@radaros/transport 0.1.0 → 0.2.0

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { Agent, Team, Workflow } from '@radaros/core';
+import { Agent, Team, Workflow, A2AAgentCard } from '@radaros/core';
 
 interface FileUploadOptions {
     maxFileSize?: number;
@@ -79,4 +79,38 @@ interface GatewayOptions {
 
 declare function createAgentGateway(opts: GatewayOptions): void;
 
-export { type FileUploadOptions, type GatewayOptions, type RouterOptions, type SwaggerOptions, buildMultiModalInput, createAgentGateway, createAgentRouter, createFileUploadMiddleware, errorHandler, generateOpenAPISpec, requestLogger };
+interface A2AServerOptions {
+    agents: Record<string, Agent>;
+    basePath?: string;
+    provider?: {
+        organization: string;
+        url?: string;
+    };
+    version?: string;
+}
+
+/**
+ * Mount an A2A-compliant server on an Express app.
+ *
+ * - Serves `/.well-known/agent.json` with the Agent Card
+ * - Handles JSON-RPC 2.0 requests at the basePath for message/send, message/stream, tasks/get, tasks/cancel
+ */
+declare function createA2AServer(app: any, opts: A2AServerOptions): void;
+
+/**
+ * Generate an A2A Agent Card from a RadarOS Agent.
+ * The card is served at /.well-known/agent.json per the A2A spec.
+ */
+declare function generateAgentCard(agent: Agent, serverUrl: string, provider?: {
+    organization: string;
+    url?: string;
+}, version?: string): A2AAgentCard;
+/**
+ * Generate a combined Agent Card that lists multiple agents as skills.
+ */
+declare function generateMultiAgentCard(agents: Record<string, Agent>, serverUrl: string, provider?: {
+    organization: string;
+    url?: string;
+}, version?: string): A2AAgentCard;
+
+export { type A2AServerOptions, type FileUploadOptions, type GatewayOptions, type RouterOptions, type SwaggerOptions, buildMultiModalInput, createA2AServer, createAgentGateway, createAgentRouter, createFileUploadMiddleware, errorHandler, generateAgentCard, generateMultiAgentCard, generateOpenAPISpec, requestLogger };

package/dist/index.js

@@ -717,12 +717,362 @@ function createAgentGateway(opts) {
     );
   });
 }
+
+// src/a2a/a2a-server.ts
+import { createRequire as createRequire4 } from "module";
+import { randomUUID } from "crypto";
+
+// src/a2a/agent-card.ts
+function generateAgentCard(agent, serverUrl, provider, version) {
+  const skills = agent.tools.map((tool) => ({
+    id: tool.name,
+    name: tool.name,
+    description: tool.description
+  }));
+  if (skills.length === 0) {
+    skills.push({
+      id: "general",
+      name: "General",
+      description: typeof agent.instructions === "string" ? agent.instructions.slice(0, 200) : "General-purpose agent"
+    });
+  }
+  const description = typeof agent.instructions === "string" ? agent.instructions : `RadarOS agent: ${agent.name}`;
+  return {
+    name: agent.name,
+    description,
+    url: serverUrl,
+    version: version ?? "1.0.0",
+    provider,
+    capabilities: {
+      streaming: true,
+      pushNotifications: false,
+      stateTransitionHistory: true
+    },
+    skills,
+    defaultInputModes: ["text/plain"],
+    defaultOutputModes: ["text/plain"],
+    supportedInputModes: ["text/plain", "application/json"],
+    supportedOutputModes: ["text/plain", "application/json"]
+  };
+}
+function generateMultiAgentCard(agents, serverUrl, provider, version) {
+  const skills = Object.entries(agents).map(
+    ([name, agent]) => ({
+      id: name,
+      name: agent.name,
+      description: typeof agent.instructions === "string" ? agent.instructions.slice(0, 200) : `Agent: ${name}`
+    })
+  );
+  return {
+    name: "RadarOS Agent Server",
+    description: `Multi-agent server with ${Object.keys(agents).length} agents: ${Object.keys(agents).join(", ")}`,
+    url: serverUrl,
+    version: version ?? "1.0.0",
+    provider,
+    capabilities: {
+      streaming: true,
+      pushNotifications: false,
+      stateTransitionHistory: true
+    },
+    skills,
+    defaultInputModes: ["text/plain"],
+    defaultOutputModes: ["text/plain"],
+    supportedInputModes: ["text/plain", "application/json"],
+    supportedOutputModes: ["text/plain", "application/json"]
+  };
+}
+
+// src/a2a/a2a-server.ts
+var _require4 = createRequire4(import.meta.url);
+var TaskStore = class {
+  tasks = /* @__PURE__ */ new Map();
+  get(id) {
+    return this.tasks.get(id);
+  }
+  set(task) {
+    this.tasks.set(task.id, task);
+  }
+  updateState(id, state, message) {
+    const task = this.tasks.get(id);
+    if (!task) return;
+    task.status = {
+      state,
+      message,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+};
+function a2aPartsToText(parts) {
+  return parts.filter((p) => p.kind === "text").map((p) => p.text).join("\n");
+}
+function textToA2AParts(text) {
+  return [{ kind: "text", text }];
+}
+function jsonRpcError(id, code, message) {
+  return { jsonrpc: "2.0", id, error: { code, message } };
+}
+function resolveAgent(agents, message) {
+  const meta = message.metadata;
+  const agentName = meta?.agentName;
+  if (agentName && agents[agentName]) {
+    return agents[agentName];
+  }
+  const names = Object.keys(agents);
+  if (names.length === 1) {
+    return agents[names[0]];
+  }
+  const textContent = a2aPartsToText(message.parts).toLowerCase();
+  for (const [name, agent] of Object.entries(agents)) {
+    if (textContent.includes(name.toLowerCase())) {
+      return agent;
+    }
+  }
+  return agents[names[0]] ?? null;
+}
+function createA2AServer(app, opts) {
+  const express = _require4("express");
+  const basePath = opts.basePath ?? "/";
+  const taskStore = new TaskStore();
+  const serverUrl = basePath === "/" ? "" : basePath;
+  const agentCard = generateMultiAgentCard(
+    opts.agents,
+    serverUrl || "/",
+    opts.provider,
+    opts.version
+  );
+  app.get("/.well-known/agent.json", (_req, res) => {
+    res.json(agentCard);
+  });
+  app.use(basePath, express.json());
+  app.post(basePath, async (req, res) => {
+    const body = req.body;
+    if (!body || body.jsonrpc !== "2.0" || !body.method) {
+      return res.status(400).json(
+        jsonRpcError(body?.id ?? 0, -32600, "Invalid JSON-RPC request")
+      );
+    }
+    try {
+      switch (body.method) {
+        case "message/send":
+          return await handleMessageSend(req, res, body, opts.agents, taskStore);
+        case "message/stream":
+          return await handleMessageStream(req, res, body, opts.agents, taskStore);
+        case "tasks/get":
+          return handleTasksGet(res, body, taskStore);
+        case "tasks/cancel":
+          return handleTasksCancel(res, body, taskStore);
+        default:
+          return res.json(
+            jsonRpcError(body.id, -32601, `Method '${body.method}' not found`)
+          );
+      }
+    } catch (err) {
+      return res.json(
+        jsonRpcError(body.id, -32e3, err.message ?? "Internal error")
+      );
+    }
+  });
+}
+async function handleMessageSend(_req, res, body, agents, store) {
+  const params = body.params;
+  const message = params?.message;
+  if (!message?.parts?.length) {
+    return res.json(jsonRpcError(body.id, -32602, "Missing message.parts"));
+  }
+  const agent = resolveAgent(agents, message);
+  if (!agent) {
+    return res.json(jsonRpcError(body.id, -32602, "No matching agent found"));
+  }
+  const taskId = randomUUID();
+  const input = a2aPartsToText(message.parts);
+  const task = {
+    id: taskId,
+    sessionId: params?.sessionId ?? void 0,
+    status: { state: "submitted", timestamp: (/* @__PURE__ */ new Date()).toISOString() },
+    history: [message],
+    metadata: { agentName: agent.name }
+  };
+  store.set(task);
+  store.updateState(taskId, "working");
+  try {
+    const result = await agent.run(input, {
+      sessionId: task.sessionId
+    });
+    const responseParts = textToA2AParts(result.text);
+    if (result.structured) {
+      responseParts.push({
+        kind: "data",
+        data: result.structured
+      });
+    }
+    const agentMessage = {
+      role: "agent",
+      parts: responseParts,
+      messageId: randomUUID(),
+      taskId
+    };
+    task.history.push(agentMessage);
+    if (result.toolCalls?.length) {
+      task.artifacts = result.toolCalls.map((tc) => ({
+        artifactId: tc.toolCallId,
+        name: tc.toolName,
+        parts: [
+          {
+            kind: "text",
+            text: typeof tc.result === "string" ? tc.result : tc.result.content
+          }
+        ]
+      }));
+    }
+    store.updateState(taskId, "completed", agentMessage);
+    const response = {
+      jsonrpc: "2.0",
+      id: body.id,
+      result: store.get(taskId)
+    };
+    res.json(response);
+  } catch (err) {
+    const errorMessage = {
+      role: "agent",
+      parts: [{ kind: "text", text: `Error: ${err.message}` }],
+      taskId
+    };
+    store.updateState(taskId, "failed", errorMessage);
+    res.json(jsonRpcError(body.id, -32e3, err.message));
+  }
+}
+async function handleMessageStream(_req, res, body, agents, store) {
+  const params = body.params;
+  const message = params?.message;
+  if (!message?.parts?.length) {
+    return res.json(jsonRpcError(body.id, -32602, "Missing message.parts"));
+  }
+  const agent = resolveAgent(agents, message);
+  if (!agent) {
+    return res.json(jsonRpcError(body.id, -32602, "No matching agent found"));
+  }
+  const taskId = randomUUID();
+  const input = a2aPartsToText(message.parts);
+  const task = {
+    id: taskId,
+    sessionId: params?.sessionId ?? void 0,
+    status: { state: "submitted", timestamp: (/* @__PURE__ */ new Date()).toISOString() },
+    history: [message],
+    metadata: { agentName: agent.name }
+  };
+  store.set(task);
+  res.writeHead(200, {
+    "Content-Type": "text/event-stream",
+    "Cache-Control": "no-cache",
+    Connection: "keep-alive"
+  });
+  const sendEvent = (data) => {
+    res.write(`data: ${JSON.stringify(data)}
+
+`);
+  };
+  store.updateState(taskId, "working");
+  sendEvent({
+    jsonrpc: "2.0",
+    id: body.id,
+    result: store.get(taskId)
+  });
+  try {
+    let fullText = "";
+    for await (const chunk of agent.stream(input, {
+      sessionId: task.sessionId
+    })) {
+      if (chunk.type === "text") {
+        fullText += chunk.text;
+        sendEvent({
+          jsonrpc: "2.0",
+          id: body.id,
+          result: {
+            id: taskId,
+            status: {
+              state: "working",
+              message: {
+                role: "agent",
+                parts: [{ kind: "text", text: chunk.text }]
+              },
+              timestamp: (/* @__PURE__ */ new Date()).toISOString()
+            }
+          }
+        });
+      }
+    }
+    const agentMessage = {
+      role: "agent",
+      parts: textToA2AParts(fullText),
+      messageId: randomUUID(),
+      taskId
+    };
+    task.history.push(agentMessage);
+    store.updateState(taskId, "completed", agentMessage);
+    sendEvent({
+      jsonrpc: "2.0",
+      id: body.id,
+      result: store.get(taskId)
+    });
+    res.end();
+  } catch (err) {
+    const errorMessage = {
+      role: "agent",
+      parts: [{ kind: "text", text: `Error: ${err.message}` }],
+      taskId
+    };
+    store.updateState(taskId, "failed", errorMessage);
+    sendEvent({
+      jsonrpc: "2.0",
+      id: body.id,
+      result: store.get(taskId)
+    });
+    res.end();
+  }
+}
+function handleTasksGet(res, body, store) {
+  const params = body.params;
+  const taskId = params?.id;
+  if (!taskId) {
+    return res.json(jsonRpcError(body.id, -32602, "Missing task id"));
+  }
+  const task = store.get(taskId);
+  if (!task) {
+    return res.json(jsonRpcError(body.id, -32602, `Task '${taskId}' not found`));
+  }
+  const historyLength = params?.historyLength;
+  const result = { ...task };
+  if (historyLength && result.history) {
+    result.history = result.history.slice(-historyLength);
+  }
+  res.json({ jsonrpc: "2.0", id: body.id, result });
+}
+function handleTasksCancel(res, body, store) {
+  const params = body.params;
+  const taskId = params?.id;
+  if (!taskId) {
+    return res.json(jsonRpcError(body.id, -32602, "Missing task id"));
+  }
+  const task = store.get(taskId);
+  if (!task) {
+    return res.json(jsonRpcError(body.id, -32602, `Task '${taskId}' not found`));
+  }
+  store.updateState(taskId, "canceled");
+  res.json({
+    jsonrpc: "2.0",
+    id: body.id,
+    result: store.get(taskId)
+  });
+}
 export {
   buildMultiModalInput,
+  createA2AServer,
   createAgentGateway,
   createAgentRouter,
   createFileUploadMiddleware,
   errorHandler,
+  generateAgentCard,
+  generateMultiAgentCard,
   generateOpenAPISpec,
   requestLogger
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@radaros/transport",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -20,7 +20,7 @@
     "typescript": "^5.6.0"
   },
   "peerDependencies": {
-    "@radaros/core": "^0.1.0",
+    "@radaros/core": "^0.2.0",
     "@types/express": "^4.0.0 || ^5.0.0",
     "express": "^4.0.0 || ^5.0.0",
     "multer": ">=1.4.0",

package/src/a2a/a2a-server.ts

@@ -0,0 +1,391 @@
+import { createRequire } from "node:module";
+import { randomUUID } from "node:crypto";
+import type { Agent } from "@radaros/core";
+import type {
+  A2ATask,
+  A2AMessage,
+  A2APart,
+  A2AJsonRpcRequest,
+  A2AJsonRpcResponse,
+  A2ATaskState,
+} from "@radaros/core";
+import { generateMultiAgentCard } from "./agent-card.js";
+import type { A2AServerOptions } from "./types.js";
+
+const _require = createRequire(import.meta.url);
+
+/**
+ * In-memory task store. Can be replaced with a persistent implementation.
+ */
+class TaskStore {
+  private tasks = new Map<string, A2ATask>();
+
+  get(id: string): A2ATask | undefined {
+    return this.tasks.get(id);
+  }
+
+  set(task: A2ATask): void {
+    this.tasks.set(task.id, task);
+  }
+
+  updateState(id: string, state: A2ATaskState, message?: A2AMessage): void {
+    const task = this.tasks.get(id);
+    if (!task) return;
+    task.status = {
+      state,
+      message,
+      timestamp: new Date().toISOString(),
+    };
+  }
+}
+
+function a2aPartsToText(parts: A2APart[]): string {
+  return parts
+    .filter((p): p is { kind: "text"; text: string } => p.kind === "text")
+    .map((p) => p.text)
+    .join("\n");
+}
+
+function textToA2AParts(text: string): A2APart[] {
+  return [{ kind: "text", text }];
+}
+
+function jsonRpcError(
+  id: string | number,
+  code: number,
+  message: string
+): A2AJsonRpcResponse {
+  return { jsonrpc: "2.0", id, error: { code, message } };
+}
+
+function resolveAgent(
+  agents: Record<string, Agent>,
+  message: A2AMessage
+): Agent | null {
+  const meta = message.metadata as Record<string, unknown> | undefined;
+  const agentName = meta?.agentName as string | undefined;
+
+  if (agentName && agents[agentName]) {
+    return agents[agentName];
+  }
+
+  const names = Object.keys(agents);
+  if (names.length === 1) {
+    return agents[names[0]];
+  }
+
+  const textContent = a2aPartsToText(message.parts).toLowerCase();
+  for (const [name, agent] of Object.entries(agents)) {
+    if (textContent.includes(name.toLowerCase())) {
+      return agent;
+    }
+  }
+
+  return agents[names[0]] ?? null;
+}
+
+/**
+ * Mount an A2A-compliant server on an Express app.
+ *
+ * - Serves `/.well-known/agent.json` with the Agent Card
+ * - Handles JSON-RPC 2.0 requests at the basePath for message/send, message/stream, tasks/get, tasks/cancel
+ */
+export function createA2AServer(app: any, opts: A2AServerOptions): void {
+  const express = _require("express");
+  const basePath = opts.basePath ?? "/";
+  const taskStore = new TaskStore();
+
+  const serverUrl =
+    basePath === "/" ? "" : basePath;
+
+  const agentCard = generateMultiAgentCard(
+    opts.agents,
+    serverUrl || "/",
+    opts.provider,
+    opts.version
+  );
+
+  app.get("/.well-known/agent.json", (_req: any, res: any) => {
+    res.json(agentCard);
+  });
+
+  app.use(basePath, express.json());
+
+  app.post(basePath, async (req: any, res: any) => {
+    const body: A2AJsonRpcRequest = req.body;
+
+    if (!body || body.jsonrpc !== "2.0" || !body.method) {
+      return res.status(400).json(
+        jsonRpcError(body?.id ?? 0, -32600, "Invalid JSON-RPC request")
+      );
+    }
+
+    try {
+      switch (body.method) {
+        case "message/send":
+          return await handleMessageSend(req, res, body, opts.agents, taskStore);
+        case "message/stream":
+          return await handleMessageStream(req, res, body, opts.agents, taskStore);
+        case "tasks/get":
+          return handleTasksGet(res, body, taskStore);
+        case "tasks/cancel":
+          return handleTasksCancel(res, body, taskStore);
+        default:
+          return res.json(
+            jsonRpcError(body.id, -32601, `Method '${body.method}' not found`)
+          );
+      }
+    } catch (err: any) {
+      return res.json(
+        jsonRpcError(body.id, -32000, err.message ?? "Internal error")
+      );
+    }
+  });
+}
+
+async function handleMessageSend(
+  _req: any,
+  res: any,
+  body: A2AJsonRpcRequest,
+  agents: Record<string, Agent>,
+  store: TaskStore
+): Promise<void> {
+  const params = body.params as any;
+  const message: A2AMessage = params?.message;
+
+  if (!message?.parts?.length) {
+    return res.json(jsonRpcError(body.id, -32602, "Missing message.parts"));
+  }
+
+  const agent = resolveAgent(agents, message);
+  if (!agent) {
+    return res.json(jsonRpcError(body.id, -32602, "No matching agent found"));
+  }
+
+  const taskId = randomUUID();
+  const input = a2aPartsToText(message.parts);
+
+  const task: A2ATask = {
+    id: taskId,
+    sessionId: (params?.sessionId as string) ?? undefined,
+    status: { state: "submitted", timestamp: new Date().toISOString() },
+    history: [message],
+    metadata: { agentName: agent.name },
+  };
+  store.set(task);
+  store.updateState(taskId, "working");
+
+  try {
+    const result = await agent.run(input, {
+      sessionId: task.sessionId,
+    });
+
+    const responseParts: A2APart[] = textToA2AParts(result.text);
+
+    if (result.structured) {
+      responseParts.push({
+        kind: "data",
+        data: result.structured as Record<string, unknown>,
+      });
+    }
+
+    const agentMessage: A2AMessage = {
+      role: "agent",
+      parts: responseParts,
+      messageId: randomUUID(),
+      taskId,
+    };
+
+    task.history!.push(agentMessage);
+
+    if (result.toolCalls?.length) {
+      task.artifacts = result.toolCalls.map((tc) => ({
+        artifactId: tc.toolCallId,
+        name: tc.toolName,
+        parts: [
+          {
+            kind: "text" as const,
+            text: typeof tc.result === "string" ? tc.result : tc.result.content,
+          },
+        ],
+      }));
+    }
+
+    store.updateState(taskId, "completed", agentMessage);
+
+    const response: A2AJsonRpcResponse = {
+      jsonrpc: "2.0",
+      id: body.id,
+      result: store.get(taskId),
+    };
+
+    res.json(response);
+  } catch (err: any) {
+    const errorMessage: A2AMessage = {
+      role: "agent",
+      parts: [{ kind: "text", text: `Error: ${err.message}` }],
+      taskId,
+    };
+    store.updateState(taskId, "failed", errorMessage);
+
+    res.json(jsonRpcError(body.id, -32000, err.message));
+  }
+}
+
+async function handleMessageStream(
+  _req: any,
+  res: any,
+  body: A2AJsonRpcRequest,
+  agents: Record<string, Agent>,
+  store: TaskStore
+): Promise<void> {
+  const params = body.params as any;
+  const message: A2AMessage = params?.message;
+
+  if (!message?.parts?.length) {
+    return res.json(jsonRpcError(body.id, -32602, "Missing message.parts"));
+  }
+
+  const agent = resolveAgent(agents, message);
+  if (!agent) {
+    return res.json(jsonRpcError(body.id, -32602, "No matching agent found"));
+  }
+
+  const taskId = randomUUID();
+  const input = a2aPartsToText(message.parts);
+
+  const task: A2ATask = {
+    id: taskId,
+    sessionId: (params?.sessionId as string) ?? undefined,
+    status: { state: "submitted", timestamp: new Date().toISOString() },
+    history: [message],
+    metadata: { agentName: agent.name },
+  };
+  store.set(task);
+
+  res.writeHead(200, {
+    "Content-Type": "text/event-stream",
+    "Cache-Control": "no-cache",
+    Connection: "keep-alive",
+  });
+
+  const sendEvent = (data: any) => {
+    res.write(`data: ${JSON.stringify(data)}\n\n`);
+  };
+
+  store.updateState(taskId, "working");
+  sendEvent({
+    jsonrpc: "2.0",
+    id: body.id,
+    result: store.get(taskId),
+  });
+
+  try {
+    let fullText = "";
+    for await (const chunk of agent.stream(input, {
+      sessionId: task.sessionId,
+    })) {
+      if (chunk.type === "text") {
+        fullText += chunk.text;
+        sendEvent({
+          jsonrpc: "2.0",
+          id: body.id,
+          result: {
+            id: taskId,
+            status: {
+              state: "working",
+              message: {
+                role: "agent",
+                parts: [{ kind: "text", text: chunk.text }],
+              },
+              timestamp: new Date().toISOString(),
+            },
+          },
+        });
+      }
+    }
+
+    const agentMessage: A2AMessage = {
+      role: "agent",
+      parts: textToA2AParts(fullText),
+      messageId: randomUUID(),
+      taskId,
+    };
+    task.history!.push(agentMessage);
+    store.updateState(taskId, "completed", agentMessage);
+
+    sendEvent({
+      jsonrpc: "2.0",
+      id: body.id,
+      result: store.get(taskId),
+    });
+
+    res.end();
+  } catch (err: any) {
+    const errorMessage: A2AMessage = {
+      role: "agent",
+      parts: [{ kind: "text", text: `Error: ${err.message}` }],
+      taskId,
+    };
+    store.updateState(taskId, "failed", errorMessage);
+
+    sendEvent({
+      jsonrpc: "2.0",
+      id: body.id,
+      result: store.get(taskId),
+    });
+    res.end();
+  }
+}
+
+function handleTasksGet(
+  res: any,
+  body: A2AJsonRpcRequest,
+  store: TaskStore
+): void {
+  const params = body.params as any;
+  const taskId = params?.id;
+
+  if (!taskId) {
+    return res.json(jsonRpcError(body.id, -32602, "Missing task id"));
+  }
+
+  const task = store.get(taskId);
+  if (!task) {
+    return res.json(jsonRpcError(body.id, -32602, `Task '${taskId}' not found`));
+  }
+
+  const historyLength = params?.historyLength as number | undefined;
+  const result = { ...task };
+  if (historyLength && result.history) {
+    result.history = result.history.slice(-historyLength);
+  }
+
+  res.json({ jsonrpc: "2.0", id: body.id, result } as A2AJsonRpcResponse);
+}
+
+function handleTasksCancel(
+  res: any,
+  body: A2AJsonRpcRequest,
+  store: TaskStore
+): void {
+  const params = body.params as any;
+  const taskId = params?.id;
+
+  if (!taskId) {
+    return res.json(jsonRpcError(body.id, -32602, "Missing task id"));
+  }
+
+  const task = store.get(taskId);
+  if (!task) {
+    return res.json(jsonRpcError(body.id, -32602, `Task '${taskId}' not found`));
+  }
+
+  store.updateState(taskId, "canceled");
+
+  res.json({
+    jsonrpc: "2.0",
+    id: body.id,
+    result: store.get(taskId),
+  } as A2AJsonRpcResponse);
+}

package/src/a2a/agent-card.ts

@@ -0,0 +1,95 @@
+import type { Agent } from "@radaros/core";
+import type {
+  A2AAgentCard,
+  A2ASkill,
+} from "@radaros/core";
+
+/**
+ * Generate an A2A Agent Card from a RadarOS Agent.
+ * The card is served at /.well-known/agent.json per the A2A spec.
+ */
+export function generateAgentCard(
+  agent: Agent,
+  serverUrl: string,
+  provider?: { organization: string; url?: string },
+  version?: string
+): A2AAgentCard {
+  const skills: A2ASkill[] = agent.tools.map((tool) => ({
+    id: tool.name,
+    name: tool.name,
+    description: tool.description,
+  }));
+
+  if (skills.length === 0) {
+    skills.push({
+      id: "general",
+      name: "General",
+      description:
+        typeof agent.instructions === "string"
+          ? agent.instructions.slice(0, 200)
+          : "General-purpose agent",
+    });
+  }
+
+  const description =
+    typeof agent.instructions === "string"
+      ? agent.instructions
+      : `RadarOS agent: ${agent.name}`;
+
+  return {
+    name: agent.name,
+    description,
+    url: serverUrl,
+    version: version ?? "1.0.0",
+    provider,
+    capabilities: {
+      streaming: true,
+      pushNotifications: false,
+      stateTransitionHistory: true,
+    },
+    skills,
+    defaultInputModes: ["text/plain"],
+    defaultOutputModes: ["text/plain"],
+    supportedInputModes: ["text/plain", "application/json"],
+    supportedOutputModes: ["text/plain", "application/json"],
+  };
+}
+
+/**
+ * Generate a combined Agent Card that lists multiple agents as skills.
+ */
+export function generateMultiAgentCard(
+  agents: Record<string, Agent>,
+  serverUrl: string,
+  provider?: { organization: string; url?: string },
+  version?: string
+): A2AAgentCard {
+  const skills: A2ASkill[] = Object.entries(agents).map(
+    ([name, agent]) => ({
+      id: name,
+      name: agent.name,
+      description:
+        typeof agent.instructions === "string"
+          ? agent.instructions.slice(0, 200)
+          : `Agent: ${name}`,
+    })
+  );
+
+  return {
+    name: "RadarOS Agent Server",
+    description: `Multi-agent server with ${Object.keys(agents).length} agents: ${Object.keys(agents).join(", ")}`,
+    url: serverUrl,
+    version: version ?? "1.0.0",
+    provider,
+    capabilities: {
+      streaming: true,
+      pushNotifications: false,
+      stateTransitionHistory: true,
+    },
+    skills,
+    defaultInputModes: ["text/plain"],
+    defaultOutputModes: ["text/plain"],
+    supportedInputModes: ["text/plain", "application/json"],
+    supportedOutputModes: ["text/plain", "application/json"],
+  };
+}

package/src/a2a/types.ts

@@ -0,0 +1,11 @@
+import type { Agent } from "@radaros/core";
+
+export interface A2AServerOptions {
+  agents: Record<string, Agent>;
+  basePath?: string;
+  provider?: {
+    organization: string;
+    url?: string;
+  };
+  version?: string;
+}

package/src/index.ts

@@ -7,3 +7,8 @@ export type { FileUploadOptions } from "./express/file-upload.js";
 
 export { createAgentGateway } from "./socketio/gateway.js";
 export type { GatewayOptions } from "./socketio/types.js";
+
+// A2A
+export { createA2AServer } from "./a2a/a2a-server.js";
+export { generateAgentCard, generateMultiAgentCard } from "./a2a/agent-card.js";
+export type { A2AServerOptions } from "./a2a/types.js";