A2A-agent

Getting Started

Lägg till det nödvändiga NuGet-paketet i projektet:

dotnet add package Microsoft.Agents.AI.A2A --prerelease

Agentidentifiering

Innan du kommunicerar med en fjärransluten A2A-agent måste du identifiera den och skapa en AIAgent instans. A2A-protokollet definierar tre identifieringsstrategier som var och en stöds av Agent Framework.

Well-Known URI

A2A-agenter kan göra agentkortet identifierbart på en standardiserad sökväg: https://{domain}/.well-known/agent-card.json. A2ACardResolver Använd för att hämta kortet och skapa en agent i ett enda anrop:

using A2A;
using Microsoft.Agents.AI;

// Initialize a resolver pointing at the remote agent's host.
A2ACardResolver resolver = new(new Uri("https://a2a-agent.example.com"));

// Resolve the agent card and create an AIAgent in one step.
AIAgent agent = await resolver.GetAIAgentAsync();

// Use the agent.
Console.WriteLine(await agent.RunAsync("Hello!"));

Catalog-Based identifiering

I företagsmiljöer eller offentliga marknadsplatser hanteras agentkort ofta av ett centralt register. Om du redan har hämtat AgentCard från ett sådant register konverterar du det direkt till en AIAgent:

using A2A;
using Microsoft.Agents.AI;

// Assume agentCard was retrieved from a registry or catalog.
AgentCard agentCard = await GetAgentCardFromRegistryAsync("travel-planner");

AIAgent agent = agentCard.AsAIAgent();

Console.WriteLine(await agent.RunAsync("Plan a trip to Paris."));

Direktkonfiguration

För nära kopplade system eller utvecklingsscenarier där agentslutpunkten är känd i förväg skapar du en A2AClient direkt och konverterar den till :AIAgent

using A2A;
using Microsoft.Agents.AI;

// Create a client pointing at the known agent endpoint.
A2AClient a2aClient = new(new Uri("https://a2a-agent.example.com"));

AIAgent agent = a2aClient.AsAIAgent(name: "my-agent", description: "A helpful assistant.");

Console.WriteLine(await agent.RunAsync("What can you help me with?"));

Protokollval

A2A-agenter kan exponera flera protokollbindningar som HTTP+JSON och JSON-RPC. Som standard föredras HTTP+JSON framför JSON-RPC. Använd A2AClientOptions.PreferredBindings för att explicit kontrollera vilken protokollbindning som används:

using A2A;
using Microsoft.Agents.AI;

A2ACardResolver agentCardResolver = new(new Uri("https://a2a-agent.example.com"));

AgentCard agentCard = await agentCardResolver.GetAgentCardAsync();

// Prefer HTTP+JSON protocol binding. For JSON-RPC, set PreferredBindings = [ProtocolBindingNames.JsonRpc]
A2AClientOptions options = new()
{
    PreferredBindings = [ProtocolBindingNames.HttpJson]
};

AIAgent agent = agentCard.AsAIAgent(options: options);

Console.WriteLine(await agent.RunAsync("Tell me a joke about a pirate."));

Streaming

A2A stöder strömmande svar via Server-Sent-händelser. Använd RunStreamingAsync för att ta emot uppdateringar i realtid när fjärragenten bearbetar begäran:

using A2A;
using Microsoft.Agents.AI;

A2ACardResolver resolver = new(new Uri("https://a2a-agent.example.com"));
AIAgent agent = await resolver.GetAIAgentAsync();

await foreach (var update in agent.RunStreamingAsync("Write a short story about a robot."))
{
    if (!string.IsNullOrEmpty(update.Text))
    {
        Console.Write(update.Text);
    }
}

Bakgrundssvar

A2A-agenter stöder bakgrundssvar för hantering av långvariga åtgärder. När en fjärransluten A2A-agent returnerar en uppgift i stället för ett omedelbart meddelande, tillhandahåller Agent Framework en fortsättningstoken som du kan använda för att söka efter resultat eller återansluta till avbrutna strömmar.

Avsökning för slutförande av aktivitet

För scenarier som inte strömmas använder du AllowBackgroundResponses för att ta emot en fortsättningstoken och avsöka tills uppgiften har slutförts:

using A2A;
using Microsoft.Agents.AI;

A2ACardResolver resolver = new(new Uri("https://a2a-agent.example.com"));
AIAgent agent = await resolver.GetAIAgentAsync();

AgentSession session = await agent.CreateSessionAsync();

// AllowBackgroundResponses must be true so the server returns immediately with a continuation token
// instead of blocking until the task is complete.
AgentRunOptions options = new() { AllowBackgroundResponses = true };

// Start the initial run with a long-running task.
AgentResponse response = await agent.RunAsync(
    "Conduct a comprehensive analysis of quantum computing applications in cryptography.",
    session,
    options: options);

// Poll until the response is complete.
while (response.ContinuationToken is { } token)
{
    // Wait before polling again.
    await Task.Delay(TimeSpan.FromSeconds(2));

    // Continue with the token.
    response = await agent.RunAsync(session, options: new AgentRunOptions { ContinuationToken = token });
}

Console.WriteLine(response);

Stream Reconnection

I strömningsscenarier kan varje uppdatering innehålla en fortsättningstoken. Om strömmen avbryts använder du token för att återansluta och hämta svarsströmmen från början:

using A2A;
using Microsoft.Agents.AI;
using Microsoft.Extensions.AI;

A2ACardResolver resolver = new(new Uri("https://a2a-agent.example.com"));
AIAgent agent = await resolver.GetAIAgentAsync();

AgentSession session = await agent.CreateSessionAsync();

ResponseContinuationToken? continuationToken = null;

await foreach (var update in agent.RunStreamingAsync(
    "Conduct a comprehensive analysis of quantum computing applications in cryptography.",
    session))
{
    // Save the continuation token to reconnect later if the stream is interrupted.
    // Continuation tokens are only returned for long-running tasks. If the A2A agent
    // returns a message instead of a task, the continuation token will not be initialized.
    if (update.ContinuationToken is { } token)
    {
        continuationToken = token;
    }
}

// If the stream was interrupted and a continuation token was captured,
// reconnect to the response stream using the saved continuation token.
if (continuationToken is not null)
{
    await foreach (var update in agent.RunStreamingAsync(
        session,
        options: new() { ContinuationToken = continuationToken }))
    {
        if (!string.IsNullOrEmpty(update.Text))
        {
            Console.WriteLine(update.Text);
        }
    }
}