Agent Card Endpoint

GET /api/a2a/card

{
  "name": "Routa Multi-Agent Coordinator",
  "description": "Multi-agent coordination platform that orchestrates AI agents for software development tasks. Supports creating CRAFTER, GATE, and DEVELOPER agents to plan, implement, and verify code changes.",
  "protocolVersion": "0.3.0",
  "version": "0.2.0",
  "url": "http://localhost:3000/api/a2a/rpc",
  "skills": [...],
  "capabilities": {
    "streaming": true,
    "pushNotifications": false
  },
  "defaultInputModes": ["text/plain"],
  "defaultOutputModes": ["text/plain", "application/json"],
  "additionalInterfaces": [...],
  "documentationUrl": "http://localhost:3000/a2a"
}

{
  "id": "agent-coordination",
  "name": "Agent Coordination",
  "description": "Create, delegate tasks to, and coordinate multiple AI agents for complex software development workflows",
  "tags": ["coordination", "multi-agent", "orchestration", "planning"],
  "examples": [
    "Create a new feature for user authentication",
    "Fix the bug in the payment processing module",
    "Refactor the database layer to use connection pooling"
  ],
  "inputModes": ["text/plain"],
  "outputModes": ["text/plain", "application/json"]
}

{
  "id": "software-development",
  "name": "Software Development",
  "description": "Implement code changes, write tests, and deliver working software using specialized CRAFTER agents",
  "tags": ["coding", "implementation", "development", "engineering"],
  "examples": [
    "Implement a REST API endpoint for user management",
    "Write unit tests for the authentication service",
    "Add TypeScript types to the existing JavaScript codebase"
  ],
  "inputModes": ["text/plain"],
  "outputModes": ["text/plain", "application/json"]
}

{
  "id": "code-verification",
  "name": "Code Verification",
  "description": "Review, validate, and verify code quality using specialized GATE agents",
  "tags": ["review", "verification", "quality", "testing"],
  "examples": [
    "Review the pull request for security vulnerabilities",
    "Verify the implementation meets the acceptance criteria",
    "Check the code for performance issues"
  ],
  "inputModes": ["text/plain"],
  "outputModes": ["text/plain", "application/json"]
}

{
  "streaming": true
}

GET /api/a2a/rpc?sessionId=<id>

{
  "pushNotifications": false
}

{
  "url": "http://localhost:3000/api/a2a/rpc",
  "transport": "JSONRPC"
}

{
  "url": "http://localhost:3000/api/a2a/message",
  "transport": "HTTP"
}

["text/plain"]

["text/plain", "application/json"]

curl http://localhost:3000/api/a2a/card

import { getA2aSessionRegistry } from "@/core/a2a";

const registry = getA2aSessionRegistry();
const card = registry.generateAgentCard("http://localhost:3000");

console.log(JSON.stringify(card, null, 2));

fetch("http://localhost:3000/api/a2a/card")
  .then(res => res.json())
  .then(card => {
    console.log("Agent:", card.name);
    console.log("Skills:", card.skills.map(s => s.name));
    console.log("RPC URL:", card.url);
  });

import { mapAgentRoleToSkillId } from "@/core/a2a";
import { AgentRole } from "@/core/models/agent";

// Map Routa agent roles to A2A skills
const skillId = mapAgentRoleToSkillId(AgentRole.CRAFTER);
console.log(skillId); // "development"

const gateSkillId = mapAgentRoleToSkillId(AgentRole.GATE);
console.log(gateSkillId); // "verification"

const routaSkillId = mapAgentRoleToSkillId(AgentRole.ROUTA);
console.log(routaSkillId); // "coordination"

async function discoverAndUseRouta() {
  // 1. Fetch agent card
  const response = await fetch("http://localhost:3000/api/a2a/card");
  const card = await response.json();
  
  console.log("Discovered:", card.name);
  console.log("Protocol:", card.protocolVersion);
  
  // 2. Find a skill
  const devSkill = card.skills.find(s => s.id === "software-development");
  if (devSkill) {
    console.log("\nSkill:", devSkill.name);
    console.log("Description:", devSkill.description);
    console.log("Examples:");
    devSkill.examples.forEach(ex => console.log(`  - ${ex}`));
  }
  
  // 3. Use the RPC endpoint
  const rpcUrl = card.url;
  const rpcResponse = await fetch(rpcUrl, {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({
      jsonrpc: "2.0",
      method: "session/new",
      params: {
        provider: "opencode",
        workspaceId: "default",
        message: "Implement user authentication",
      },
      id: 1,
    }),
  });
  
  const result = await rpcResponse.json();
  console.log("\nSession created:", result.result.sessionId);
}

discoverAndUseRouta();

const registry = getA2aSessionRegistry();

// Local development
const localCard = registry.generateAgentCard("http://localhost:3000");
console.log(localCard.url); // http://localhost:3000/api/a2a/rpc

// Production
const prodCard = registry.generateAgentCard("https://routa.example.com");
console.log(prodCard.url); // https://routa.example.com/api/a2a/rpc

// app/api/a2a/card/route.ts
export async function GET(request: Request) {
  const url = new URL(request.url);
  const baseUrl = `${url.protocol}//${url.host}`;
  
  const registry = getA2aSessionRegistry();
  const card = registry.generateAgentCard(baseUrl);
  
  return Response.json(card);
}

{
  "protocolVersion": "0.3.0"
}

{
  "version": "0.2.0"
}

{
  "documentationUrl": "http://localhost:3000/a2a"
}

// Automatic CORS headers
Access-Control-Allow-Origin: *
Access-Control-Allow-Methods: GET, OPTIONS
Access-Control-Allow-Headers: Content-Type

Cache-Control: public, max-age=3600