C# SDK

Installation (Coming Soon)

dotnet add package Sieve.Moderation

Quick Example (Coming Soon)

using Sieve.Moderation;

var client = new SieveClient(Environment.GetEnvironmentVariable("SIEVE_API_KEY"));

var result = await client.Moderate.TextAsync(new TextModerationRequest {
    Content = "Message to moderate",
    Context = "chat",
    UserId = "player123"
});

if (result.Action == ModerationAction.Block) {
    // Find the highest-scoring category
    var topCategory = result.Categories.OrderByDescending(c => c.Value.Score).First().Key;
    Console.WriteLine($"Blocked for: {topCategory}");
}

Using the API Directly

Until the SDK is available, use HttpClient to call the Sieve API:

using System.Net.Http;
using System.Net.Http.Json;
using System.Text.Json.Serialization;

public class CategoryResult
{
    [JsonPropertyName("score")]
    public double Score { get; set; }

    [JsonPropertyName("threshold")]
    public double Threshold { get; set; }

    [JsonPropertyName("flagged")]
    public bool Flagged { get; set; }
}

public class ModerationResult
{
    [JsonPropertyName("action")]
    public string Action { get; set; }

    [JsonPropertyName("categories")]
    public Dictionary<string, CategoryResult> Categories { get; set; }

    [JsonPropertyName("pipeline_tier")]
    public string PipelineTier { get; set; }

    [JsonPropertyName("latency_ms")]
    public int LatencyMs { get; set; }
}

public class SieveClient
{
    private readonly HttpClient _http;

    public SieveClient(string apiKey)
    {
        _http = new HttpClient();
        _http.BaseAddress = new Uri("https://api.getsieve.dev");
        _http.DefaultRequestHeaders.Add("Authorization", $"Bearer {apiKey}");
    }

    public async Task<ModerationResult> ModerateTextAsync(
        string content, string context = "default", string userId = null)
    {
        var response = await _http.PostAsJsonAsync("/v1/moderate/text", new {
            content,
            context,
            user_id = userId
        });

        response.EnsureSuccessStatusCode();
        return await response.Content.ReadFromJsonAsync<ModerationResult>();
    }
}

// Usage
var client = new SieveClient(Environment.GetEnvironmentVariable("SIEVE_API_KEY"));
var result = await client.ModerateTextAsync("Hello world", "chat", "player123");

// Find the highest-scoring category
var topCategory = result.Categories.OrderByDescending(c => c.Value.Score).First().Key;

switch (result.Action)
{
    case "block":
        Console.WriteLine($"Blocked for: {topCategory}");
        break;
    case "flag":
        Console.WriteLine($"Flagged for review: {topCategory}");
        break;
    case "allow":
        Console.WriteLine("Content is clean");
        break;
}

using UnityEngine;
using UnityEngine.Networking;
using System.Collections;
using System.Text;

public class SieveModeration : MonoBehaviour
{
    private const string API_URL = "https://api.getsieve.dev/v1/moderate/text";
    private string _apiKey;

    void Start()
    {
        _apiKey = "mod_live_your_key"; // Load from config in production
    }

    public IEnumerator ModerateChat(string message, string userId,
        System.Action<string> onResult)
    {
        var json = JsonUtility.ToJson(new ModerationRequest {
            content = message,
            context = "chat",
            user_id = userId
        });

        var request = new UnityWebRequest(API_URL, "POST");
        request.uploadHandler = new UploadHandlerRaw(Encoding.UTF8.GetBytes(json));
        request.downloadHandler = new DownloadHandlerBuffer();
        request.SetRequestHeader("Content-Type", "application/json");
        request.SetRequestHeader("Authorization", $"Bearer {_apiKey}");

        yield return request.SendWebRequest();

        if (request.result == UnityWebRequest.Result.Success)
        {
            var result = JsonUtility.FromJson<ModerationResponse>(
                request.downloadHandler.text);
            onResult(result.action);
        }
        else
        {
            // Fail open
            onResult("allow");
        }
    }

    [System.Serializable]
    private class ModerationRequest
    {
        public string content;
        public string context;
        public string user_id;
    }

    [System.Serializable]
    private class ModerationResponse
    {
        public string action;
    }
}

ASP.NET Integration

// Program.cs - Register as a service
builder.Services.AddSingleton(sp =>
    new SieveClient(builder.Configuration["Sieve:ApiKey"]));

// CommentController.cs
[ApiController]
[Route("api/[controller]")]
public class CommentController : ControllerBase
{
    private readonly SieveClient _sieve;

    public CommentController(SieveClient sieve) => _sieve = sieve;

    [HttpPost]
    public async Task<IActionResult> CreateComment([FromBody] CreateCommentRequest req)
    {
        var modResult = await _sieve.ModerateTextAsync(
            req.Body, "comment", userId: User.Identity.Name);

        if (modResult.Action == "block")
            return UnprocessableEntity("Comment violates community guidelines.");

        // Save comment
        var comment = await _commentService.CreateAsync(req);
        return Ok(comment);
    }
}