@radaros/transport 0.3.2 → 0.3.3

package/package.json

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

package/dist/index.d.ts

@@ -1,116 +0,0 @@
-import { Agent, Team, Workflow, A2AAgentCard } from '@radaros/core';
-
-interface FileUploadOptions {
-    maxFileSize?: number;
-    maxFiles?: number;
-    allowedMimeTypes?: string[];
-}
-declare function createFileUploadMiddleware(opts?: FileUploadOptions): any;
-declare function buildMultiModalInput(body: any, files?: any[]): string | any[];
-
-interface SwaggerOptions {
-    /** Enable Swagger UI at /docs. Default: false */
-    enabled?: boolean;
-    /** API title shown in Swagger UI */
-    title?: string;
-    /** API description shown in Swagger UI */
-    description?: string;
-    /** API version string */
-    version?: string;
-    /** Route prefix used in path generation (e.g. "/api") */
-    routePrefix?: string;
-    /** Server URLs for the spec */
-    servers?: Array<{
-        url: string;
-        description?: string;
-    }>;
-    /** Path to serve Swagger UI. Default: "/docs" */
-    docsPath?: string;
-    /** Path to serve the raw OpenAPI JSON spec. Default: "/docs/spec.json" */
-    specPath?: string;
-}
-interface RouterOptions {
-    agents?: Record<string, Agent>;
-    teams?: Record<string, Team>;
-    workflows?: Record<string, Workflow<any>>;
-    middleware?: any[];
-    /** Swagger / OpenAPI configuration */
-    swagger?: SwaggerOptions;
-    /** File upload configuration for multi-modal inputs */
-    fileUpload?: boolean | FileUploadOptions;
-}
-
-declare function createAgentRouter(opts: RouterOptions): any;
-
-declare function errorHandler(): (err: any, _req: any, res: any, _next: any) => void;
-declare function requestLogger(): (req: any, _res: any, next: any) => void;
-
-interface OpenAPISpec {
-    openapi: string;
-    info: {
-        title: string;
-        description: string;
-        version: string;
-    };
-    servers?: Array<{
-        url: string;
-        description?: string;
-    }>;
-    paths: Record<string, Record<string, unknown>>;
-    components: {
-        schemas: Record<string, unknown>;
-        securitySchemes?: Record<string, unknown>;
-    };
-    security?: Array<Record<string, string[]>>;
-    tags: Array<{
-        name: string;
-        description: string;
-    }>;
-}
-declare function generateOpenAPISpec(routerOpts: RouterOptions, swaggerOpts?: SwaggerOptions): OpenAPISpec;
-
-interface GatewayOptions {
-    agents?: Record<string, Agent>;
-    teams?: Record<string, Team>;
-    io: any;
-    namespace?: string;
-    authMiddleware?: (socket: any, next: (err?: Error) => void) => void;
-}
-
-declare function createAgentGateway(opts: GatewayOptions): void;
-
-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

@@ -1,1127 +0,0 @@
-// src/express/router-factory.ts
-import { createRequire as createRequire3 } from "module";
-
-// src/express/swagger.ts
-import { createRequire } from "module";
-var _require = createRequire(import.meta.url);
-function zodSchemaToJsonSchema(schema) {
-  try {
-    const zodToJsonSchema = _require("zod-to-json-schema").default ?? _require("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 = _require("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/file-upload.ts
-import { createRequire as createRequire2 } from "module";
-var _require2 = createRequire2(import.meta.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 = _require2("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/router-factory.ts
-var _require3 = createRequire3(import.meta.url);
-var API_KEY_HEADERS = {
-  "x-openai-api-key": "openai",
-  "x-google-api-key": "google",
-  "x-anthropic-api-key": "anthropic",
-  "x-api-key": "_generic"
-};
-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) {
-  let express;
-  try {
-    express = _require3("express");
-  } catch {
-    throw new Error(
-      "express is required for createAgentRouter. Install it: npm install express"
-    );
-  }
-  const router = express.Router();
-  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 input = buildMultiModalInput(req.body, req.files);
-            if (!input) {
-              return res.status(400).json({ error: "input is required" });
-            }
-            const { sessionId, userId } = req.body ?? {};
-            const apiKey = extractApiKey(req, agent);
-            const result = await agent.run(input, { sessionId, userId, apiKey });
-            res.json(result);
-          } catch (error) {
-            res.status(500).json({ error: error.message });
-          }
-        })
-      );
-      router.post(`/agents/${name}/stream`, async (req, res) => {
-        try {
-          const { input, sessionId, userId } = req.body ?? {};
-          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"
-          });
-          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 { input, sessionId, userId } = req.body ?? {};
-          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, userId, apiKey });
-          res.json(result);
-        } catch (error) {
-          res.status(500).json({ error: error.message });
-        }
-      });
-      router.post(`/teams/${name}/stream`, async (req, res) => {
-        try {
-          const { input, sessionId, userId } = req.body ?? {};
-          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"
-          });
-          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 });
-        }
-      });
-    }
-  }
-  return router;
-}
-
-// src/express/middleware.ts
-function errorHandler() {
-  return (err, _req, res, _next) => {
-    console.error("[radaros:transport] Error:", err.message);
-    res.status(err.statusCode ?? 500).json({
-      error: err.message ?? "Internal server error"
-    });
-  };
-}
-function requestLogger() {
-  return (req, _res, next) => {
-    console.log(`[radaros:transport] ${req.method} ${req.path}`);
-    next();
-  };
-}
-
-// src/socketio/gateway.ts
-function createAgentGateway(opts) {
-  const ns = opts.io.of(opts.namespace ?? "/radaros");
-  if (opts.authMiddleware) {
-    ns.use(opts.authMiddleware);
-  }
-  ns.on("connection", (socket) => {
-    socket.on(
-      "agent.run",
-      async (data) => {
-        const agent = opts.agents?.[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(
-      "team.run",
-      async (data) => {
-        const team = opts.teams?.[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/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
-};