Microsoft.AutoGen.Core

using Microsoft.AutoGen.Core;
using Microsoft.AutoGen.Contracts;

public class MyAgent : BaseAgent
{
    public MyAgent(
        AgentId id,
        IAgentRuntime runtime,
        string description,
        ILogger<BaseAgent>? logger = null)
        : base(id, runtime, description, logger)
    {
    }
}

using Microsoft.AutoGen.Core;

var runtime = new InProcessRuntime();

// Register agent factory
await runtime.RegisterAgentFactoryAsync(
    type: new AgentType("worker"),
    factoryFunc: async (id, rt) => new WorkerAgent(id, rt)
);

// Send message
var response = await runtime.SendMessageAsync(
    message: "Task",
    recipient: new AgentId("worker", "instance1")
);

public interface IAgent : ISaveState
{
    AgentId Id { get; }
    AgentMetadata Metadata { get; }
    ValueTask<object?> OnMessageAsync(object message, MessageContext messageContext);
}

public interface IHostableAgent : IAgent
{
    ValueTask CloseAsync();
}

public interface IAgentRuntime : ISaveState
{
    ValueTask<object?> SendMessageAsync(
        object message,
        AgentId recipient,
        AgentId? sender = null,
        string? messageId = null,
        CancellationToken cancellationToken = default);

    ValueTask PublishMessageAsync(
        object message,
        TopicId topic,
        AgentId? sender = null,
        string? messageId = null,
        CancellationToken cancellationToken = default);

    ValueTask<AgentType> RegisterAgentFactoryAsync(
        AgentType type,
        Func<AgentId, IAgentRuntime, ValueTask<IHostableAgent>> factoryFunc);

    ValueTask AddSubscriptionAsync(ISubscriptionDefinition subscription);

    ValueTask RemoveSubscriptionAsync(string subscriptionId);
}

using Microsoft.AutoGen.Contracts;

public class WorkerAgent : BaseAgent, IHandle<TaskMessage>
{
    public async ValueTask<object?> HandleAsync(
        TaskMessage message,
        MessageContext context)
    {
        // Process task
        return new ResultMessage { Result = "Completed" };
    }
}

using Microsoft.AutoGen.Contracts;

// Create agent ID
var agentId = new AgentId(type: "worker", key: "instance_1");

// From string
var parsed = AgentId.FromStr("worker/instance_1");

// Convert to string
string str = agentId.ToString(); // "worker/instance_1"

using Microsoft.AutoGen.Contracts;

var workerType = new AgentType("worker");

using Microsoft.AutoGen.Contracts;

var topic = new TopicId(type: "events", source: "system");

public struct AgentMetadata
{
    public string Type { get; set; }
    public string Key { get; set; }
    public string Description { get; set; }
}

var proxy = await runtime.TryGetAgentProxyAsync(agentId);
var result = await proxy.SendAsync("Hello");

public class MessageContext
{
    public AgentId? Sender { get; }
    public TopicId? TopicId { get; }
    public string MessageId { get; }
}

using Microsoft.AutoGen.Core;

var subscription = new TypeSubscription(
    topicType: "tasks",
    agentType: "worker"
);

await runtime.AddSubscriptionAsync(subscription);

var subscription = new TypePrefixSubscription(
    topicTypePrefix: "task.",
    agentType: "worker"
);

[TypeSubscription("tasks")]
public class WorkerAgent : BaseAgent, IHandle<TaskMessage>
{
    // ...
}

public interface ISaveState
{
    ValueTask<JsonElement> SaveStateAsync();
    ValueTask LoadStateAsync(JsonElement state);
}

using Microsoft.AutoGen.Core;

var app = await AgentsApp.CreateAsync();

// Register agents
await app.RegisterAgentAsync<WorkerAgent>("worker");

// Start the application
await app.StartAsync();

throw new CantHandleException("Unsupported message type");

throw new UndeliverableException("Agent not found");

using Microsoft.AutoGen.Core;

var handlers = ReflectionHelper.GetMessageHandlers(agentType);

var invoker = new HandlerInvoker(methodInfo, target);
var result = await invoker.InvokeAsync(message, context);

using System.Diagnostics;

public static readonly ActivitySource s_source =
    new("Microsoft.AutoGen.Core.Agent");

using var activity = s_source.StartActivity("HandleMessage");