Building Agents

public abstract class AIAgent
{
    public string Id { get; }
    public virtual string? Name { get; }
    public virtual string? Description { get; }
    
    public abstract Task<AgentResponse> RunAsync(
        IEnumerable<ChatMessage> messages,
        AgentSession? session = null,
        AgentRunOptions? options = null,
        CancellationToken cancellationToken = default);
    
    public abstract IAsyncEnumerable<AgentResponseUpdate> RunStreamingAsync(
        IEnumerable<ChatMessage> messages,
        AgentSession? session = null,
        AgentRunOptions? options = null,
        CancellationToken cancellationToken = default);
    
    public ValueTask<AgentSession> CreateSessionAsync(
        CancellationToken cancellationToken = default);
}

using Azure.AI.OpenAI;
using Azure.Identity;
using Microsoft.Agents.AI;
using OpenAI.Chat;

var endpoint = Environment.GetEnvironmentVariable("AZURE_OPENAI_ENDPOINT");
var deploymentName = Environment.GetEnvironmentVariable("AZURE_OPENAI_DEPLOYMENT_NAME") ?? "gpt-4o-mini";

// Create an agent using Azure OpenAI
AIAgent agent = new AzureOpenAIClient(
    new Uri(endpoint),
    new DefaultAzureCredential())
    .GetChatClient(deploymentName)
    .AsAIAgent(
        instructions: "You are a helpful assistant.",
        name: "Assistant");

// Run the agent
AgentResponse response = await agent.RunAsync("What is the capital of France?");
Console.WriteLine(response.Text);

using Microsoft.Extensions.AI;

AIAgent agent = chatClient.AsAIAgent(new ChatClientAgentOptions()
{
    Name = "ResearchAssistant",
    Description = "An agent that helps with research tasks",
    ChatOptions = new ChatOptions()
    {
        Instructions = "You are an expert research assistant.",
        Temperature = 0.7f,
        MaxOutputTokens = 2000
    }
});

// Single-turn interaction
AgentResponse response = await agent.RunAsync("Tell me a joke about programming.");
Console.WriteLine(response.Text);

// Stream responses for real-time output
await foreach (var update in agent.RunStreamingAsync("Write a short story about AI."))
{
    Console.Write(update.Text);
}

// Create a session for the conversation
AgentSession session = await agent.CreateSessionAsync();

// First turn
var response1 = await agent.RunAsync("Tell me a joke about pirates.", session);
Console.WriteLine(response1.Text);

// Second turn - agent remembers previous context
var response2 = await agent.RunAsync(
    "Now tell it in the voice of a pirate's parrot.", 
    session);
Console.WriteLine(response2.Text);

AgentSession session = await agent.CreateSessionAsync();

await foreach (var update in agent.RunStreamingAsync("Tell me a joke.", session))
{
    Console.Write(update.Text);
}

await foreach (var update in agent.RunStreamingAsync("Make it funnier.", session))
{
    Console.Write(update.Text);
}

using System.ComponentModel;
using System.Text.Json.Serialization;

[Description("Information about a city")]
public class CityInfo
{
    [JsonPropertyName("name")]
    public string? Name { get; set; }
    
    [JsonPropertyName("population")]
    public int? Population { get; set; }
    
    [JsonPropertyName("country")]
    public string? Country { get; set; }
}

AIAgent agent = chatClient.AsAIAgent(new ChatClientAgentOptions()
{
    Name = "CityExpert",
    ChatOptions = new ChatOptions()
    {
        Instructions = "You provide information about cities.",
        ResponseFormat = ChatResponseFormat.ForJsonSchema<CityInfo>()
    }
});

AgentResponse response = await agent.RunAsync(
    "Tell me about Paris, France.");

// Deserialize the structured output
CityInfo city = JsonSerializer.Deserialize<CityInfo>(response.Text);
Console.WriteLine($"City: {city.Name}, Population: {city.Population}");

// Directly get typed result
AgentResponse<CityInfo> response = await agent.RunAsync<CityInfo>(
    "Tell me about Tokyo, Japan.");

CityInfo city = response.Result;
Console.WriteLine($"City: {city.Name}");

// Create a specialized agent
AIAgent weatherAgent = weatherChatClient.AsAIAgent(
    name: "WeatherAgent",
    instructions: "You provide weather information for cities.");

// Convert agent to a function tool
AIFunction weatherTool = weatherAgent.AsAIFunction();

// Use it as a tool in another agent
AIAgent mainAgent = chatClient.AsAIAgent(
    instructions: "You are a travel assistant.",
    tools: [weatherTool]);

var response = await mainAgent.RunAsync(
    "What's the weather like in Paris?");

using Microsoft.Extensions.AI;

AIAgent baseAgent = chatClient.AsAIAgent(
    instructions: "You are a helpful assistant.");

// Build agent with middleware
AIAgent enhancedAgent = baseAgent
    .AsBuilder()
    .Use(LoggingMiddleware)
    .Use(FilteringMiddleware)
    .Build();

async Task<AgentResponse> LoggingMiddleware(
    IEnumerable<ChatMessage> messages,
    AgentSession? session,
    AgentRunOptions? options,
    AIAgent innerAgent,
    CancellationToken cancellationToken)
{
    Console.WriteLine($"[{DateTime.Now}] Agent invoked");
    var response = await innerAgent.RunAsync(messages, session, options, cancellationToken);
    Console.WriteLine($"[{DateTime.Now}] Agent completed");
    return response;
}

// Create a new session
AgentSession session = await agent.CreateSessionAsync();

// Serialize session state
JsonElement sessionData = await agent.SerializeSessionAsync(session);

// Store in database, file, etc.
string json = JsonSerializer.Serialize(sessionData);

// Later, deserialize
JsonElement restored = JsonSerializer.Deserialize<JsonElement>(json);
AgentSession restoredSession = await agent.DeserializeSessionAsync(restored);

// Continue conversation
var response = await agent.RunAsync("Continue our discussion.", restoredSession);

var options = new ChatClientAgentRunOptions(new ChatOptions()
{
    Temperature = 0.9f,
    MaxOutputTokens = 500,
    Tools = [additionalTool]
});

var response = await agent.RunAsync(
    "Be creative!", 
    session, 
    options);