@radaros/transport 0.3.13 → 0.3.14

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, 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>>;
@@ -175,6 +193,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;

package/dist/index.js

@@ -431,6 +431,7 @@ function requestLogger(options) {
 
 // src/express/router-factory.ts
 import { createRequire as createRequire4 } from "module";
+import { classifyServables, 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,138 @@ 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());
+    });
+  }
   return router;
 }
 
@@ -1261,6 +1404,7 @@ function createBrowserGateway(opts) {
 }
 
 // src/socketio/gateway.ts
+import { classifyServables as classifyServables2, registry as globalRegistry2 } from "@radaros/core";
 function createSocketRateLimiter(maxPerMinute = 60) {
   return () => {
     let count = 0;
@@ -1277,6 +1421,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 +1450,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`
@@ -1332,7 +1485,19 @@ function createAgentGateway(opts) {
     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.14",
   "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.14",
     "@types/express": "^4.0.0 || ^5.0.0",
     "express": "^4.0.0 || ^5.0.0",
     "multer": ">=2.0.0",