@radaros/transport 0.3.6 → 0.3.8

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { Agent, Team, Workflow, A2AAgentCard } from '@radaros/core';
+import { Agent, Team, Workflow, VoiceAgent, EventBus, A2AAgentCard } from '@radaros/core';
 
 interface FileUploadOptions {
     maxFileSize?: number;
@@ -79,6 +79,74 @@ interface GatewayOptions {
 
 declare function createAgentGateway(opts: GatewayOptions): void;
 
+interface VoiceGatewayOptions {
+    agents: Record<string, VoiceAgent>;
+    io: any;
+    namespace?: string;
+    authMiddleware?: (socket: any, next: (err?: Error) => void) => void;
+}
+declare function createVoiceGateway(opts: VoiceGatewayOptions): void;
+
+/**
+ * Minimal interface for a BrowserAgent — avoids a hard dependency on @radaros/browser.
+ * Any object that matches this shape (e.g. a real BrowserAgent) works.
+ */
+interface BrowserAgentLike {
+    name: string;
+    eventBus: EventBus;
+    run(task: string, opts?: {
+        startUrl?: string;
+        apiKey?: string;
+        sessionId?: string;
+    }): Promise<{
+        result: string;
+        success: boolean;
+        finalUrl: string;
+        durationMs: number;
+        videoPath?: string;
+        steps: Array<{
+            index: number;
+            action: unknown;
+            screenshot: Buffer;
+            pageUrl: string;
+            pageTitle: string;
+            dom?: string;
+        }>;
+    }>;
+}
+interface BrowserGatewayOptions {
+    /** Named BrowserAgent instances. Clients select one via agentName. */
+    agents: Record<string, BrowserAgentLike>;
+    /** Socket.IO server instance */
+    io: any;
+    /** Socket.IO namespace. Default: "/radaros-browser" */
+    namespace?: string;
+    /** Optional auth middleware applied to the namespace */
+    authMiddleware?: (socket: any, next: (err?: Error) => void) => void;
+    /**
+     * Stream screenshots to the client in real-time.
+     * Default: true. Disable for bandwidth-constrained clients.
+     */
+    streamScreenshots?: boolean;
+}
+/**
+ * Create a Socket.IO gateway that streams BrowserAgent execution in real-time.
+ *
+ * ## Client → Server events
+ * - `browser.start` — kick off a browser task
+ * - `browser.stop`  — cancel a running task
+ *
+ * ## Server → Client events
+ * - `browser.started`    — task accepted
+ * - `browser.screenshot` — live screenshot (base64 PNG)
+ * - `browser.action`     — action about to execute
+ * - `browser.step`       — full step with screenshot + DOM
+ * - `browser.done`       — task finished (result, success, duration, video)
+ * - `browser.error`      — error occurred
+ * - `browser.stopped`    — task was cancelled
+ */
+declare function createBrowserGateway(opts: BrowserGatewayOptions): void;
+
 interface A2AServerOptions {
     agents: Record<string, Agent>;
     basePath?: string;
@@ -113,4 +181,4 @@ declare function generateMultiAgentCard(agents: Record<string, Agent>, serverUrl
     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 };
+export { type A2AServerOptions, type BrowserGatewayOptions, type FileUploadOptions, type GatewayOptions, type RouterOptions, type SwaggerOptions, type VoiceGatewayOptions, buildMultiModalInput, createA2AServer, createAgentGateway, createAgentRouter, createBrowserGateway, createFileUploadMiddleware, createVoiceGateway, errorHandler, generateAgentCard, generateMultiAgentCard, generateOpenAPISpec, requestLogger };

package/dist/index.js

@@ -767,6 +767,237 @@ function createAgentGateway(opts) {
   });
 }
 
+// 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("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 {
+        }
+        activeSessions.delete(socket.id);
+      }
+    });
+  });
+}
+
+// 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/a2a/a2a-server.ts
 import { createRequire as createRequire4 } from "module";
 import { randomUUID } from "crypto";
@@ -1118,7 +1349,9 @@ export {
   createA2AServer,
   createAgentGateway,
   createAgentRouter,
+  createBrowserGateway,
   createFileUploadMiddleware,
+  createVoiceGateway,
   errorHandler,
   generateAgentCard,
   generateMultiAgentCard,

package/package.json

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