@radaros/transport 0.1.0

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@radaros/transport",
+  "version": "0.1.0",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format esm --dts --clean",
+    "dev": "tsup src/index.ts --format esm --dts --watch"
+  },
+  "devDependencies": {
+    "@types/node": "^25.3.1",
+    "tsup": "^8.0.0",
+    "typescript": "^5.6.0"
+  },
+  "peerDependencies": {
+    "@radaros/core": "^0.1.0",
+    "@types/express": "^4.0.0 || ^5.0.0",
+    "express": "^4.0.0 || ^5.0.0",
+    "multer": ">=1.4.0",
+    "socket.io": "^4.0.0",
+    "swagger-ui-express": "^5.0.0"
+  },
+  "peerDependenciesMeta": {
+    "express": {
+      "optional": true
+    },
+    "socket.io": {
+      "optional": true
+    },
+    "@types/express": {
+      "optional": true
+    },
+    "multer": {
+      "optional": true
+    },
+    "swagger-ui-express": {
+      "optional": true
+    }
+  }
+}

package/src/express/file-upload.ts

@@ -0,0 +1,88 @@
+import { createRequire } from "node:module";
+
+const _require = createRequire(import.meta.url);
+
+const MIME_TO_PART_TYPE: Record<string, "image" | "audio" | "file"> = {
+  "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: string): "image" | "audio" | "file" {
+  return MIME_TO_PART_TYPE[mimeType] ?? "file";
+}
+
+export interface FileUploadOptions {
+  maxFileSize?: number;
+  maxFiles?: number;
+  allowedMimeTypes?: string[];
+}
+
+export function createFileUploadMiddleware(opts: FileUploadOptions = {}) {
+  let multer: any;
+  try {
+    multer = _require("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: any, file: any, cb: any) => {
+          if (opts.allowedMimeTypes!.includes(file.mimetype)) {
+            cb(null, true);
+          } else {
+            cb(new Error(`File type ${file.mimetype} is not allowed`));
+          }
+        }
+      : undefined,
+  });
+
+  return upload.array("files", opts.maxFiles ?? 10);
+}
+
+export function filesToContentParts(files: any[]): any[] {
+  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 } : {}),
+    };
+  });
+}
+
+export function buildMultiModalInput(body: any, files?: any[]): string | any[] {
+  const textInput = body?.input;
+  if (!files || files.length === 0) {
+    return textInput;
+  }
+
+  const parts: any[] = [];
+  if (textInput) {
+    parts.push({ type: "text", text: textInput });
+  }
+  parts.push(...filesToContentParts(files));
+  return parts;
+}

package/src/express/middleware.ts

@@ -0,0 +1,15 @@
+export function errorHandler() {
+  return (err: any, _req: any, res: any, _next: any) => {
+    console.error("[radaros:transport] Error:", err.message);
+    res.status(err.statusCode ?? 500).json({
+      error: err.message ?? "Internal server error",
+    });
+  };
+}
+
+export function requestLogger() {
+  return (req: any, _res: any, next: any) => {
+    console.log(`[radaros:transport] ${req.method} ${req.path}`);
+    next();
+  };
+}

package/src/express/router-factory.ts

@@ -0,0 +1,208 @@
+import { createRequire } from "node:module";
+import type { RouterOptions } from "./types.js";
+import { generateOpenAPISpec, serveSwaggerUI } from "./swagger.js";
+import { createFileUploadMiddleware, buildMultiModalInput } from "./file-upload.js";
+
+const _require = createRequire(import.meta.url);
+
+const API_KEY_HEADERS: Record<string, string> = {
+  "x-openai-api-key": "openai",
+  "x-google-api-key": "google",
+  "x-anthropic-api-key": "anthropic",
+  "x-api-key": "_generic",
+};
+
+function extractApiKey(req: any, agent: any): string | undefined {
+  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 ?? undefined;
+}
+
+export function createAgentRouter(opts: RouterOptions) {
+  let express: any;
+  try {
+    express = _require("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);
+    }
+  }
+
+  // ── File upload middleware (lazy-initialized) ───────────────────────────
+  let uploadMiddleware: any = null;
+  if (opts.fileUpload) {
+    const uploadOpts = typeof opts.fileUpload === "object" ? opts.fileUpload : {};
+    uploadMiddleware = createFileUploadMiddleware(uploadOpts);
+  }
+
+  function withUpload(handler: (req: any, res: any) => Promise<void>) {
+    if (!uploadMiddleware) return handler;
+    return (req: any, res: any, next: any) => {
+      uploadMiddleware(req, res, (err: any) => {
+        if (err) {
+          return res.status(400).json({ error: err.message });
+        }
+        handler(req, res).catch(next);
+      });
+    };
+  }
+
+  // ── Swagger UI ──────────────────────────────────────────────────────────
+  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: any, res: any) => {
+      res.json(spec);
+    });
+
+    try {
+      const { serve, setup } = serveSwaggerUI(spec);
+      router.use(docsPath, serve, setup);
+    } catch (e: any) {
+      console.warn(`[radaros:transport] Swagger UI disabled: ${e.message}`);
+    }
+  }
+
+  // ── Agent endpoints ─────────────────────────────────────────────────────
+  if (opts.agents) {
+    for (const [name, agent] of Object.entries(opts.agents)) {
+      router.post(
+        `/agents/${name}/run`,
+        withUpload(async (req: any, res: any) => {
+          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: any) {
+            res.status(500).json({ error: error.message });
+          }
+        })
+      );
+
+      router.post(`/agents/${name}/stream`, async (req: any, res: any) => {
+        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)}\n\n`);
+          }
+
+          res.write("data: [DONE]\n\n");
+          res.end();
+        } catch (error: any) {
+          if (!res.headersSent) {
+            res.status(500).json({ error: error.message });
+          } else {
+            res.write(
+              `data: ${JSON.stringify({ type: "error", error: error.message })}\n\n`
+            );
+            res.end();
+          }
+        }
+      });
+    }
+  }
+
+  // ── Team endpoints ──────────────────────────────────────────────────────
+  if (opts.teams) {
+    for (const [name, team] of Object.entries(opts.teams)) {
+      router.post(`/teams/${name}/run`, async (req: any, res: any) => {
+        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: any) {
+          res.status(500).json({ error: error.message });
+        }
+      });
+
+      router.post(`/teams/${name}/stream`, async (req: any, res: any) => {
+        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)}\n\n`);
+          }
+
+          res.write("data: [DONE]\n\n");
+          res.end();
+        } catch (error: any) {
+          if (!res.headersSent) {
+            res.status(500).json({ error: error.message });
+          } else {
+            res.write(
+              `data: ${JSON.stringify({ type: "error", error: error.message })}\n\n`
+            );
+            res.end();
+          }
+        }
+      });
+    }
+  }
+
+  // ── Workflow endpoints ──────────────────────────────────────────────────
+  if (opts.workflows) {
+    for (const [name, workflow] of Object.entries(opts.workflows)) {
+      router.post(`/workflows/${name}/run`, async (req: any, res: any) => {
+        try {
+          const { sessionId, userId } = req.body ?? {};
+          const result = await workflow.run({ sessionId, userId });
+          res.json(result);
+        } catch (error: any) {
+          res.status(500).json({ error: error.message });
+        }
+      });
+    }
+  }
+
+  return router;
+}