Client

var builder = WebApplication.CreateBuilder(args);

builder.AddFabrCoreClient();
builder.Services.AddRazorComponents()
    .AddInteractiveServerComponents();

var app = builder.Build();

app.UseFabrCoreClient();

app.MapRazorComponents<App>()
    .AddInteractiveServerRenderMode();

app.Run();

{
  "Orleans": {
    "ClusteringMode": "Localhost",
    "ClusterId": "fabrcore-cluster",
    "ServiceId": "fabrcore-service"
  },
  "FabrHostUrl": "http://localhost:5000"
}

@inject IClientContextFactory ClientContextFactory
@implements IAsyncDisposable

@code {
    private IClientContext? _context;

    protected override async Task OnInitializedAsync()
    {
        _context = await ClientContextFactory
            .GetOrCreateAsync(userId);
        _context.AgentMessageReceived += OnMessageReceived;
    }

    public ValueTask DisposeAsync()
    {
        if (_context != null)
            _context.AgentMessageReceived -= OnMessageReceived;
        return ValueTask.CompletedTask;
    }
}

public class NotificationService
{
    private readonly IDirectMessageSender _sender;

    public async Task NotifyAgent(string handle, string text)
    {
        await _sender.SendMessageAsync(new AgentMessage
        {
            FromHandle = "notification-service",
            ToHandle = handle,
            Message = text,
            MessageType = "notification"
        });
    }
}

var health = await context.GetAgentHealth(
    "my-agent", HealthDetailLevel.Full);

switch (health.State)
{
    case HealthState.Healthy:
        Console.WriteLine("Agent is ready");
        break;
    case HealthState.Degraded:
        Console.WriteLine($"Issues: {health.Message}");
        break;
}

public enum ClusteringMode
{
    Localhost,      // Development (in-memory)
    SqlServer,      // Production (SQL Server)
    AzureStorage    // Azure (Table Storage)
}

{
  "Orleans": {
    "ClusterId": "fabrcore-cluster",
    "ServiceId": "fabrcore-service",
    "ClusteringMode": "Localhost",
    "ConnectionRetryCount": 10,
    "ConnectionRetryDelay": "00:00:05",
    "GatewayListRefreshPeriod": "00:00:30"
  }
}

public interface IFabrHostApiClient
{
    // Agent Operations
    Task<CreateAgentsResponse> CreateAgentsAsync(string userId,
        IEnumerable<AgentConfiguration> configs, ...);
    Task<AgentHealthStatus> GetAgentHealthAsync(string userId,
        string handle, ...);
    Task<AgentMessage> ChatAsync(string userId,
        string handle, string message, ...);
    Task<AgentsListResponse> GetAgentsAsync(...);
    Task<AgentInfo?> GetAgentAsync(string key, ...);
    Task<AgentStatisticsResponse> GetAgentStatisticsAsync(...);
    Task<PurgeAgentsResponse> PurgeOldAgentsAsync(int olderThanHours, ...);

    // Configuration
    Task<ModelConfigResponse> GetModelConfigAsync(string name, ...);
    Task<ApiKeyResponse> GetApiKeyAsync(string alias, ...);

    // File Operations
    Task<string> UploadFileAsync(Stream fileStream,
        string fileName, int ttlSeconds = 3600, ...);
    Task<Stream?> GetFileAsync(string fileId, ...);
    Task<FileMetadataResponse?> GetFileInfoAsync(string fileId, ...);

    // Embeddings
    Task<EmbeddingResponse> GetEmbeddingsAsync(string text, ...);
    Task<BatchEmbeddingResponse> GetBatchEmbeddingsAsync(
        List<BatchEmbeddingItem> items, ...);
}

public class AgentConfigService
{
    private readonly IFabrHostApiClient _apiClient;

    public AgentConfigService(IFabrHostApiClient apiClient)
        => _apiClient = apiClient;

    public async Task<IChatClient> CreateChatClientAsync(string modelName)
    {
        var modelConfig = await _apiClient.GetModelConfigAsync(modelName);
        var apiKey = await _apiClient.GetApiKeyAsync(modelConfig.ApiKeyAlias);

        return new OpenAIChatClient(
            model: modelConfig.Model,
            apiKey: apiKey.Value);
    }
}

[ApiController]
[Route("api/[controller]")]
public class ChatController : ControllerBase
{
    private readonly IClientContextFactory _factory;

    public ChatController(IClientContextFactory factory)
        => _factory = factory;

    [HttpPost("send")]
    public async Task<IActionResult> SendMessage(
        [FromBody] ChatRequest request)
    {
        var userId = User
            .FindFirst(ClaimTypes.NameIdentifier)?.Value
            ?? throw new UnauthorizedAccessException();

        await using var context =
            await _factory.CreateAsync(userId);

        var response = await context
            .SendAndReceiveMessage(new AgentMessage
            {
                FromHandle = userId,
                ToHandle = request.AgentHandle,
                Message = request.Message
            });

        return Ok(new { response.Message });
    }
}

builder.Services.AddOpenTelemetry()
    .WithTracing(tracing => tracing
        .AddSource("FabrCore.Client.*"))
    .WithMetrics(metrics => metrics
        .AddMeter("FabrCore.Client.*"));