Agents

using System.ComponentModel;
using FabrCore.Core;
using FabrCore.Sdk;
using Microsoft.Agents.AI;
using Microsoft.Extensions.AI;

[AgentAlias("my-agent")]
[Description("A helpful assistant")]
[FabrCoreCapabilities("Answers questions using configured tools")]
[FabrCoreNote("Configure tools and model access before use")]
public class MyAgent : FabrCoreAgentProxy
{
    private AIAgent? _agent;
    private AgentSession? _session;

    public MyAgent(
        AgentConfiguration config,
        IServiceProvider serviceProvider,
        IFabrCoreAgentHost fabrcoreAgentHost)
        : base(config, serviceProvider, fabrcoreAgentHost) { }

    public override async Task OnInitialize()
    {
        // Resolve plugins, standalone tools, and MCP tools from config
        var tools = await ResolveConfiguredToolsAsync();

        var result = await CreateChatClientAgent(
            "default",
            threadId: config.Handle ?? fabrcoreAgentHost.GetHandle(),
            tools: tools);
        _agent = result.Agent;
        _session = result.Session;
    }

    public override async Task<AgentMessage> OnMessage(AgentMessage message)
    {
        var response = message.Response();
        var chatMessage = new ChatMessage(ChatRole.User, message.Message);

        await foreach (var update in _agent!.RunStreamingAsync(
            chatMessage, _session!))
        {
            response.Message += update.Text;
        }

        return response;
    }

}

var created = await CreateChatClientAgent(
    "default",
    threadId: config.Handle,
    tools: [AIFunctionFactory.Create(plugin.MyTool)]
);
agent = created.Agent;
thread = created.Session;

[AgentAlias("CustomerSupport")]
[AgentAlias("support")]
public class CustomerSupportAgent : FabrCoreAgentProxy
{
    // ...
}

[AgentAlias("job-agent")]
[Description("Manufacturing job management agent")]
[FabrCoreCapabilities("Manages manufacturing jobs — lookup, status tracking, priority changes, and ship date queries.")]
public class JobAgent : FabrCoreAgentProxy
{
    // ...
}

[AgentAlias("job-agent")]
[FabrCoreNote("Requires a job number in context before most tools will work.")]
[FabrCoreNote("Do not use for quoting — use the quotes-agent instead.")]
public class JobAgent : FabrCoreAgentProxy
{
    // ...
}

[AgentAlias("internal-worker")]
[FabrCoreHidden]
public class InternalWorkerAgent : FabrCoreAgentProxy
{
    // Hidden from /fabrcoreapi/discovery but still fully operational
}

var userInfoMemory = new UserInfoMemory(chatClient);

var created = await CreateChatClientAgent(
    "default",
    threadId: config.Handle,
    tools: [AIFunctionFactory.Create(plugin.Echo)],
    configureOptions: options =>
    {
        options.AIContextProviders = [.. options.AIContextProviders ?? [], userInfoMemory];
    }
);
agent = created.Agent;
thread = created.Session;

public override async Task<ProxyHealthStatus> GetHealth(HealthDetailLevel detailLevel)
{
    var health = await base.GetHealth(detailLevel);
    return health with { CustomMetrics = new Dictionary<string, string>
        { ["application_status"] = "ready" } };
}

private async Task<List<AgentHealthStatus>> GetHealthyAgentsAsync(
    IEnumerable<string> handles)
{
    var results = new List<AgentHealthStatus>();
    foreach (var handle in handles)
    {
        var health = await fabrcoreAgentHost.GetAgentHealth(
            handle, HealthDetailLevel.Detailed);
        if (health.State == HealthState.Healthy && health.IsConfigured)
            results.Add(health);
    }
    return results;
}

// Use SendAndReceiveMessage for synchronous delegation
var result = await fabrcoreAgentHost.SendAndReceiveMessage(new AgentMessage
{
    ToHandle = targetHandle,
    FromHandle = fabrcoreAgentHost.GetHandle(),
    Kind = MessageKind.Request,
    Message = userMessage
});