Getting started with A2A

curl -X POST http://localhost:9090/agents/register \
  -H "Content-Type: application/json" \
  -d '{
    "agent_id": "echo-agent-01",
    "name": "Echo Agent",
    "description": "A simple echo agent for testing",
    "version": "1.0.0",
    "url": "http://localhost:18080/",
    "skills": [
      {"id": "echo", "name": "Echo", "description": "Echoes back the received message", "tags": ["test", "echo"]}
    ],
    "defaultInputModes": ["text"],
    "defaultOutputModes": ["text"],
    "protocolVersions": ["1.0"]
  }'

var card = new JsonObject
{
    ["agent_id"] = "echo-agent-01",
    ["name"] = "Echo Agent",
    ["description"] = "A simple echo agent for testing",
    ["version"] = "1.0.0",
    ["url"] = "http://localhost:18080/",
    ["skills"] = new JsonArray(new JsonObject
    {
        ["id"] = "echo", ["name"] = "Echo",
        ["description"] = "Echoes back the received message",
        ["tags"] = new JsonArray("test", "echo")
    }),
    ["defaultInputModes"] = new JsonArray("text"),
    ["defaultOutputModes"] = new JsonArray("text"),
    ["protocolVersions"] = new JsonArray("1.0")
};

using var client = new HttpClient();
var resp = await client.PostAsync(
    "http://localhost:9090/agents/register",
    new StringContent(card.ToJsonString(), System.Text.Encoding.UTF8, "application/json"));
Console.WriteLine($"Registered: {(int)resp.StatusCode}");

card := map[string]interface{}{
    "agent_id":    "echo-agent-01",
    "name":        "Echo Agent",
    "description": "A simple echo agent for testing",
    "version":     "1.0.0",
    "url":         "http://localhost:18080/",
    "skills": []map[string]interface{}{
        {
            "id":          "echo",
            "name":        "Echo",
            "description": "Echoes back the received message",
            "tags":        []string{"test", "echo"},
        },
    },
    "defaultInputModes":  []string{"text"},
    "defaultOutputModes": []string{"text"},
    "protocolVersions":   []string{"1.0"},
}
data, _ := json.Marshal(card)
resp, err := http.Post("http://localhost:9090/agents/register", "application/json", bytes.NewReader(data))
if err != nil {
    fmt.Fprintf(os.Stderr, "Registration failed: %v\n", err)
    return
}
defer resp.Body.Close()
fmt.Printf("Registered: %d\n", resp.StatusCode)

var card = Map.of(
    "agent_id", "echo-agent-01",
    "name", "Echo Agent",
    "description", "A simple echo agent for testing",
    "version", "1.0.0",
    "url", "http://localhost:18080/",
    "skills", List.of(Map.of(
        "id", "echo", "name", "Echo",
        "description", "Echoes back the received message",
        "tags", List.of("test", "echo")
    )),
    "defaultInputModes", List.of("text"),
    "defaultOutputModes", List.of("text"),
    "protocolVersions", List.of("1.0")
);

var client = HttpClient.newHttpClient();
var req = HttpRequest.newBuilder()
    .uri(URI.create("http://localhost:9090/agents/register"))
    .header("Content-Type", "application/json")
    .POST(HttpRequest.BodyPublishers.ofString(MAPPER.writeValueAsString(card)))
    .build();
var resp = client.send(req, HttpResponse.BodyHandlers.ofString());
System.out.println("Registered: " + resp.statusCode());

card = {
    "agent_id": "echo-agent-01",
    "name": "Echo Agent",
    "description": "A simple echo agent for testing",
    "version": "1.0.0",
    "url": "http://localhost:18080/",
    "skills": [
        {
            "id": "echo",
            "name": "Echo",
            "description": "Echoes back the received message",
            "tags": ["test", "echo"],
        }
    ],
    "defaultInputModes": ["text"],
    "defaultOutputModes": ["text"],
    "protocolVersions": ["1.0"],
}
async with httpx.AsyncClient() as client:
    resp = await client.post("http://localhost:9090/agents/register", json=card)
    print(f"Registered: {resp.status_code}")

const card = {
  agent_id: "echo-agent-01",
  name: "Echo Agent",
  description: "A simple echo agent for testing",
  version: "1.0.0",
  url: "http://localhost:18080/",
  skills: [
    {
      id: "echo",
      name: "Echo",
      description: "Echoes back the received message",
      tags: ["test", "echo"],
    },
  ],
  defaultInputModes: ["text"],
  defaultOutputModes: ["text"],
  protocolVersions: ["1.0"],
};

const resp = await fetch("http://localhost:9090/agents/register", {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify(card),
});
console.log("Registered:", resp.status);

curl -X POST http://localhost:9090/a2a/echo-agent-01 \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "message/send",
    "params": {
      "message": {
        "parts": [{"text": "Hello, agent!"}]
      }
    }
  }'

var payload = new JsonObject
{
    ["jsonrpc"] = "2.0",
    ["id"] = 1,
    ["method"] = "message/send",
    ["params"] = new JsonObject
    {
        ["message"] = new JsonObject
        {
            ["parts"] = new JsonArray(new JsonObject { ["text"] = "Hello, agent!" })
        }
    }
};

using var client = new HttpClient();
var resp = await client.PostAsync(
    "http://localhost:9090/a2a/echo-agent-01",
    new StringContent(payload.ToJsonString(), Encoding.UTF8, "application/json"));

Console.WriteLine($"Status: {(int)resp.StatusCode}");
var body = await resp.Content.ReadAsStringAsync();
var data = JsonNode.Parse(body)!;
Console.WriteLine(JsonSerializer.Serialize(data, new JsonSerializerOptions { WriteIndented = true }));

payload := map[string]interface{}{
    "jsonrpc": "2.0",
    "id":      1,
    "method":  "message/send",
    "params": map[string]interface{}{
        "message": map[string]interface{}{
            "parts": []map[string]interface{}{{"text": "Hello, agent!"}},
        },
    },
}

data, _ := json.Marshal(payload)
resp, err := http.Post("http://localhost:9090/a2a/echo-agent-01", "application/json", bytes.NewReader(data))
if err != nil {
    fmt.Fprintf(os.Stderr, "Request failed: %v\n", err)
    os.Exit(1)
}
defer resp.Body.Close()

body, _ := io.ReadAll(resp.Body)
fmt.Printf("Status: %d\n", resp.StatusCode)
fmt.Println(string(body))

var payload = Map.of(
    "jsonrpc", "2.0",
    "id", 1,
    "method", "message/send",
    "params", Map.of(
        "message", Map.of(
            "parts", List.of(Map.of("text", "Hello, agent!"))
        )
    )
);

var client = HttpClient.newHttpClient();
var req = HttpRequest.newBuilder()
    .uri(URI.create("http://localhost:9090/a2a/echo-agent-01"))
    .header("Content-Type", "application/json")
    .POST(HttpRequest.BodyPublishers.ofString(MAPPER.writeValueAsString(payload)))
    .build();
var resp = client.send(req, HttpResponse.BodyHandlers.ofString());
System.out.println("Status: " + resp.statusCode());

var data = MAPPER.readTree(resp.body());
System.out.println(MAPPER.writerWithDefaultPrettyPrinter().writeValueAsString(data));

payload = {
    "jsonrpc": "2.0",
    "id": 1,
    "method": "message/send",
    "params": {
        "message": {
            "parts": [{"text": "Hello, agent!"}],
        },
    },
}

async with httpx.AsyncClient() as client:
    resp = await client.post("http://localhost:9090/a2a/echo-agent-01", json=payload)
    print(f"Status: {resp.status_code}")
    data = resp.json()
    print(json.dumps(data, indent=2))
    assert "result" in data

const request = {
  jsonrpc: "2.0",
  id: 1,
  method: "message/send",
  params: {
    message: {
      parts: [{ text: "Hello, agent!" }],
    },
  },
};

const resp = await fetch("http://localhost:9090/a2a/echo-agent-01", {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify(request),
});

const data = await resp.json();
console.log("Response:", JSON.stringify(data, null, 2));