{
  "name": "CountLettersAgent",
  "description": "Analyzes text to count letters and provide detailed reasoning about letter counts in questions.",
  "version": "1.0.0",
  "url": "https://localhost:9443/agents/count-letters-a2a",
  "protocolVersion": "1.0",
  "preferredTransport": "HTTP",
  "supportedInterfaces": [
    {
      "url": "https://localhost:9443/agents/count-letters-a2a",
      "protocolBinding": "HTTP+JSON",
      "protocolVersion": "1.0"
    }
  ],
  "defaultInputModes": ["text/plain"],
  "defaultOutputModes": ["text/plain"],
  "capabilities": {
    "streaming": false,
    "pushNotifications": false
  },
  "skills": [
    {
      "id": "id_count_letters_agent",
      "name": "CountLettersAgent",
      "description": "Analyzes text to count letters and provide detailed reasoning about letter counts in questions.",
      "tags": ["calculator", "letter-counting", "text-analysis"],
      "examples": [
        "How many letters are in the word 'hello'?",
        "Count the letters in this sentence",
        "What is the letter count of 'Python'?"
      ]
    }
  ]
}

{
  "jsonrpc": "2.0",
  "method": "run",
  "params": {
    "message": {
      "kind": "message",
      "messageId": "msg-1",
      "role": "User",
      "parts": [
        {
          "kind": "text",
          "text": "How many r are there in the word strawberry?"
        }
      ]
    }
  },
  "id": 1
}

# A2A Protocol Models - Request/Response structures
class A2AMessagePart(BaseModel):
    """A2A Message Part - represents content within a message"""

    kind: str
    text: str

class A2AMessage(BaseModel):
    """A2A Message - the core message structure"""

    kind: str = "message"
    role: str
    parts: list[A2AMessagePart]
    messageId: str

class A2ASendMessageParams(BaseModel):
    """A2A SendMessage parameters"""

    message: A2AMessage

class A2AJsonRpcRequest(BaseModel):
    """A2A JSON-RPC request with typed params"""

    jsonrpc: str = "2.0"
    method: str
    params: A2ASendMessageParams
    id: str | int

@router.post("/count-letters-a2a")
async def count_letters_a2a(request: A2AJsonRpcRequest) -> JSONResponse:
    # Fetch the question from the request
    question = None
        for part in request.params.message.parts:
            if part.kind == "text":
                question = part.text
                break

    # Run the calculator, which in turn creates an agent for AI Foundry
    subject = calculator()
    results = await subject.run(question)

    # Parse the response and put it in a nice answer that gets returned to the client
    answer_text = (
        f"Answer: {results.answer}\n"
        f"Final Number: {results.final_number}\n"
        f"Reasoning: {results.reasoning}\n"
        f"Chain of Thought: {results.chain_of_thought}"
    )

    a2a_message = {
        "kind": "message",
        "messageId": message_id,
        "role": "Agent",  # .NET expects PascalCase role
        "parts": [{"kind": "text", "text": answer_text}],
    }

    # Return JSON-RPC response with A2A Message object
    jsonrpc_response = JsonRpcResponse(result=a2a_message, id=request.id)
    response_data = jsonrpc_response.model_dump()

    return JSONResponse(content=response_data)

POST {{ApiService_HostAddress}}/countLetters-a2a
Accept: application/json
Content-Type: application/json

{
    "question": "I want to know the square root of the number of times the letter `r` is found in `Strawberry`?"
}

<PackageReference Include="Microsoft.Agents.AI.AzureAI" Version="1.0.0-preview.260209.1" />
<PackageReference Include="Microsoft.Agents.AI.A2A">
  <Version>1.0.0-preview.260209.1</Version>
</PackageReference>
<PackageReference Include="Microsoft.Agents.AI.Abstractions">
  <Version>1.0.0-preview.260209.1</Version>
</PackageReference>

private const string Instructions =
    @"Your job is to orchestrate the use of agents made available to you.
    You will receive a question that needs to be solved and require the use of these agents.
    If an agent can't answer or provides the wrong answer, feel free to ask it again with an updated question and remarks on
    why it should try again.
    ";

public async Task<A2aResult> Ask(string question)
{
    // Get the agent card from the A2A endpoint
    var agentCardResolver = new A2ACardResolver(new Uri(endpoint), httpClient);
    var agentCard = await agentCardResolver.GetAgentCardAsync();

    // Create the A2A agent from the card
    var agent = agentCard.AsAIAgent();

    // Create function tools from the agent's skills
    var tools = CreateFunctionTools(agent, agentCard, logger).ToList();

    AIProjectClient aiProjectClient = new(new Uri(aiOptions.ProjectEndpoint), new DefaultAzureCredential());
    var newAgent = await aiProjectClient.CreateAIAgentAsync(
        name: "A2ATestClient",
        model: aiOptions.ModelDeploymentName,
        instructions: Instructions,
        tools: tools);

    var session = await newAgent.CreateSessionAsync();

    var answer = await newAgent.RunAsync(question, session);
    logger.LogInformation("Received answer from agent");

    return new A2aResult(question, answer.Text);
}

private static IEnumerable<AITool> CreateFunctionTools(AIAgent a2aAgent, AgentCard agentCard, ILogger logger)
{
    // Useful if multiple skills are defined. This way the agent over here knows what the added agent can do.
    foreach (var skill in agentCard.Skills)
    {
        AIFunctionFactoryOptions options = new()
        {
            Name = skill.Name,
            Description = $$"""
            {
                "description": "{{skill.Description}}",
                "tags": "[{{string.Join(", ", skill.Tags ?? [])}}]",
                "examples": "[{{string.Join(", ", skill.Examples ?? [])}}]",
                "inputModes": "[{{string.Join(", ", skill.InputModes ?? [])}}]",
                "outputModes": "[{{string.Join(", ", skill.OutputModes ?? [])}}]"
            }
            """,
        };

        yield return AIFunctionFactory.Create(RunAgentAsync, options);
    }