Communication

[AgentAlias("Orchestrator")]
public class OrchestratorAgent : FabrCoreAgentProxy
{
    private A2AAgentProxy? supportAgent;
    private A2AAgentProxy? reviewAgent;

    public override async Task OnInitialize()
    {
        // Wrap remote FabrCore agents as AIAgent instances
        // Format: "agentType:agentHandle"
        supportAgent = new A2AAgentProxy(
            fabrAgentHost, "CustomerSupport:support1");
        reviewAgent = new A2AAgentProxy(
            fabrAgentHost, "ReviewAgent:reviewer1");
    }

    public override async Task<AgentMessage> OnMessage(AgentMessage message)
    {
        var response = message.Response();

        // Use in a Microsoft Agent Framework workflow
        var workflow = new WorkflowBuilder(supportAgent)
            .AddEdge(supportAgent, reviewAgent)
            .Build();

        var result = await InProcessExecution.RunAsync(
            workflow, new ChatMessage(ChatRole.User, message.Message));
        response.Message = result.Text;

        return response;
    }
}

public override async Task<AgentMessage> OnMessage(AgentMessage message)
{
    var response = message.Response(); // Copies Id, TraceId, sets Kind=Response
    response.Message = "Your response here";
    return response;
}

public override async Task<AgentMessage> OnMessage(AgentMessage message)
{
    // Route by channel
    if (string.Equals(message.Channel, "agent",
        StringComparison.OrdinalIgnoreCase))
        return await HandleAgentResponse(message);

    // Ignore fire-and-forget notifications
    if (message.Kind == MessageKind.OneWay)
        return message.Response();

    // Default: handle user messages
    return await HandleUserMessage(message);
}

private string? _callerHandle;

public override async Task<AgentMessage> OnMessage(AgentMessage message)
{
    _callerHandle = message.FromHandle;

    await SendProgressAsync("Analyzing your request...");
    // ... do work
    await SendProgressAsync("Processing results...");
    // ... return response
}

private async Task SendProgressAsync(string text)
{
    if (_callerHandle is null) return;
    await fabrAgentHost.SendMessage(new AgentMessage
    {
        ToHandle = _callerHandle,
        FromHandle = fabrAgentHost.GetHandle(),
        Kind = MessageKind.OneWay,
        MessageType = "thinking",
        Message = text
    });
}

await fabrAgentHost.SendEvent(new AgentMessage
{
    FromHandle = fabrAgentHost.GetHandle(),
    ToHandle = "monitor-agent",
    MessageType = "status-update",
    Message = "{ \"status\": \"processing\" }"
});

public override async Task OnEvent(AgentMessage message)
{
    switch (message.MessageType)
    {
        case "status-update":
            await HandleStatusUpdate(message);
            break;
        case "notification":
            await HandleNotification(message);
            break;
    }
}

public override async Task OnInitialize()
{
    fabrAgentHost.RegisterTimer(
        timerName: "heartbeat",
        messageType: "timer:heartbeat",
        message: null,
        dueTime: TimeSpan.FromSeconds(1),
        period: TimeSpan.FromSeconds(5));
}

await fabrAgentHost.RegisterReminder(
    reminderName: "hourly-report",
    messageType: "reminder:hourly-report",
    message: null,
    dueTime: TimeSpan.FromMinutes(1),
    period: TimeSpan.FromHours(1));

builder.AddFabrCoreServer(new FabrCoreServerOptions
{
    AdditionalAssemblies = [typeof(MyAgent).Assembly]
}
.UseAclProvider<SqlAclProvider>());

{
  "Acl": {
    "Rules": [
      {
        "OwnerPattern": "system",
        "AgentPattern": "*",
        "CallerPattern": "*",
        "Permission": "Message,Read"
      },
      {
        "OwnerPattern": "shared",
        "AgentPattern": "analytics_*",
        "CallerPattern": "group:premium",
        "Permission": "Message,Read"
      }
    ],
    "Groups": {
      "admins": ["alice", "bob"],
      "premium": ["alice", "charlie"]
    }
  }
}