Agntcy.Slim 2.1.2

SLIM C# SDK

C# SDK for SLIM (Secure Low-Latency Interactive Messaging).

This SDK provides an idiomatic C# API built on top of auto-generated bindings from uniffi-bindgen-cs.

Requirements

• .NET 8.0 or higher
• Rust toolchain (for building native libraries from source)
• Task (optional, for build automation)

Quick Start

Using NuGet Package

dotnet add package Agntcy.Slim

The NuGet package includes native libraries for all supported platforms. No additional setup required!

using Agntcy.Slim;

Slim.Initialize();
var service = Slim.GetGlobalService();
// ...
Slim.Shutdown();

Building from Source

To build the complete SDK, you need artifacts from the Rust bindings build:

# From the root of the repository
cd dotnet
task ci BINDGEN_TARGET=x86_64-unknown-linux-gnu PROFILE=release

For development on a single platform:

task generate
task build
task test

API Overview

Main Classes

Transport Authentication (gRPC connection)

Separate from the app identity passed to CreateApp, the gRPC connection to a SLIM node can carry its own credentials.

OIDC, client side (client-credentials flow):

var clientConfig = Slim.NewInsecureClientConfig("http://127.0.0.1:46357")
    .WithOidc(new SlimOidcConfig
    {
        IssuerUrl = "https://auth.example.com",
        ClientId = "my-client",
        ClientSecret = "s3cr3t",
        Scope = "openid profile",
        Timeout = TimeSpan.FromSeconds(30)
    });

using var service = Slim.GetGlobalService();
var connId = service.Connect(clientConfig);

For the refresh-token flow set RefreshToken (or RefreshTokenFile, which is rewritten in place as tokens rotate) instead of ClientSecret.

Server side, verifying incoming JWTs against the issuer's JWKS endpoint, optionally restricting access by claim:

var serverConfig = Slim.NewInsecureServerConfig("127.0.0.1:46357")
    .WithOidc(new SlimOidcConfig
    {
        IssuerUrl = "https://auth.example.com",
        Audience = "slim",                       // required for verification
        JwksTtl = TimeSpan.FromHours(1),
        ClaimCacheTtl = TimeSpan.FromMinutes(1),
        Policy = new SlimOidcPolicy.Cel("\"admin\" in claims.groups")
    });

await service.RunServerAsync(serverConfig);

Policy accepts SlimOidcPolicy.Cel, SlimOidcPolicy.Rego (which must define package slim.auth with default allow = false), or SlimOidcPolicy.RegoFile. Client-only properties (Scope, Timeout) and server-only properties (JwksTtl, ClaimCacheTtl, Policy) are ignored by the other side. Read back what a config carries via SlimClientConfig.Oidc / SlimServerConfig.Oidc, which return null for other auth modes.

From a config file — Slim.NewClientConfigFromJson accepts a full gRPC client config, covering TLS material, backoff, and every authentication mode (basic, static_jwt, jwt, spire, oidc). The examples read the same document from SLIM_CLIENT_CONFIG:

{
  "endpoint": "http://127.0.0.1:46357",
  "tls": { "insecure": true },
  "auth": {
    "type": "oidc",
    "issuer_url": "https://auth.example.com",
    "client_id": "my-client",
    "client_secret": "s3cr3t",
    "audience": "slim",
    "policy": { "cel": "\"admin\" in claims.groups" }
  }
}

The schema matches data-plane/core/config/src/grpc/schema/client-config.schema.json in the slim repo.

Examples

The SDK includes complete working examples demonstrating real-world usage:

• Point-to-Point (Slim.Examples.PointToPoint): 1:1 messaging with request/reply pattern
• Group Messaging (Slim.Examples.Group): Group sessions with moderator/participant roles
• slimrpc (Slim.Examples.SlimRpc): Protobuf RPC over SLIM (see SLIMRPC.md)

Quick Start:

# Run receiver
dotnet run --project Slim.Examples.PointToPoint -- --local org/alice/v1

# Run sender (in another terminal)
dotnet run --project Slim.Examples.PointToPoint -- \
  --local org/bob/v1 --remote org/alice/v1 --message "Hello"

slimrpc Example:

Requires a running SLIM server. See the SLIM repository for instructions on running a server (for example, from the slim repo: cd data-plane && cargo run --bin slim -- --config ./config/base/server-config.yaml).

# Generate proto code (requires buf and protoc-gen-slimrpc-csharp)
task slimrpc:generate-proto

# Run server (in one terminal)
dotnet run --project Slim.Examples.SlimRpc -- --mode server

# Run client (in another terminal)
dotnet run --project Slim.Examples.SlimRpc -- --mode client

See example source code in Slim.Examples.* projects for full implementation details and command-line options.

Running Tests

The SDK includes smoke tests that don't require a running SLIM server:

task test

For full integration testing with a SLIM server, you would need to:

1. Start a SLIM server instance
2. Run the example applications to verify functionality

See the Slim.Examples.* projects for working integration examples.

Development

Available Tasks

task                  # List all available tasks
task ci               # Run complete CI pipeline: generate, copy runtimes, build, test, pack
task format           # Format the C# code using dotnet format
task lint             # Check code formatting without applying changes
task generate         # Generate C# bindings from artifacts (requires ARTIFACTS_DIR)
task copy:runtimes    # Copy runtime libraries from artifacts to runtimes directory
task build            # Build .NET solution (expects bindings already generated)
task test             # Run smoke tests (no server required)
task pack             # Create NuGet package (expects runtimes already copied)
task clean            # Clean all build artifacts

Regenerating Bindings

If the Rust bindings change, you need to rebuild the Rust library first, then regenerate C# bindings:

task generate

Platform Support

NuGet Package

The NuGet package includes native libraries for all supported platforms using the standard runtimes/{rid}/native/ structure. When you install the package, .NET automatically selects the correct native library for your platform.

# Install the package
dotnet add package Agntcy.Slim

# Build and run - native library is automatically included
dotnet run

Publishing to NuGet

The NuGet package is automatically published when a release tag is pushed (e.g., slim-bindings-v0.1.0). The release workflow:

1. Builds native libraries for all supported platforms
2. Tests bindings locally with all platform libraries
3. Creates a NuGet package with native libraries for all platforms
4. Publishes to NuGet.org

License

Apache-2.0 - See LICENSE for details.

Related Projects

• Go bindings - Go bindings for SLIM
• Python bindings - Python bindings for SLIM
• uniffi-bindgen-cs - C# bindings generator for UniFFI