@radaros/transport 0.3.20 → 0.3.22

package/dist/index.cjs

@@ -0,0 +1,2032 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  MCPManager: () => MCPManager,
+  buildMultiModalInput: () => buildMultiModalInput,
+  createA2AServer: () => createA2AServer,
+  createAdminRouter: () => createAdminRouter,
+  createAgentGateway: () => createAgentGateway,
+  createAgentRouter: () => createAgentRouter,
+  createBrowserGateway: () => createBrowserGateway,
+  createFileUploadMiddleware: () => createFileUploadMiddleware,
+  createVoiceGateway: () => createVoiceGateway,
+  errorHandler: () => errorHandler,
+  generateAgentCard: () => generateAgentCard,
+  generateMultiAgentCard: () => generateMultiAgentCard,
+  generateOpenAPISpec: () => generateOpenAPISpec,
+  requestLogger: () => requestLogger
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/a2a/a2a-server.ts
+var import_node_crypto = require("crypto");
+var import_node_module = require("module");
+
+// 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 import_meta = {};
+var _require = (0, import_node_module.createRequire)(import_meta.url);
+var TaskStore = class {
+  tasks = /* @__PURE__ */ new Map();
+  maxTasks = 1e4;
+  get(id) {
+    return this.tasks.get(id);
+  }
+  set(task) {
+    if (this.tasks.size >= this.maxTasks) {
+      for (const [id, t] of this.tasks) {
+        if (t.status?.state === "completed" || t.status?.state === "canceled") {
+          this.tasks.delete(id);
+          break;
+        }
+      }
+    }
+    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 = _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, 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 = (0, import_node_crypto.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: (0, import_node_crypto.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 = (0, import_node_crypto.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: (0, import_node_crypto.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)
+  });
+}
+
+// src/express/admin-router.ts
+var import_node_module2 = require("module");
+var import_core2 = require("@radaros/core");
+
+// src/express/mcp-manager.ts
+var import_core = require("@radaros/core");
+var MCPManager = class {
+  servers = /* @__PURE__ */ new Map();
+  /** Add a server config. Auto-generates an id from the name if not provided. */
+  add(config, id) {
+    const serverId = id ?? config.name;
+    if (this.servers.has(serverId)) {
+      throw new Error(`MCP server "${serverId}" already exists`);
+    }
+    const provider = new import_core.MCPToolProvider(config);
+    const entry = {
+      id: serverId,
+      config,
+      provider,
+      status: "disconnected",
+      toolCount: 0
+    };
+    this.servers.set(serverId, entry);
+    return this.summarize(entry);
+  }
+  /** Connect a server by id. Discovers tools on success. */
+  async connect(id) {
+    const entry = this.getEntry(id);
+    entry.status = "connecting";
+    entry.error = void 0;
+    try {
+      await entry.provider.connect();
+      const tools = await entry.provider.getTools();
+      entry.status = "connected";
+      entry.toolCount = tools.length;
+      entry.connectedAt = /* @__PURE__ */ new Date();
+    } catch (err) {
+      entry.status = "error";
+      entry.error = err.message;
+    }
+    return this.summarize(entry);
+  }
+  /** Disconnect a server by id. */
+  async disconnect(id) {
+    const entry = this.getEntry(id);
+    try {
+      await entry.provider.close();
+    } catch {
+    }
+    entry.status = "disconnected";
+    entry.toolCount = 0;
+    entry.connectedAt = void 0;
+    return this.summarize(entry);
+  }
+  /** Remove a server entirely. Disconnects first if connected. */
+  async remove(id) {
+    const entry = this.getEntry(id);
+    if (entry.status === "connected" || entry.status === "connecting") {
+      try {
+        await entry.provider.close();
+      } catch {
+      }
+    }
+    this.servers.delete(id);
+  }
+  /** Get all tools from all connected servers, merged into one array. */
+  async getAllTools() {
+    const all = [];
+    for (const entry of this.servers.values()) {
+      if (entry.status === "connected") {
+        try {
+          const tools = await entry.provider.getTools();
+          all.push(...tools);
+        } catch {
+        }
+      }
+    }
+    return all;
+  }
+  /** Get tools from a specific server. */
+  async getTools(id) {
+    const entry = this.getEntry(id);
+    if (entry.status !== "connected") {
+      throw new Error(`MCP server "${id}" is not connected`);
+    }
+    return entry.provider.getTools();
+  }
+  /** List all registered servers. */
+  list() {
+    return Array.from(this.servers.values()).map((e) => this.summarize(e));
+  }
+  /** Get a single server summary. */
+  get(id) {
+    return this.summarize(this.getEntry(id));
+  }
+  has(id) {
+    return this.servers.has(id);
+  }
+  /** Disconnect all servers. */
+  async closeAll() {
+    const promises = Array.from(this.servers.values()).map(async (entry) => {
+      if (entry.status === "connected") {
+        try {
+          await entry.provider.close();
+        } catch {
+        }
+        entry.status = "disconnected";
+        entry.toolCount = 0;
+      }
+    });
+    await Promise.all(promises);
+  }
+  getEntry(id) {
+    const entry = this.servers.get(id);
+    if (!entry) throw new Error(`MCP server "${id}" not found`);
+    return entry;
+  }
+  summarize(entry) {
+    return {
+      id: entry.id,
+      name: entry.config.name,
+      transport: entry.config.transport,
+      url: entry.config.url,
+      command: entry.config.command,
+      status: entry.status,
+      toolCount: entry.toolCount,
+      error: entry.error,
+      connectedAt: entry.connectedAt?.toISOString()
+    };
+  }
+};
+
+// src/express/admin-router.ts
+var import_meta2 = {};
+var _require2 = (0, import_node_module2.createRequire)(import_meta2.url);
+function createAdminRouter(opts) {
+  let express;
+  try {
+    express = _require2("express");
+  } catch {
+    throw new Error("express is required for createAdminRouter. Install it: npm install express");
+  }
+  const router = express.Router();
+  const mcpManager = opts?.mcpManager ?? new MCPManager();
+  if (opts?.middleware) {
+    for (const mw of opts.middleware) router.use(mw);
+  }
+  if (!opts?.middleware?.length && process.env.NODE_ENV === "production") {
+    console.warn(
+      "[admin-router] WARNING: Admin routes mounted without authentication middleware. These endpoints can add MCP servers, execute tools, and modify configurations. Pass middleware in AdminRouterOptions to secure them."
+    );
+  }
+  router.get("/mcp", (_req, res) => {
+    res.json(mcpManager.list());
+  });
+  router.get("/mcp/tools", async (_req, res) => {
+    try {
+      const tools = await mcpManager.getAllTools();
+      res.json(
+        tools.map((t) => ({
+          name: t.name,
+          description: t.description,
+          parameters: Object.keys(t.parameters?.shape ?? {})
+        }))
+      );
+    } catch (err) {
+      res.status(500).json({ error: err.message });
+    }
+  });
+  router.post("/mcp", async (req, res) => {
+    try {
+      const { name, transport, url, command, args, env, headers, id, autoConnect } = req.body;
+      if (!name || !transport) {
+        return res.status(400).json({ error: "name and transport are required" });
+      }
+      const config = { name, transport };
+      if (url) config.url = url;
+      if (command) config.command = command;
+      if (args) config.args = args;
+      if (env) config.env = env;
+      if (headers) config.headers = headers;
+      const summary = mcpManager.add(config, id);
+      if (autoConnect !== false) {
+        const connected = await mcpManager.connect(summary.id);
+        return res.status(201).json(connected);
+      }
+      res.status(201).json(summary);
+    } catch (err) {
+      res.status(400).json({ error: err.message });
+    }
+  });
+  router.get("/mcp/:id", (req, res) => {
+    try {
+      res.json(mcpManager.get(req.params.id));
+    } catch (err) {
+      res.status(404).json({ error: err.message });
+    }
+  });
+  router.post("/mcp/:id/connect", async (req, res) => {
+    try {
+      const summary = await mcpManager.connect(req.params.id);
+      res.json(summary);
+    } catch (err) {
+      res.status(400).json({ error: err.message });
+    }
+  });
+  router.post("/mcp/:id/disconnect", async (req, res) => {
+    try {
+      const summary = await mcpManager.disconnect(req.params.id);
+      res.json(summary);
+    } catch (err) {
+      res.status(400).json({ error: err.message });
+    }
+  });
+  router.delete("/mcp/:id", async (req, res) => {
+    try {
+      await mcpManager.remove(req.params.id);
+      res.json({ ok: true });
+    } catch (err) {
+      res.status(404).json({ error: err.message });
+    }
+  });
+  router.get("/mcp/:id/tools", async (req, res) => {
+    try {
+      const tools = await mcpManager.getTools(req.params.id);
+      res.json(
+        tools.map((t) => ({
+          name: t.name,
+          description: t.description,
+          parameters: Object.keys(t.parameters?.shape ?? {})
+        }))
+      );
+    } catch (err) {
+      res.status(400).json({ error: err.message });
+    }
+  });
+  router.get("/toolkits", (_req, res) => {
+    res.json(import_core2.toolkitCatalog.list());
+  });
+  router.get("/toolkits/:id", (req, res) => {
+    const meta = import_core2.toolkitCatalog.get(req.params.id);
+    if (!meta) return res.status(404).json({ error: `Toolkit "${req.params.id}" not found` });
+    res.json(meta);
+  });
+  router.post("/toolkits/:id", (req, res) => {
+    try {
+      const toolkit = import_core2.toolkitCatalog.create(req.params.id, req.body ?? {});
+      const tools = toolkit.getTools().map((t) => ({
+        name: t.name,
+        description: t.description
+      }));
+      res.status(201).json({
+        id: req.params.id,
+        name: toolkit.name,
+        tools
+      });
+    } catch (err) {
+      res.status(400).json({ error: err.message });
+    }
+  });
+  return { router, mcpManager };
+}
+
+// src/express/file-upload.ts
+var import_node_module3 = require("module");
+var import_meta3 = {};
+var _require3 = (0, import_node_module3.createRequire)(import_meta3.url);
+var MIME_TO_PART_TYPE = {
+  "image/png": "image",
+  "image/jpeg": "image",
+  "image/jpg": "image",
+  "image/gif": "image",
+  "image/webp": "image",
+  "audio/mpeg": "audio",
+  "audio/mp3": "audio",
+  "audio/wav": "audio",
+  "audio/ogg": "audio",
+  "audio/webm": "audio",
+  "audio/flac": "audio",
+  "audio/aac": "audio",
+  "audio/mp4": "audio"
+};
+function getPartType(mimeType) {
+  return MIME_TO_PART_TYPE[mimeType] ?? "file";
+}
+function createFileUploadMiddleware(opts = {}) {
+  let multer;
+  try {
+    multer = _require3("multer");
+  } catch {
+    throw new Error("multer is required for file uploads. Install it: npm install multer");
+  }
+  const storage = multer.memoryStorage();
+  const upload = multer({
+    storage,
+    limits: {
+      fileSize: opts.maxFileSize ?? 50 * 1024 * 1024,
+      files: opts.maxFiles ?? 10
+    },
+    fileFilter: opts.allowedMimeTypes ? (_req, file, cb) => {
+      if (opts.allowedMimeTypes.includes(file.mimetype)) {
+        cb(null, true);
+      } else {
+        cb(new Error(`File type ${file.mimetype} is not allowed`));
+      }
+    } : void 0
+  });
+  return upload.array("files", opts.maxFiles ?? 10);
+}
+function filesToContentParts(files) {
+  return files.map((file) => {
+    const base64 = file.buffer.toString("base64");
+    const partType = getPartType(file.mimetype);
+    return {
+      type: partType,
+      data: base64,
+      mimeType: file.mimetype,
+      ...partType === "file" ? { fileName: file.originalname } : {}
+    };
+  });
+}
+function buildMultiModalInput(body, files) {
+  const textInput = body?.input;
+  if (!files || files.length === 0) {
+    return textInput;
+  }
+  const parts = [];
+  if (textInput) {
+    parts.push({ type: "text", text: textInput });
+  }
+  parts.push(...filesToContentParts(files));
+  return parts;
+}
+
+// src/express/middleware.ts
+function errorHandler(options) {
+  const log = options?.logger ?? console;
+  return (err, _req, res, _next) => {
+    log.error("[radaros:transport] Error:", err.message);
+    res.status(err.statusCode ?? 500).json({
+      error: err.message ?? "Internal server error"
+    });
+  };
+}
+function requestLogger(options) {
+  const log = options?.logger ?? console;
+  return (req, _res, next) => {
+    log.log(`[radaros:transport] ${req.method} ${req.path}`);
+    next();
+  };
+}
+
+// src/express/router-factory.ts
+var import_node_module5 = require("module");
+var import_core3 = require("@radaros/core");
+
+// src/express/swagger.ts
+var import_node_module4 = require("module");
+var import_meta4 = {};
+var _require4 = (0, import_node_module4.createRequire)(import_meta4.url);
+function zodSchemaToJsonSchema(schema) {
+  try {
+    const zodToJsonSchema = _require4("zod-to-json-schema").default ?? _require4("zod-to-json-schema");
+    const result = zodToJsonSchema(schema, { target: "openApi3" });
+    const { $schema, ...rest } = result;
+    return rest;
+  } catch {
+    return null;
+  }
+}
+var SCHEMAS = {
+  RunRequest: {
+    type: "object",
+    required: ["input"],
+    properties: {
+      input: {
+        oneOf: [
+          { type: "string", description: "Text input" },
+          {
+            type: "array",
+            description: "Multi-modal content parts",
+            items: {
+              oneOf: [
+                {
+                  type: "object",
+                  properties: {
+                    type: { type: "string", enum: ["text"] },
+                    text: { type: "string" }
+                  },
+                  required: ["type", "text"]
+                },
+                {
+                  type: "object",
+                  properties: {
+                    type: { type: "string", enum: ["image"] },
+                    data: { type: "string", description: "Base64 data or URL" },
+                    mimeType: { type: "string", enum: ["image/png", "image/jpeg", "image/gif", "image/webp"] }
+                  },
+                  required: ["type", "data"]
+                },
+                {
+                  type: "object",
+                  properties: {
+                    type: { type: "string", enum: ["audio"] },
+                    data: { type: "string", description: "Base64 data or URL" },
+                    mimeType: { type: "string" }
+                  },
+                  required: ["type", "data"]
+                },
+                {
+                  type: "object",
+                  properties: {
+                    type: { type: "string", enum: ["file"] },
+                    data: { type: "string", description: "Base64 data or URL" },
+                    mimeType: { type: "string" },
+                    fileName: { type: "string" }
+                  },
+                  required: ["type", "data"]
+                }
+              ]
+            }
+          }
+        ]
+      },
+      sessionId: { type: "string", description: "Session ID for conversation continuity" },
+      userId: { type: "string", description: "User identifier" }
+    }
+  },
+  MultipartRunRequest: {
+    type: "object",
+    properties: {
+      input: { type: "string", description: "Text input" },
+      sessionId: { type: "string" },
+      userId: { type: "string" },
+      files: {
+        type: "array",
+        items: { type: "string", format: "binary" },
+        description: "Files to include as multi-modal input (images, audio, documents)"
+      }
+    },
+    required: ["input"]
+  },
+  RunOutput: {
+    type: "object",
+    properties: {
+      text: { type: "string", description: "Agent response text" },
+      toolCalls: {
+        type: "array",
+        items: {
+          type: "object",
+          properties: {
+            toolCallId: { type: "string" },
+            toolName: { type: "string" },
+            result: {}
+          }
+        }
+      },
+      usage: {
+        type: "object",
+        properties: {
+          promptTokens: { type: "number" },
+          completionTokens: { type: "number" },
+          totalTokens: { type: "number" }
+        }
+      },
+      structured: { description: "Parsed structured output (if schema is configured)" },
+      durationMs: { type: "number" }
+    }
+  },
+  StreamChunk: {
+    type: "object",
+    description: "Server-Sent Event data",
+    properties: {
+      type: { type: "string", enum: ["text", "tool_call_start", "tool_call_delta", "tool_call_end", "finish"] },
+      text: { type: "string" }
+    }
+  },
+  Error: {
+    type: "object",
+    properties: {
+      error: { type: "string" }
+    }
+  },
+  WorkflowRunRequest: {
+    type: "object",
+    properties: {
+      sessionId: { type: "string" },
+      userId: { type: "string" }
+    }
+  }
+};
+function buildAgentDescription(agent) {
+  const parts = [];
+  parts.push(`**Model:** \`${agent.providerId}/${agent.modelId}\``);
+  if (typeof agent.instructions === "string") {
+    const instr = agent.instructions.length > 200 ? `${agent.instructions.slice(0, 200)}\u2026` : agent.instructions;
+    parts.push(`**Instructions:** ${instr}`);
+  }
+  if (agent.tools?.length > 0) {
+    const toolNames = agent.tools.map((t) => `\`${t.name}\``).join(", ");
+    parts.push(`**Tools:** ${toolNames}`);
+  }
+  if (agent.hasStructuredOutput) {
+    parts.push("**Structured Output:** Enabled");
+  }
+  return parts.join("\n\n");
+}
+function generateOpenAPISpec(routerOpts, swaggerOpts = {}) {
+  const prefix = swaggerOpts.routePrefix ?? "";
+  const providers = /* @__PURE__ */ new Set();
+  if (routerOpts.agents) {
+    for (const agent of Object.values(routerOpts.agents)) {
+      providers.add(agent.providerId ?? "unknown");
+    }
+  }
+  const securitySchemes = {};
+  const securityRequirements = [];
+  if (providers.has("openai")) {
+    securitySchemes.OpenAIKey = {
+      type: "apiKey",
+      in: "header",
+      name: "x-openai-api-key",
+      description: "OpenAI API key (sk-...)"
+    };
+    securityRequirements.push({ OpenAIKey: [] });
+  }
+  if (providers.has("google")) {
+    securitySchemes.GoogleKey = {
+      type: "apiKey",
+      in: "header",
+      name: "x-google-api-key",
+      description: "Google AI API key (AIza...)"
+    };
+    securityRequirements.push({ GoogleKey: [] });
+  }
+  if (providers.has("anthropic")) {
+    securitySchemes.AnthropicKey = {
+      type: "apiKey",
+      in: "header",
+      name: "x-anthropic-api-key",
+      description: "Anthropic API key (sk-ant-...)"
+    };
+    securityRequirements.push({ AnthropicKey: [] });
+  }
+  securitySchemes.GenericKey = {
+    type: "apiKey",
+    in: "header",
+    name: "x-api-key",
+    description: "Generic API key (used if provider-specific key is not set)"
+  };
+  const spec = {
+    openapi: "3.0.3",
+    info: {
+      title: swaggerOpts.title ?? "RadarOS API",
+      description: swaggerOpts.description ?? "Auto-generated API documentation for RadarOS agents, teams, and workflows.",
+      version: swaggerOpts.version ?? "1.0.0"
+    },
+    paths: {},
+    components: {
+      schemas: SCHEMAS,
+      securitySchemes
+    },
+    security: securityRequirements,
+    tags: []
+  };
+  if (swaggerOpts.servers) {
+    spec.servers = swaggerOpts.servers;
+  }
+  if (routerOpts.agents && Object.keys(routerOpts.agents).length > 0) {
+    spec.tags.push({ name: "Agents", description: "Agent endpoints for running and streaming AI agents" });
+    for (const [name, agent] of Object.entries(routerOpts.agents)) {
+      const agentDesc = buildAgentDescription(agent);
+      let responseSchemaRef = "#/components/schemas/RunOutput";
+      const zodSchema = agent.structuredOutputSchema;
+      if (zodSchema) {
+        const structuredJsonSchema = zodSchemaToJsonSchema(zodSchema);
+        if (structuredJsonSchema) {
+          const schemaName = `RunOutput_${name}`;
+          spec.components.schemas[schemaName] = {
+            type: "object",
+            properties: {
+              text: { type: "string", description: "Raw agent response text" },
+              toolCalls: {
+                type: "array",
+                items: {
+                  type: "object",
+                  properties: {
+                    toolCallId: { type: "string" },
+                    toolName: { type: "string" },
+                    result: {}
+                  }
+                }
+              },
+              usage: {
+                type: "object",
+                properties: {
+                  promptTokens: { type: "number" },
+                  completionTokens: { type: "number" },
+                  totalTokens: { type: "number" }
+                }
+              },
+              structured: {
+                ...structuredJsonSchema,
+                description: "Parsed structured output"
+              },
+              durationMs: { type: "number" }
+            }
+          };
+          responseSchemaRef = `#/components/schemas/${schemaName}`;
+        }
+      }
+      spec.paths[`${prefix}/agents/${name}/run`] = {
+        post: {
+          tags: ["Agents"],
+          summary: `Run agent: ${name}`,
+          description: agentDesc,
+          operationId: `runAgent_${name}`,
+          requestBody: {
+            required: true,
+            content: {
+              "application/json": {
+                schema: { $ref: "#/components/schemas/RunRequest" }
+              },
+              "multipart/form-data": {
+                schema: { $ref: "#/components/schemas/MultipartRunRequest" }
+              }
+            }
+          },
+          responses: {
+            "200": {
+              description: "Agent run result",
+              content: {
+                "application/json": {
+                  schema: { $ref: responseSchemaRef }
+                }
+              }
+            },
+            "400": {
+              description: "Bad request",
+              content: {
+                "application/json": {
+                  schema: { $ref: "#/components/schemas/Error" }
+                }
+              }
+            },
+            "500": {
+              description: "Internal server error",
+              content: {
+                "application/json": {
+                  schema: { $ref: "#/components/schemas/Error" }
+                }
+              }
+            }
+          }
+        }
+      };
+      spec.paths[`${prefix}/agents/${name}/stream`] = {
+        post: {
+          tags: ["Agents"],
+          summary: `Stream agent: ${name}`,
+          description: `Stream responses from agent **${name}** via Server-Sent Events.
+
+${agentDesc}`,
+          operationId: `streamAgent_${name}`,
+          requestBody: {
+            required: true,
+            content: {
+              "application/json": {
+                schema: { $ref: "#/components/schemas/RunRequest" }
+              }
+            }
+          },
+          responses: {
+            "200": {
+              description: "SSE stream of agent chunks",
+              content: {
+                "text/event-stream": {
+                  schema: { $ref: "#/components/schemas/StreamChunk" }
+                }
+              }
+            },
+            "400": {
+              description: "Bad request",
+              content: {
+                "application/json": {
+                  schema: { $ref: "#/components/schemas/Error" }
+                }
+              }
+            }
+          }
+        }
+      };
+    }
+  }
+  if (routerOpts.teams && Object.keys(routerOpts.teams).length > 0) {
+    spec.tags.push({ name: "Teams", description: "Team endpoints for multi-agent coordination" });
+    for (const name of Object.keys(routerOpts.teams)) {
+      spec.paths[`${prefix}/teams/${name}/run`] = {
+        post: {
+          tags: ["Teams"],
+          summary: `Run team: ${name}`,
+          operationId: `runTeam_${name}`,
+          requestBody: {
+            required: true,
+            content: {
+              "application/json": {
+                schema: { $ref: "#/components/schemas/RunRequest" }
+              }
+            }
+          },
+          responses: {
+            "200": {
+              description: "Team run result",
+              content: {
+                "application/json": {
+                  schema: { $ref: "#/components/schemas/RunOutput" }
+                }
+              }
+            },
+            "400": {
+              description: "Bad request",
+              content: { "application/json": { schema: { $ref: "#/components/schemas/Error" } } }
+            },
+            "500": {
+              description: "Internal server error",
+              content: { "application/json": { schema: { $ref: "#/components/schemas/Error" } } }
+            }
+          }
+        }
+      };
+      spec.paths[`${prefix}/teams/${name}/stream`] = {
+        post: {
+          tags: ["Teams"],
+          summary: `Stream team: ${name}`,
+          operationId: `streamTeam_${name}`,
+          requestBody: {
+            required: true,
+            content: { "application/json": { schema: { $ref: "#/components/schemas/RunRequest" } } }
+          },
+          responses: {
+            "200": {
+              description: "SSE stream",
+              content: { "text/event-stream": { schema: { $ref: "#/components/schemas/StreamChunk" } } }
+            },
+            "400": {
+              description: "Bad request",
+              content: { "application/json": { schema: { $ref: "#/components/schemas/Error" } } }
+            }
+          }
+        }
+      };
+    }
+  }
+  if (routerOpts.workflows && Object.keys(routerOpts.workflows).length > 0) {
+    spec.tags.push({ name: "Workflows", description: "Workflow endpoints for step-based pipelines" });
+    for (const name of Object.keys(routerOpts.workflows)) {
+      spec.paths[`${prefix}/workflows/${name}/run`] = {
+        post: {
+          tags: ["Workflows"],
+          summary: `Run workflow: ${name}`,
+          operationId: `runWorkflow_${name}`,
+          requestBody: {
+            required: true,
+            content: {
+              "application/json": {
+                schema: { $ref: "#/components/schemas/WorkflowRunRequest" }
+              }
+            }
+          },
+          responses: {
+            "200": { description: "Workflow result", content: { "application/json": { schema: { type: "object" } } } },
+            "500": {
+              description: "Internal server error",
+              content: { "application/json": { schema: { $ref: "#/components/schemas/Error" } } }
+            }
+          }
+        }
+      };
+    }
+  }
+  return spec;
+}
+function serveSwaggerUI(spec) {
+  let swaggerUiExpress;
+  try {
+    swaggerUiExpress = _require4("swagger-ui-express");
+  } catch {
+    throw new Error("swagger-ui-express is required for Swagger UI. Install it: npm install swagger-ui-express");
+  }
+  return {
+    setup: swaggerUiExpress.setup(spec, {
+      customCss: ".swagger-ui .topbar { display: none }",
+      customSiteTitle: spec.info.title
+    }),
+    serve: swaggerUiExpress.serve
+  };
+}
+
+// src/express/router-factory.ts
+var import_meta5 = {};
+var _require5 = (0, import_node_module5.createRequire)(import_meta5.url);
+function corsMiddleware(origins) {
+  return (req, res, next) => {
+    const origin = req.headers.origin;
+    let allowed = false;
+    if (origins === true || origins === "*") {
+      allowed = true;
+      res.setHeader("Access-Control-Allow-Origin", "*");
+    } else if (typeof origins === "string") {
+      allowed = origin === origins;
+      if (allowed) res.setHeader("Access-Control-Allow-Origin", origin);
+    } else if (Array.isArray(origins)) {
+      allowed = origins.includes(origin);
+      if (allowed) res.setHeader("Access-Control-Allow-Origin", origin);
+    }
+    if (allowed) {
+      res.setHeader("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, OPTIONS");
+      res.setHeader("Access-Control-Allow-Headers", "Content-Type, Authorization, X-API-Key");
+      res.setHeader("Access-Control-Max-Age", "86400");
+    }
+    if (req.method === "OPTIONS") {
+      res.status(204).end();
+      return;
+    }
+    next();
+  };
+}
+function rateLimitMiddleware(config = {}) {
+  const windowMs = config.windowMs ?? 6e4;
+  const max = config.max ?? 100;
+  const hits = /* @__PURE__ */ new Map();
+  return (req, res, next) => {
+    const key = req.ip ?? req.socket?.remoteAddress ?? "unknown";
+    const now = Date.now();
+    const record = hits.get(key);
+    if (!record || now > record.resetTime) {
+      hits.set(key, { count: 1, resetTime: now + windowMs });
+      next();
+      return;
+    }
+    record.count++;
+    if (record.count > max) {
+      res.status(429).json({ error: "Too many requests, please try again later" });
+      return;
+    }
+    next();
+  };
+}
+var API_KEY_HEADERS = {
+  "x-openai-api-key": "openai",
+  "x-google-api-key": "google",
+  "x-anthropic-api-key": "anthropic",
+  "x-api-key": "_generic"
+};
+function validateBody(body, fields) {
+  if (!body || typeof body !== "object") throw new Error("Invalid request body");
+  const result = {};
+  for (const [key, type] of Object.entries(fields)) {
+    const val = body[key];
+    const isOptional = type.endsWith("?");
+    const baseType = type.replace("?", "");
+    if (val === void 0 || val === null) {
+      if (!isOptional) throw new Error(`Missing required field: ${key}`);
+      continue;
+    }
+    if (baseType === "string" && typeof val !== "string") throw new Error(`Field ${key} must be a string`);
+    if (baseType === "object" && typeof val !== "object") throw new Error(`Field ${key} must be an object`);
+    result[key] = val;
+  }
+  return result;
+}
+function extractApiKey(req, agent) {
+  for (const [header, provider] of Object.entries(API_KEY_HEADERS)) {
+    const value = req.headers[header];
+    if (value && (provider === "_generic" || provider === agent.providerId)) {
+      return value;
+    }
+  }
+  return req.body?.apiKey ?? void 0;
+}
+function createAgentRouter(opts) {
+  if (opts.serve?.length) {
+    const discovered = (0, import_core3.classifyServables)(opts.serve);
+    opts = {
+      ...opts,
+      agents: { ...discovered.agents, ...opts.agents },
+      teams: { ...discovered.teams, ...opts.teams },
+      workflows: { ...discovered.workflows, ...opts.workflows }
+    };
+  }
+  const reg = opts.registry === false ? null : opts.registry ?? import_core3.registry;
+  let express;
+  try {
+    express = _require5("express");
+  } catch {
+    throw new Error("express is required for createAgentRouter. Install it: npm install express");
+  }
+  const router = express.Router();
+  if (opts.cors) {
+    router.use(corsMiddleware(opts.cors));
+  }
+  if (opts.rateLimit) {
+    const config = opts.rateLimit === true ? {} : opts.rateLimit;
+    router.use(rateLimitMiddleware(config));
+  }
+  if (opts.middleware) {
+    for (const mw of opts.middleware) {
+      router.use(mw);
+    }
+  }
+  let uploadMiddleware = null;
+  if (opts.fileUpload) {
+    const uploadOpts = typeof opts.fileUpload === "object" ? opts.fileUpload : {};
+    uploadMiddleware = createFileUploadMiddleware(uploadOpts);
+  }
+  function withUpload(handler) {
+    if (!uploadMiddleware) return handler;
+    return (req, res, next) => {
+      uploadMiddleware(req, res, (err) => {
+        if (err) {
+          return res.status(400).json({ error: err.message });
+        }
+        handler(req, res).catch(next);
+      });
+    };
+  }
+  if (opts.swagger?.enabled) {
+    const spec = generateOpenAPISpec(opts, opts.swagger);
+    const docsPath = opts.swagger.docsPath ?? "/docs";
+    const specPath = opts.swagger.specPath ?? "/docs/spec.json";
+    router.get(specPath, (_req, res) => {
+      res.json(spec);
+    });
+    try {
+      const { serve, setup } = serveSwaggerUI(spec);
+      router.use(docsPath, serve, setup);
+    } catch (e) {
+      console.warn(`[radaros:transport] Swagger UI disabled: ${e.message}`);
+    }
+  }
+  if (opts.agents) {
+    for (const [name, agent] of Object.entries(opts.agents)) {
+      router.post(
+        `/agents/${name}/run`,
+        withUpload(async (req, res) => {
+          try {
+            const validated = validateBody(req.body, {
+              input: "string",
+              sessionId: "string?",
+              userId: "string?"
+            });
+            const input = buildMultiModalInput(req.body, req.files) ?? validated.input;
+            if (!input) {
+              return res.status(400).json({ error: "input is required" });
+            }
+            const sessionId = validated.sessionId;
+            const userId = validated.userId;
+            const apiKey = extractApiKey(req, agent);
+            const result = await agent.run(input, { sessionId, userId, apiKey });
+            res.json(result);
+          } catch (error) {
+            res.status(400).json({ error: error.message });
+          }
+        })
+      );
+      router.post(`/agents/${name}/stream`, async (req, res) => {
+        try {
+          const validated = validateBody(req.body, {
+            input: "string",
+            sessionId: "string?",
+            userId: "string?"
+          });
+          const input = validated.input;
+          if (!input) {
+            return res.status(400).json({ error: "input is required" });
+          }
+          const sessionId = validated.sessionId;
+          const userId = validated.userId;
+          const apiKey = extractApiKey(req, agent);
+          res.writeHead(200, {
+            "Content-Type": "text/event-stream",
+            "Cache-Control": "no-cache",
+            Connection: "keep-alive"
+          });
+          const stream = agent.stream(input, { sessionId, userId, apiKey });
+          for await (const chunk of stream) {
+            res.write(`data: ${JSON.stringify(chunk)}
+
+`);
+          }
+          res.write("data: [DONE]\n\n");
+          res.end();
+        } catch (error) {
+          if (!res.headersSent) {
+            res.status(500).json({ error: error.message });
+          } else {
+            res.write(`data: ${JSON.stringify({ type: "error", error: error.message })}
+
+`);
+            res.end();
+          }
+        }
+      });
+    }
+  }
+  if (opts.teams) {
+    for (const [name, team] of Object.entries(opts.teams)) {
+      router.post(`/teams/${name}/run`, async (req, res) => {
+        try {
+          const validated = validateBody(req.body, {
+            input: "string",
+            sessionId: "string?",
+            userId: "string?"
+          });
+          const input = validated.input;
+          if (!input) {
+            return res.status(400).json({ error: "input is required" });
+          }
+          const sessionId = validated.sessionId;
+          const userId = validated.userId;
+          const apiKey = req.headers["x-api-key"] ?? req.body?.apiKey;
+          const result = await team.run(input, { sessionId, userId, apiKey });
+          res.json(result);
+        } catch (error) {
+          res.status(500).json({ error: error.message });
+        }
+      });
+      router.post(`/teams/${name}/stream`, async (req, res) => {
+        try {
+          const validated = validateBody(req.body, {
+            input: "string",
+            sessionId: "string?",
+            userId: "string?"
+          });
+          const input = validated.input;
+          if (!input) {
+            return res.status(400).json({ error: "input is required" });
+          }
+          const sessionId = validated.sessionId;
+          const userId = validated.userId;
+          const apiKey = req.headers["x-api-key"] ?? req.body?.apiKey;
+          res.writeHead(200, {
+            "Content-Type": "text/event-stream",
+            "Cache-Control": "no-cache",
+            Connection: "keep-alive"
+          });
+          const stream = team.stream(input, { sessionId, userId, apiKey });
+          for await (const chunk of stream) {
+            res.write(`data: ${JSON.stringify(chunk)}
+
+`);
+          }
+          res.write("data: [DONE]\n\n");
+          res.end();
+        } catch (error) {
+          if (!res.headersSent) {
+            res.status(500).json({ error: error.message });
+          } else {
+            res.write(`data: ${JSON.stringify({ type: "error", error: error.message })}
+
+`);
+            res.end();
+          }
+        }
+      });
+    }
+  }
+  if (opts.workflows) {
+    for (const [name, workflow] of Object.entries(opts.workflows)) {
+      router.post(`/workflows/${name}/run`, async (req, res) => {
+        try {
+          const { sessionId, userId } = req.body ?? {};
+          const result = await workflow.run({ sessionId, userId });
+          res.json(result);
+        } catch (error) {
+          res.status(500).json({ error: error.message });
+        }
+      });
+    }
+  }
+  if (reg) {
+    router.post(
+      "/agents/:name/run",
+      withUpload(async (req, res) => {
+        const agent = reg.getAgent(req.params.name);
+        if (!agent) return res.status(404).json({ error: `Agent "${req.params.name}" not found` });
+        try {
+          const validated = validateBody(req.body, { input: "string", sessionId: "string?", userId: "string?" });
+          const input = buildMultiModalInput(req.body, req.files) ?? validated.input;
+          if (!input) return res.status(400).json({ error: "input is required" });
+          const apiKey = extractApiKey(req, agent);
+          const result = await agent.run(input, {
+            sessionId: validated.sessionId,
+            userId: validated.userId,
+            apiKey
+          });
+          res.json(result);
+        } catch (error) {
+          res.status(400).json({ error: error.message });
+        }
+      })
+    );
+    router.post("/agents/:name/stream", async (req, res) => {
+      const agent = reg.getAgent(req.params.name);
+      if (!agent) return res.status(404).json({ error: `Agent "${req.params.name}" not found` });
+      try {
+        const validated = validateBody(req.body, { input: "string", sessionId: "string?", userId: "string?" });
+        const input = validated.input;
+        if (!input) return res.status(400).json({ error: "input is required" });
+        const apiKey = extractApiKey(req, agent);
+        res.writeHead(200, {
+          "Content-Type": "text/event-stream",
+          "Cache-Control": "no-cache",
+          Connection: "keep-alive"
+        });
+        for await (const chunk of agent.stream(input, {
+          sessionId: validated.sessionId,
+          userId: validated.userId,
+          apiKey
+        })) {
+          res.write(`data: ${JSON.stringify(chunk)}
+
+`);
+        }
+        res.write("data: [DONE]\n\n");
+        res.end();
+      } catch (error) {
+        if (!res.headersSent) res.status(500).json({ error: error.message });
+        else {
+          res.write(`data: ${JSON.stringify({ type: "error", error: error.message })}
+
+`);
+          res.end();
+        }
+      }
+    });
+    router.post("/teams/:name/run", async (req, res) => {
+      const team = reg.getTeam(req.params.name);
+      if (!team) return res.status(404).json({ error: `Team "${req.params.name}" not found` });
+      try {
+        const validated = validateBody(req.body, { input: "string", sessionId: "string?", userId: "string?" });
+        const input = validated.input;
+        if (!input) return res.status(400).json({ error: "input is required" });
+        const apiKey = req.headers["x-api-key"] ?? req.body?.apiKey;
+        const result = await team.run(input, {
+          sessionId: validated.sessionId,
+          userId: validated.userId,
+          apiKey
+        });
+        res.json(result);
+      } catch (error) {
+        res.status(500).json({ error: error.message });
+      }
+    });
+    router.post("/teams/:name/stream", async (req, res) => {
+      const team = reg.getTeam(req.params.name);
+      if (!team) return res.status(404).json({ error: `Team "${req.params.name}" not found` });
+      try {
+        const validated = validateBody(req.body, { input: "string", sessionId: "string?", userId: "string?" });
+        const input = validated.input;
+        if (!input) return res.status(400).json({ error: "input is required" });
+        const apiKey = req.headers["x-api-key"] ?? req.body?.apiKey;
+        res.writeHead(200, {
+          "Content-Type": "text/event-stream",
+          "Cache-Control": "no-cache",
+          Connection: "keep-alive"
+        });
+        for await (const chunk of team.stream(input, {
+          sessionId: validated.sessionId,
+          userId: validated.userId,
+          apiKey
+        })) {
+          res.write(`data: ${JSON.stringify(chunk)}
+
+`);
+        }
+        res.write("data: [DONE]\n\n");
+        res.end();
+      } catch (error) {
+        if (!res.headersSent) res.status(500).json({ error: error.message });
+        else {
+          res.write(`data: ${JSON.stringify({ type: "error", error: error.message })}
+
+`);
+          res.end();
+        }
+      }
+    });
+    router.post("/workflows/:name/run", async (req, res) => {
+      const workflow = reg.getWorkflow(req.params.name);
+      if (!workflow) return res.status(404).json({ error: `Workflow "${req.params.name}" not found` });
+      try {
+        const { sessionId, userId } = req.body ?? {};
+        const result = await workflow.run({ sessionId, userId });
+        res.json(result);
+      } catch (error) {
+        res.status(500).json({ error: error.message });
+      }
+    });
+    router.get("/agents", (_req, res) => {
+      res.json(reg.describeAgents());
+    });
+    router.get("/teams", (_req, res) => {
+      res.json(reg.describeTeams());
+    });
+    router.get("/workflows", (_req, res) => {
+      res.json(reg.describeWorkflows());
+    });
+    router.get("/registry", (_req, res) => {
+      res.json(reg.list());
+    });
+  }
+  if (opts.admin) {
+    const adminOpts = typeof opts.admin === "object" ? opts.admin : {};
+    const { router: adminRouter } = createAdminRouter({
+      mcpManager: adminOpts.mcpManager
+    });
+    router.use("/admin", adminRouter);
+  }
+  const fromToolkits = opts.toolkits ? (0, import_core3.collectToolkitTools)(opts.toolkits) : {};
+  const mergedTools = { ...fromToolkits, ...opts.toolLibrary ?? {} };
+  if (Object.keys(mergedTools).length > 0) {
+    router.get("/tools", (_req, res) => {
+      res.json((0, import_core3.describeToolLibrary)(mergedTools));
+    });
+    router.get("/tools/:name", (req, res) => {
+      const tool = mergedTools[req.params.name];
+      if (!tool) return res.status(404).json({ error: `Tool "${req.params.name}" not found` });
+      res.json({
+        name: tool.name,
+        description: tool.description,
+        parameters: Object.keys(tool.parameters.shape ?? {})
+      });
+    });
+  }
+  return router;
+}
+
+// src/socketio/browser-gateway.ts
+function createBrowserGateway(opts) {
+  const ns = opts.io.of(opts.namespace ?? "/radaros-browser");
+  const streamScreenshots = opts.streamScreenshots ?? true;
+  if (opts.authMiddleware) {
+    ns.use(opts.authMiddleware);
+  }
+  const activeRuns = /* @__PURE__ */ new Map();
+  ns.on("connection", (socket) => {
+    socket.on(
+      "browser.start",
+      async (data) => {
+        const agent = opts.agents[data.agentName];
+        if (!agent) {
+          socket.emit("browser.error", {
+            error: `Browser agent "${data.agentName}" not found`
+          });
+          return;
+        }
+        if (activeRuns.has(socket.id)) {
+          socket.emit("browser.error", {
+            error: "A browser task is already running for this connection"
+          });
+          return;
+        }
+        const abort = new AbortController();
+        activeRuns.set(socket.id, abort);
+        const onScreenshot = (ev) => {
+          if (streamScreenshots && !abort.signal.aborted) {
+            socket.emit("browser.screenshot", {
+              data: ev.data.toString("base64"),
+              mimeType: "image/png"
+            });
+          }
+        };
+        const onAction = (ev) => {
+          if (!abort.signal.aborted) {
+            socket.emit("browser.action", { action: ev.action });
+          }
+        };
+        const onStep = (ev) => {
+          if (!abort.signal.aborted) {
+            socket.emit("browser.step", {
+              index: ev.index,
+              action: ev.action,
+              pageUrl: ev.pageUrl,
+              screenshot: streamScreenshots ? ev.screenshot.toString("base64") : void 0
+            });
+          }
+        };
+        const onError = (ev) => {
+          if (!abort.signal.aborted) {
+            socket.emit("browser.error", { error: ev.error.message });
+          }
+        };
+        agent.eventBus.on("browser.screenshot", onScreenshot);
+        agent.eventBus.on("browser.action", onAction);
+        agent.eventBus.on("browser.step", onStep);
+        agent.eventBus.on("browser.error", onError);
+        const cleanup = () => {
+          agent.eventBus.off("browser.screenshot", onScreenshot);
+          agent.eventBus.off("browser.action", onAction);
+          agent.eventBus.off("browser.step", onStep);
+          agent.eventBus.off("browser.error", onError);
+          activeRuns.delete(socket.id);
+        };
+        socket.emit("browser.started", {
+          agentName: data.agentName,
+          task: data.task
+        });
+        try {
+          const result = await agent.run(data.task, {
+            startUrl: data.startUrl,
+            apiKey: data.apiKey ?? socket.handshake?.auth?.apiKey,
+            sessionId: data.sessionId
+          });
+          cleanup();
+          if (!abort.signal.aborted) {
+            socket.emit("browser.done", {
+              result: result.result,
+              success: result.success,
+              finalUrl: result.finalUrl,
+              durationMs: result.durationMs,
+              totalSteps: result.steps.length,
+              videoPath: result.videoPath
+            });
+          }
+        } catch (error) {
+          cleanup();
+          if (!abort.signal.aborted) {
+            socket.emit("browser.error", { error: error.message });
+          }
+        }
+      }
+    );
+    socket.on("browser.stop", () => {
+      const abort = activeRuns.get(socket.id);
+      if (abort) {
+        abort.abort();
+        activeRuns.delete(socket.id);
+        socket.emit("browser.stopped");
+      }
+    });
+    socket.on("disconnect", () => {
+      const abort = activeRuns.get(socket.id);
+      if (abort) {
+        abort.abort();
+        activeRuns.delete(socket.id);
+      }
+    });
+  });
+}
+
+// src/socketio/gateway.ts
+var import_core4 = require("@radaros/core");
+function createSocketRateLimiter(maxPerMinute = 60) {
+  return () => {
+    let count = 0;
+    let resetTime = Date.now() + 6e4;
+    return () => {
+      const now = Date.now();
+      if (now > resetTime) {
+        count = 0;
+        resetTime = now + 6e4;
+      }
+      count++;
+      return count <= maxPerMinute;
+    };
+  };
+}
+function createAgentGateway(opts) {
+  if (opts.serve?.length) {
+    const discovered = (0, import_core4.classifyServables)(opts.serve);
+    opts = {
+      ...opts,
+      agents: { ...discovered.agents, ...opts.agents },
+      teams: { ...discovered.teams, ...opts.teams }
+    };
+  }
+  const reg = opts.registry === false ? null : opts.registry ?? import_core4.registry;
+  const ns = opts.io.of(opts.namespace ?? "/radaros");
+  if (opts.authMiddleware) {
+    ns.use(opts.authMiddleware);
+  }
+  const rateLimiterFactory = createSocketRateLimiter(opts.maxRequestsPerMinute ?? 60);
+  ns.on("connection", (socket) => {
+    const checkRate = rateLimiterFactory();
+    socket.on("agent.run", async (data) => {
+      if (!checkRate()) {
+        socket.emit("agent.error", { error: "Rate limit exceeded" });
+        return;
+      }
+      if (!data || typeof data.input !== "string" || !data.input.trim()) {
+        socket.emit("agent.error", { error: "Invalid input: must be a non-empty string" });
+        return;
+      }
+      if (data.sessionId !== void 0 && typeof data.sessionId !== "string") {
+        socket.emit("agent.error", { error: "Invalid sessionId: must be a string" });
+        return;
+      }
+      const agent = opts.agents?.[data.name] ?? reg?.getAgent(data.name);
+      if (!agent) {
+        socket.emit("agent.error", {
+          error: `Agent "${data.name}" not found`
+        });
+        return;
+      }
+      try {
+        const apiKey = data.apiKey ?? socket.handshake?.auth?.apiKey;
+        const sessionId = data.sessionId ?? socket.id;
+        let fullText = "";
+        for await (const chunk of agent.stream(data.input, {
+          sessionId,
+          apiKey
+        })) {
+          if (chunk.type === "text") {
+            fullText += chunk.text;
+            socket.emit("agent.chunk", { chunk: chunk.text });
+          } else if (chunk.type === "tool_call_start") {
+            socket.emit("agent.tool.call", {
+              toolName: chunk.toolCall.name,
+              args: null
+            });
+          } else if (chunk.type === "tool_call_end") {
+            socket.emit("agent.tool.done", { toolCallId: chunk.toolCallId });
+          }
+        }
+        socket.emit("agent.done", { output: { text: fullText } });
+      } catch (error) {
+        socket.emit("agent.error", { error: error.message });
+      }
+    });
+    socket.on("agents.list", (_data, ack) => {
+      if (reg) {
+        ack?.(reg.describeAgents());
+      } else {
+        const names = Object.keys(opts.agents ?? {});
+        ack?.(names.map((n) => ({ name: n })));
+      }
+    });
+    socket.on("teams.list", (_data, ack) => {
+      if (reg) {
+        ack?.(reg.describeTeams());
+      } else {
+        const names = Object.keys(opts.teams ?? {});
+        ack?.(names.map((n) => ({ name: n })));
+      }
+    });
+    socket.on("workflows.list", (_data, ack) => {
+      if (reg) {
+        ack?.(reg.describeWorkflows());
+      } else {
+        ack?.([]);
+      }
+    });
+    socket.on("registry.list", (_data, ack) => {
+      if (reg) {
+        ack?.(reg.list());
+      } else {
+        ack?.({
+          agents: Object.keys(opts.agents ?? {}),
+          teams: Object.keys(opts.teams ?? {}),
+          workflows: []
+        });
+      }
+    });
+    const fromToolkits = opts.toolkits ? (0, import_core4.collectToolkitTools)(opts.toolkits) : {};
+    const mergedTools = { ...fromToolkits, ...opts.toolLibrary ?? {} };
+    socket.on("tools.list", (_data, ack) => {
+      ack?.((0, import_core4.describeToolLibrary)(mergedTools));
+    });
+    socket.on("tools.get", (data, ack) => {
+      const tool = mergedTools[data?.name];
+      if (!tool) return ack?.({ error: `Tool "${data?.name}" not found` });
+      ack?.({
+        name: tool.name,
+        description: tool.description,
+        parameters: Object.keys(tool.parameters.shape ?? {})
+      });
+    });
+    socket.on("disconnect", () => {
+    });
+    socket.on("team.run", async (data) => {
+      if (!checkRate()) {
+        socket.emit("agent.error", { error: "Rate limit exceeded" });
+        return;
+      }
+      if (!data || typeof data.input !== "string" || !data.input.trim()) {
+        socket.emit("agent.error", { error: "Invalid input: must be a non-empty string" });
+        return;
+      }
+      if (data.sessionId !== void 0 && typeof data.sessionId !== "string") {
+        socket.emit("agent.error", { error: "Invalid sessionId: must be a string" });
+        return;
+      }
+      const team = opts.teams?.[data.name] ?? reg?.getTeam(data.name);
+      if (!team) {
+        socket.emit("agent.error", {
+          error: `Team "${data.name}" not found`
+        });
+        return;
+      }
+      try {
+        const apiKey = data.apiKey ?? socket.handshake?.auth?.apiKey;
+        const result = await team.run(data.input, {
+          sessionId: data.sessionId ?? socket.id,
+          apiKey
+        });
+        socket.emit("agent.done", { output: result });
+      } catch (error) {
+        socket.emit("agent.error", { error: error.message });
+      }
+    });
+  });
+}
+
+// src/socketio/voice-gateway.ts
+function createVoiceGateway(opts) {
+  const ns = opts.io.of(opts.namespace ?? "/radaros-voice");
+  if (opts.authMiddleware) {
+    ns.use(opts.authMiddleware);
+  }
+  const activeSessions = /* @__PURE__ */ new Map();
+  ns.on("connection", (socket) => {
+    socket.on(
+      "voice.start",
+      async (data) => {
+        const agent = opts.agents[data.agentName];
+        if (!agent) {
+          socket.emit("voice.error", {
+            error: `Voice agent "${data.agentName}" not found`
+          });
+          return;
+        }
+        if (activeSessions.has(socket.id)) {
+          socket.emit("voice.error", {
+            error: "A voice session is already active for this connection"
+          });
+          return;
+        }
+        try {
+          const apiKey = data.apiKey ?? socket.handshake?.auth?.apiKey;
+          const userId = data.userId ?? socket.handshake?.auth?.userId;
+          const sessionId = data.sessionId ?? socket.handshake?.auth?.sessionId;
+          const session = await agent.connect({
+            apiKey,
+            userId,
+            sessionId
+          });
+          activeSessions.set(socket.id, session);
+          session.on("audio", (ev) => {
+            socket.emit("voice.audio", {
+              data: ev.data.toString("base64"),
+              mimeType: ev.mimeType ?? "audio/pcm"
+            });
+          });
+          session.on("transcript", (ev) => {
+            socket.emit("voice.transcript", {
+              text: ev.text,
+              role: ev.role
+            });
+          });
+          session.on("text", (ev) => {
+            socket.emit("voice.text", { text: ev.text });
+          });
+          session.on("tool_call_start", (ev) => {
+            socket.emit("voice.tool.call", {
+              name: ev.name,
+              args: ev.args
+            });
+          });
+          session.on("tool_result", (ev) => {
+            socket.emit("voice.tool.result", {
+              name: ev.name,
+              result: ev.result
+            });
+          });
+          session.on("usage", (ev) => {
+            socket.emit("voice.usage", ev);
+          });
+          session.on("interrupted", () => {
+            socket.emit("voice.interrupted");
+          });
+          session.on("error", (ev) => {
+            socket.emit("voice.error", { error: ev.error.message });
+          });
+          session.on("disconnected", () => {
+            activeSessions.delete(socket.id);
+            socket.emit("voice.stopped");
+          });
+          socket.emit("voice.started", { userId });
+        } catch (error) {
+          socket.emit("voice.error", { error: error.message });
+        }
+      }
+    );
+    socket.on("voice.audio", (data) => {
+      const session = activeSessions.get(socket.id);
+      if (!session) return;
+      session.sendAudio(Buffer.from(data.data, "base64"));
+    });
+    socket.on("voice.text", (data) => {
+      const session = activeSessions.get(socket.id);
+      if (!session) return;
+      session.sendText(data.text);
+    });
+    socket.on("voice.interrupt", () => {
+      const session = activeSessions.get(socket.id);
+      if (!session) return;
+      session.interrupt();
+    });
+    socket.on("voice.stop", async () => {
+      const session = activeSessions.get(socket.id);
+      if (!session) return;
+      await session.close();
+      activeSessions.delete(socket.id);
+      socket.emit("voice.stopped");
+    });
+    socket.on("disconnect", async () => {
+      const session = activeSessions.get(socket.id);
+      if (session) {
+        try {
+          await session.close();
+        } catch (err) {
+          console.warn(
+            "[radaros/voice-gateway] Error closing session on disconnect:",
+            err instanceof Error ? err.message : err
+          );
+        }
+        activeSessions.delete(socket.id);
+      }
+    });
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MCPManager,
+  buildMultiModalInput,
+  createA2AServer,
+  createAdminRouter,
+  createAgentGateway,
+  createAgentRouter,
+  createBrowserGateway,
+  createFileUploadMiddleware,
+  createVoiceGateway,
+  errorHandler,
+  generateAgentCard,
+  generateMultiAgentCard,
+  generateOpenAPISpec,
+  requestLogger
+});