@radaros/transport 0.3.13 → 0.3.15

package/README.md

@@ -29,8 +29,9 @@ app.listen(3000);
 
 ## Features
 
-- **Express Router** — REST API with streaming support
-- **Socket.IO Gateway** — Real-time WebSocket communication
+- **Auto-Discovery** — Reads from the global `Registry` at request time; agents created after server start are immediately available
+- **Express Router** — REST API with streaming support and list endpoints (`GET /agents`, `/teams`, `/workflows`, `/tools`)
+- **Socket.IO Gateway** — Real-time WebSocket communication with dynamic agent/team lookup and tool discovery
 - **A2A Server** — Agent-to-Agent protocol support
 - **CORS & Rate Limiting** — Built-in security middleware
 - **Swagger** — Auto-generated API documentation

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { Agent, A2AAgentCard, Team, Workflow, EventBus, VoiceAgent } from '@radaros/core';
+import { Agent, A2AAgentCard, Registry, Servable, Team, Workflow, ToolDef, Toolkit, EventBus, VoiceAgent } from '@radaros/core';
 
 interface A2AServerOptions {
     agents: Record<string, Agent>;
@@ -71,6 +71,24 @@ interface SwaggerOptions {
     specPath?: string;
 }
 interface RouterOptions {
+    /**
+     * Use a Registry for live auto-discovery. The router creates dynamic routes
+     * that resolve agents/teams/workflows at request time — any instance created
+     * after the router is mounted is automatically available.
+     *
+     * When omitted, falls back to the global registry from `@radaros/core`.
+     * Pass `false` to disable registry-based routing entirely (use explicit maps only).
+     *
+     * @example
+     * createAgentRouter({ cors: true });
+     * new Agent({ name: "bot", model: openai("gpt-4o") }); // immediately routable
+     */
+    registry?: Registry | false;
+    /**
+     * Auto-discover agents, teams, and workflows from a mixed array.
+     * Each item is classified by its `.kind` and keyed by `.name`.
+     */
+    serve?: Servable[];
     agents?: Record<string, Agent>;
     teams?: Record<string, Team>;
     workflows?: Record<string, Workflow<any>>;
@@ -86,6 +104,10 @@ interface RouterOptions {
         windowMs?: number;
         max?: number;
     } | boolean;
+    /** Named tool library exposed via GET /tools. Tools from toolkits are auto-collected. */
+    toolLibrary?: Record<string, ToolDef>;
+    /** Toolkit instances whose tools are exposed via GET /tools. Merged with toolLibrary. */
+    toolkits?: Toolkit[];
 }
 
 declare function createAgentRouter(opts: RouterOptions): any;
@@ -175,6 +197,24 @@ interface BrowserGatewayOptions {
 declare function createBrowserGateway(opts: BrowserGatewayOptions): void;
 
 interface GatewayOptions {
+    /**
+     * Use a Registry for live auto-discovery. The gateway resolves agents/teams
+     * at event time — any instance created after the gateway starts is automatically
+     * reachable.
+     *
+     * When omitted, falls back to the global registry from `@radaros/core`.
+     * Pass `false` to disable registry-based lookup (use explicit maps only).
+     *
+     * @example
+     * createAgentGateway({ io });
+     * new Agent({ name: "bot", model: openai("gpt-4o") }); // immediately reachable
+     */
+    registry?: Registry | false;
+    /**
+     * Auto-discover agents and teams from a mixed array.
+     * Each item is classified by its `.kind` and keyed by `.name`.
+     */
+    serve?: Servable[];
     agents?: Record<string, Agent>;
     teams?: Record<string, Team>;
     io: any;
@@ -182,6 +222,10 @@ interface GatewayOptions {
     authMiddleware?: (socket: any, next: (err?: Error) => void) => void;
     /** Max requests per minute per socket. Default: 60 */
     maxRequestsPerMinute?: number;
+    /** Named tool library exposed via tools.list event. */
+    toolLibrary?: Record<string, ToolDef>;
+    /** Toolkit instances whose tools are exposed via tools.list. Merged with toolLibrary. */
+    toolkits?: Toolkit[];
 }
 
 declare function createAgentGateway(opts: GatewayOptions): void;

package/dist/index.js

@@ -431,6 +431,7 @@ function requestLogger(options) {
 
 // src/express/router-factory.ts
 import { createRequire as createRequire4 } from "module";
+import { classifyServables, collectToolkitTools, describeToolLibrary, registry as globalRegistry } from "@radaros/core";
 
 // src/express/swagger.ts
 import { createRequire as createRequire3 } from "module";
@@ -955,6 +956,16 @@ function extractApiKey(req, agent) {
   return req.body?.apiKey ?? void 0;
 }
 function createAgentRouter(opts) {
+  if (opts.serve?.length) {
+    const discovered = 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 ?? globalRegistry;
   let express;
   try {
     express = _require4("express");
@@ -1144,6 +1155,154 @@ function createAgentRouter(opts) {
       });
     }
   }
+  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());
+    });
+  }
+  const fromToolkits = opts.toolkits ? collectToolkitTools(opts.toolkits) : {};
+  const mergedTools = { ...fromToolkits, ...opts.toolLibrary ?? {} };
+  if (Object.keys(mergedTools).length > 0) {
+    router.get("/tools", (_req, res) => {
+      res.json(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;
 }
 
@@ -1261,6 +1420,7 @@ function createBrowserGateway(opts) {
 }
 
 // src/socketio/gateway.ts
+import { classifyServables as classifyServables2, collectToolkitTools as collectToolkitTools2, describeToolLibrary as describeToolLibrary2, registry as globalRegistry2 } from "@radaros/core";
 function createSocketRateLimiter(maxPerMinute = 60) {
   return () => {
     let count = 0;
@@ -1277,6 +1437,15 @@ function createSocketRateLimiter(maxPerMinute = 60) {
   };
 }
 function createAgentGateway(opts) {
+  if (opts.serve?.length) {
+    const discovered = classifyServables2(opts.serve);
+    opts = {
+      ...opts,
+      agents: { ...discovered.agents, ...opts.agents },
+      teams: { ...discovered.teams, ...opts.teams }
+    };
+  }
+  const reg = opts.registry === false ? null : opts.registry ?? globalRegistry2;
   const ns = opts.io.of(opts.namespace ?? "/radaros");
   if (opts.authMiddleware) {
     ns.use(opts.authMiddleware);
@@ -1297,7 +1466,7 @@ function createAgentGateway(opts) {
         socket.emit("agent.error", { error: "Invalid sessionId: must be a string" });
         return;
       }
-      const agent = opts.agents?.[data.name];
+      const agent = opts.agents?.[data.name] ?? reg?.getAgent(data.name);
       if (!agent) {
         socket.emit("agent.error", {
           error: `Agent "${data.name}" not found`
@@ -1329,10 +1498,70 @@ function createAgentGateway(opts) {
         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 ? collectToolkitTools2(opts.toolkits) : {};
+    const mergedTools = { ...fromToolkits, ...opts.toolLibrary ?? {} };
+    socket.on("tools.list", (_data, ack) => {
+      ack?.(describeToolLibrary2(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) => {
-      const team = opts.teams?.[data.name];
+      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`

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@radaros/transport",
-  "version": "0.3.13",
+  "version": "0.3.15",
   "description": "HTTP and WebSocket transport layer for RadarOS agents",
   "license": "MIT",
   "repository": {
@@ -39,7 +39,7 @@
     "typescript": "^5.6.0"
   },
   "peerDependencies": {
-    "@radaros/core": "^0.3.13",
+    "@radaros/core": "^0.3.15",
     "@types/express": "^4.0.0 || ^5.0.0",
     "express": "^4.0.0 || ^5.0.0",
     "multer": ">=2.0.0",