@fudrouter/fsrouter 0.6.64 → 0.6.65

package/open-sse/handlers/imageProviders/runwayml.js

@@ -0,0 +1,72 @@
+/**
+ * RunwayML image and video generation adapter.
+ *
+ * Providers: runwayml
+ * Auth: Bearer token + X-Runway-Version header
+ * Format: JSON body → async polling
+ * Polling: Yes — polls task ID until status == "SUCCEEDED"
+ *
+ * Model routing:
+ * - "*_image*" model IDs → POST /text_to_image (image generation)
+ * - all others           → POST /image_to_video (video generation)
+ *
+ * Image model params:
+ * @param {string}  prompt         - (required) Image description (sent as promptText)
+ * @param {string}  [size]         - Maps to ratio: "1:1"|"16:9"|"9:16" etc.
+ * @param {string}  [image]        - Reference image URL (referenceImages[])
+ *
+ * Video model params:
+ * @param {string}  prompt         - (required) Video description (promptText)
+ * @param {string}  [image]        - Start frame URL (promptImage)
+ * @param {number}  [duration=5]   - Video duration in seconds
+ * @param {string}  [resolution]   - "720p"|"1080p"
+ *
+ * Response normalize: output[] → { created, data: [{ url }] }.
+ */
+// Runway ML — async submit + /tasks/{id} polling
+import { sleep, nowSec, sizeToAspectRatio, POLL_INTERVAL_MS, POLL_TIMEOUT_MS } from "./_base.js";
+
+const BASE_URL = "https://api.dev.runwayml.com/v1";
+
+export default {
+  async: true,
+  buildUrl: (model) => {
+    // Image models (gen4_image*) → text_to_image; video models → image_to_video
+    return `${BASE_URL}/${model.includes("image") ? "text_to_image" : "image_to_video"}`;
+  },
+  buildHeaders: (creds) => {
+    const key = creds?.apiKey || creds?.accessToken;
+    return {
+      "Content-Type": "application/json",
+      "Authorization": `Bearer ${key}`,
+      "X-Runway-Version": "2024-11-06",
+    };
+  },
+  buildBody: (model, body) => {
+    const isVideo = !model.includes("image");
+    const ratio = sizeToAspectRatio(body.size);
+    if (isVideo) {
+      return { promptText: body.prompt, model, ratio, duration: 5, ...(body.image ? { promptImage: body.image } : {}) };
+    }
+    return { promptText: body.prompt, model, ratio, ...(body.image ? { referenceImages: [{ uri: body.image }] } : {}) };
+  },
+  async parseResponse(response, { headers }) {
+    const { id } = await response.json();
+    if (!id) throw new Error("Runway: no task id returned");
+    const taskUrl = `${BASE_URL}/tasks/${id}`;
+    const deadline = Date.now() + POLL_TIMEOUT_MS;
+    while (Date.now() < deadline) {
+      await sleep(POLL_INTERVAL_MS);
+      const r = await fetch(taskUrl, { headers });
+      if (!r.ok) throw new Error(`Runway status ${r.status}`);
+      const s = await r.json();
+      if (s.status === "SUCCEEDED") return s;
+      if (s.status === "FAILED" || s.status === "CANCELLED") throw new Error(s.failure || "Runway task failed");
+    }
+    throw new Error("Runway polling timeout");
+  },
+  normalize: (responseBody) => {
+    const outputs = Array.isArray(responseBody.output) ? responseBody.output : [];
+    return { created: nowSec(), data: outputs.map((url) => ({ url })) };
+  },
+};

package/open-sse/handlers/imageProviders/sdwebui.js

@@ -0,0 +1,36 @@
+/**
+ * Stable Diffusion WebUI (Automatic1111) local adapter.
+ *
+ * Providers: sdwebui (self-hosted instance)
+ * Auth: Optional HTTP Basic auth (username/password)
+ * Format: JSON body → sync JSON response
+ * Polling: None (synchronous, but can be slow)
+ *
+ * Supported request params:
+ * @param {string}  prompt              - (required) Positive prompt
+ * @param {number}  [n=1]               - Number of images (batch_size)
+ * @param {string}  [size="512x512"]    - Dimensions e.g. "512x512", "768x768" → width/height
+ * @param {string}  [negative_prompt]   - Tokens to exclude
+ * @param {number}  [seed]              - Fixed seed (-1 = random)
+ * @param {number}  [guidance=7]        - CFG scale
+ * @param {number}  [num_steps=20]      - Sampling steps
+ *
+ * Response normalize: extracts images[0] → { created, data: [{ b64_json }] }.
+ */
+// SD WebUI (AUTOMATIC1111) — local, noAuth
+import { nowSec } from "./_base.js";
+
+export default {
+  noAuth: true,
+  buildUrl: () => "http://localhost:7860/sdapi/v1/txt2img",
+  buildHeaders: () => ({ "Content-Type": "application/json" }),
+  buildBody: (_model, body) => {
+    const { prompt, n = 1, size = "1024x1024" } = body;
+    const [width, height] = size.split("x").map(Number);
+    return { prompt, width: width || 512, height: height || 512, steps: 20, batch_size: n };
+  },
+  normalize: (responseBody) => {
+    const images = Array.isArray(responseBody.images) ? responseBody.images.map((img) => ({ b64_json: img })) : [];
+    return { created: nowSec(), data: images };
+  },
+};

package/open-sse/handlers/imageProviders/stabilityAi.js

@@ -0,0 +1,59 @@
+/**
+ * Stability AI v2beta image generation adapter.
+ *
+ * Providers: stability-ai
+ * Auth: Bearer token via Authorization header (apiKey or accessToken)
+ * Format: JSON body → sync JSON response ({ image: "<b64>" })
+ * Polling: None (synchronous)
+ *
+ * Endpoint routing by model:
+ * - "stable-image-ultra" → /ultra
+ * - "sd3*"               → /sd3
+ * - all others           → /core
+ *
+ * Supported request params:
+ * @param {string}  prompt                   - (required) Image description
+ * @param {string}  [size="1024x1024"]       - Maps to aspect_ratio: "1:1"|"16:9"|"9:16"|"4:3"|"3:2"|"2:3"
+ * @param {string}  [style]                  - Style preset (core only): "anime"|"photographic"|"cinematic" etc.
+ * @param {string}  [negative_prompt]        - Elements to exclude
+ * @param {number}  [seed]                   - Fixed seed
+ * @param {number}  [guidance]               - CFG scale
+ * @param {string}  [output_format="png"]    - "png"|"jpeg"|"webp"
+ * @param {string}  [model]                  - SD3 only: "sd3.5-large"|"sd3.5-large-turbo"|"sd3.5-medium"
+ *
+ * Response normalize: { image: b64 } → { created, data: [{ b64_json }] }.
+ */
+// Stability AI v2 — sync, returns { image: "<b64>" }
+import { nowSec, sizeToAspectRatio } from "./_base.js";
+
+const BASE_URL = "https://api.stability.ai/v2beta/stable-image/generate";
+
+// Map model id → endpoint segment
+function modelToEndpoint(model) {
+  if (model.includes("ultra")) return "ultra";
+  if (model.includes("sd3")) return "sd3";
+  return "core";
+}
+
+export default {
+  buildUrl: (model) => `${BASE_URL}/${modelToEndpoint(model)}`,
+  buildHeaders: (creds) => {
+    const key = creds?.apiKey || creds?.accessToken;
+    return {
+      "Content-Type": "application/json",
+      "Authorization": `Bearer ${key}`,
+      "Accept": "application/json",
+    };
+  },
+  buildBody: (model, body) => {
+    const req = { prompt: body.prompt, output_format: (body.output_format || "png").toLowerCase() };
+    if (body.size) req.aspect_ratio = sizeToAspectRatio(body.size);
+    if (body.style) req.style_preset = body.style;
+    if (model.includes("sd3")) req.model = model;
+    return req;
+  },
+  normalize: (responseBody) => {
+    if (responseBody.image) return { created: nowSec(), data: [{ b64_json: responseBody.image }] };
+    return { created: nowSec(), data: [] };
+  },
+};

package/open-sse/handlers/imageProviders/weavy.js

@@ -0,0 +1,222 @@
+/**
+ * Weavy AI image and video generation adapter.
+ *
+ * Providers: weavy
+ * Auth: Firebase JWT Bearer token + x-weavy-* headers
+ *       Requires: accessToken (or apiKey), optionally email/connectionName
+ * Format: POST duplicate-recipe → then delegates to weavy_generate.py subprocess
+ * Polling: Handled entirely by weavy_generate.py (polls Weavy batch status)
+ *
+ * MODEL TYPE DETECTION:
+ * - Model IDs registered as type="image" → --model-type image
+ * - Model IDs registered as type="video" → --model-type video
+ * - Detected at runtime by checking PROVIDER_MODELS registry
+ *
+ * NOTE: Weavy image models use FAL-style image_size names (square_hd, portrait_16_9, etc.).
+ *       The backend (weavy_service.py) maps these to the appropriate format per model:
+ *       - FAL models: image_size = "portrait_16_9" etc. (passed directly)
+ *       - Replicate/Google: aspect_ratio = "9:16" etc. (converted from FAL name)
+ *       - GPT Image 2: size = "1024x1536" etc. (converted via size_map)
+ *
+ * Supported request params (image models):
+ * @param {string}  prompt              - (required) Image/video description
+ * @param {string}  [size="1:1"]        - Aspect ratio: "1:1"|"16:9"|"9:16"|"4:3"|"3:2"|"2:3"
+ * @param {string}  [negative_prompt]   - Elements to exclude (model-dependent)
+ * @param {string}  [image_url]         - Reference/start-frame image URL
+ *
+ * Additional params for video models:
+ * @param {number}  [duration]          - Duration in seconds (model-specific: 5/8/10 etc.)
+ * @param {string}  [video_url]         - Reference video URL (motion-strength models)
+ * @param {string}  [end_image_url]     - End/last-frame image URL (first-last-frame models)
+ *
+ * Headers:
+ * @header Authorization              Bearer {token}
+ * @header x-weavy-auth-provider      "firebase"
+ * @header x-weavy-token              JWT token
+ * @header x-weavy-email              User email
+ */
+import path from "path";
+import { execFile } from "child_process";
+import { promisify } from "util";
+import { PROVIDER_MODELS } from "../../config/providerModels.js";
+import { updateProviderConnection } from '../../../dist/lib/localDb.js';
+
+const TEMPLATE_ID = "SZXXYN7L9PN2SCTVYAlt";
+
+// 10 MB buffer — avoids ENOBUFS on heavy stderr logs
+const MAX_BUFFER = 10 * 1024 * 1024;
+// Timeout slightly longer than Python's own 180 s image timeout
+const EXEC_TIMEOUT_MS = 240_000; // 4 minutes
+
+export default {
+  skipFetch: true,
+
+  buildUrl: (_model, _creds) => {
+    return `https://api.weavy.ai/api/v1/recipes/${TEMPLATE_ID}/duplicate`;
+  },
+
+  buildHeaders: (...args) => {
+    const creds = args[0];
+    const token = creds?.accessToken || creds?.apiKey || "";
+    const email = creds?.email || creds?.name || creds?.connectionName || "";
+    const connectionId = creds?.connectionId || creds?.id || "";
+    return {
+      "x-weavy-auth-provider": "firebase",
+      "x-app-version": "4.1.489",
+      "authorization": `Bearer ${token}`,
+      "Accept": "application/json",
+      "Content-Type": "application/json",
+      "x-weavy-email": email,
+      "x-weavy-token": token,
+      "x-weavy-connection-id": connectionId,
+      "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/122.0.0.0 Safari/537.36",
+    };
+  },
+
+  buildBody: async (_model, _body) => {
+    return {};
+  },
+
+  async parseResponse(response, { headers, log, model, body }) {
+    const email = headers["x-weavy-email"] || "";
+    const token = headers["x-weavy-token"] || "";
+    const connId = headers["x-weavy-connection-id"] || "";
+    const prompt = body.prompt || "";
+    const size = body.size || "1:1";
+    const modelId = model.replace(/^weavy-/, "");
+    const imageUrl = body.image_url || body.imageReference || body.start_frame || body.startFrame || "";
+    const endImageUrl = body.end_image_url || body.endImageUrl || "";
+    const videoUrl = body.video_url || body.videoUrl || "";
+    const negativePrompt = body.negative_prompt || "";
+    const duration = body.duration ? parseInt(body.duration, 10) : undefined;
+
+    // Detect model type from registry (image vs video)
+    const weavyModels = PROVIDER_MODELS["weavy"] || [];
+    const modelEntry = weavyModels.find(m => m.id === model);
+    const modelType = modelEntry?.type === "video" ? "video" : "image";
+
+    log?.debug?.("WEAVY", `Running generation via python: email=${email}, model=${modelId}, type=${modelType}, prompt="${prompt.slice(0, 30)}..." img=${imageUrl ? "yes" : "no"} endImg=${endImageUrl ? "yes" : "no"} video=${videoUrl ? "yes" : "no"} dur=${duration ?? "none"} negPrompt=${negativePrompt ? "yes" : "no"}`);
+
+    const venvPython = path.resolve(process.cwd(), ".venv/bin/python");
+    const scriptPath = path.resolve(process.cwd(), "src/automation/weavy_generate.py");
+    const profilesDir = path.resolve(process.cwd(), "profiles/weavy");
+    
+    const execFileAsync = promisify(execFile);
+    let stdout;
+    let stderr;
+    try {
+      const args = [
+        scriptPath,
+        "--email", email,
+        "--prompt", prompt,
+        "--aspect-ratio", size,
+        "--model-type", modelType,
+        "--model", modelId,
+        "--profiles-dir", profilesDir,
+        "--token", token,
+      ];
+      if (imageUrl) {
+        args.push("--image-url", imageUrl);
+      }
+      if (endImageUrl) {
+        args.push("--end-image-url", endImageUrl);
+      }
+      if (videoUrl) {
+        args.push("--video-url", videoUrl);
+      }
+      if (duration !== undefined && !isNaN(duration)) {
+        args.push("--duration", String(duration));
+      }
+      if (negativePrompt) {
+        args.push("--negative-prompt", negativePrompt);
+      }
+
+      const res = await execFileAsync(venvPython, args, {
+        maxBuffer: MAX_BUFFER,
+        timeout: EXEC_TIMEOUT_MS,
+      });
+      stdout = res.stdout;
+      stderr = res.stderr;
+    } catch (err) {
+      if (err.message && token) {
+        err.message = err.message.split(token).join("[REDACTED_JWT_TOKEN]");
+      }
+      if (err.stderr) {
+        log?.debug?.("WEAVY", `stderr: ${err.stderr.slice(0, 500)}`);
+      }
+      if (err.killed || err.code === "ETIMEDOUT") {
+        throw new Error("Weavy image generation timed out (Node exec limit)");
+      }
+      // Surface actual Python error message from stdout JSON (e.g. "only available on paid plans").
+      // When Python exits with code 1, execFile throws with a generic "Command failed: ..." message
+      // and the real error sits in err.stdout — which error classification rules can't match.
+      if (err.stdout) {
+        try {
+          const pyOut = JSON.parse(err.stdout.trim());
+          if (pyOut?.message) {
+            const actualMsg = token ? pyOut.message.split(token).join("[REDACTED_JWT_TOKEN]") : pyOut.message;
+            log?.debug?.("WEAVY", `python error: ${actualMsg.slice(0, 300)}`);
+            throw new Error(actualMsg);
+          }
+        } catch (innerErr) {
+          if (innerErr !== err) throw innerErr; // re-throw the new Error we just constructed
+          // stdout wasn't valid JSON → fall through to original error
+        }
+      }
+      throw err;
+    }
+
+    // Surface Python stderr for debugging
+    if (stderr) {
+      log?.debug?.("WEAVY", `python stderr: ${stderr.slice(0, 500)}`);
+    }
+
+    let parsed;
+    try {
+      parsed = JSON.parse(stdout.trim());
+    } catch (parseErr) {
+      log?.debug?.("WEAVY", `JSON parse failed. stdout="${stdout.slice(0, 200)}"`);
+      throw new Error(`Weavy image returned non-JSON output: ${stdout.slice(0, 200)}`);
+    }
+
+    if (parsed.status === "success" && Array.isArray(parsed.urls)) {
+      if (connId) {
+        const updates = {};
+        if (parsed.balance !== undefined) {
+          updates.last_balance = parsed.balance;
+        }
+        if (parsed.refreshed_token) {
+          updates.accessToken = parsed.refreshed_token;
+          updates.cached_jwt = parsed.refreshed_token;
+          updates.testStatus = "active";
+          try {
+            const payload = JSON.parse(Buffer.from(parsed.refreshed_token.split('.')[1], 'base64').toString());
+            if (payload && payload.exp) {
+              updates.jwt_expires_at = payload.exp;
+              updates.expiresAt = new Date(payload.exp * 1000).toISOString();
+            }
+          } catch (e) {
+            const exp = Math.floor(Date.now() / 1000) + 3600;
+            updates.jwt_expires_at = exp;
+            updates.expiresAt = new Date(exp * 1000).toISOString();
+          }
+        }
+        if (Object.keys(updates).length > 0) {
+          updateProviderConnection(connId, updates).catch(() => {});
+        }
+      }
+      return {
+        created: Math.floor(Date.now() / 1000),
+        data: parsed.urls.map(url => ({ url }))
+      };
+    } else {
+      throw new Error(parsed.message || "Weavy generation failed");
+    }
+  },
+
+  normalize: (parsed) => {
+    if (parsed?.created && Array.isArray(parsed?.data)) return parsed;
+    const urls = Array.isArray(parsed?.data) ? parsed.data : [];
+    return { created: Math.floor(Date.now() / 1000), data: urls };
+  },
+};

package/open-sse/handlers/moderations.js

@@ -0,0 +1,92 @@
+/**
+ * Moderation Handler
+ *
+ * Handles POST /v1/moderations (OpenAI Moderations API format).
+ * Converted from OmniRoute TypeScript.
+ */
+
+const CORS_HEADERS = {
+  "Access-Control-Allow-Origin": "*",
+  "Access-Control-Allow-Methods": "GET, POST, PUT, DELETE, OPTIONS",
+  "Access-Control-Allow-Headers": "Content-Type, Authorization",
+};
+
+import { MODERATION_PROVIDERS, parseModerationModel, getModerationProvider } from "../config/moderationRegistry.js";
+
+// ── Inline stubs for @/ imports ──────────────────────────────────────
+function attachOmniRouteMetaHeaders(headers, meta) {
+  if (meta.provider) headers.set("X-Provider", meta.provider);
+  if (meta.model) headers.set("X-Model", meta.model);
+  if (meta.latencyMs != null) headers.set("X-Latency-Ms", String(meta.latencyMs));
+}
+
+function generateRequestId() {
+  return crypto.randomUUID();
+}
+
+import { errorResponse } from "../utils/error.js";
+
+/**
+ * Handle moderation request
+ */
+export async function handleModeration({ body, credentials }) {
+  const startTime = Date.now();
+  if (!body.input) {
+    return errorResponse(400, "input is required");
+  }
+
+  // Default to latest moderation model
+  const model = body.model || "omni-moderation-latest";
+  const { provider: providerId, model: modelId } = parseModerationModel(model);
+  const providerConfig = providerId ? getModerationProvider(providerId) : null;
+
+  if (!providerConfig) {
+    return errorResponse(
+      400,
+      `No moderation provider found for model "${model}". Available: openai`
+    );
+  }
+
+  const token = credentials?.apiKey || credentials?.accessToken;
+  if (!token) {
+    return errorResponse(401, `No credentials for moderation provider: ${providerId}`);
+  }
+
+  try {
+    const res = await fetch(providerConfig.baseUrl, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${token}`,
+      },
+      body: JSON.stringify({
+        model: modelId,
+        input: body.input,
+      }),
+    });
+
+    if (!res.ok) {
+      const errText = await res.text();
+      return new Response(errText, {
+        status: res.status,
+        headers: {
+          "Content-Type": "application/json",
+          ...CORS_HEADERS,
+        },
+      });
+    }
+
+    const data = await res.json();
+    const headers = new Headers({ ...CORS_HEADERS, "Content-Type": "application/json" });
+    attachOmniRouteMetaHeaders(headers, {
+      provider: providerId,
+      model: modelId,
+      costUsd: 0,
+      latencyMs: Date.now() - startTime,
+      requestId: generateRequestId(),
+    });
+    return new Response(JSON.stringify(data), { status: 200, headers });
+  } catch (err) {
+    return errorResponse(500, `Moderation request failed: ${err.message}`);
+  }
+}

package/open-sse/handlers/ocr.js

@@ -0,0 +1,89 @@
+/**
+ * OCR Handler
+ *
+ * Handles POST /v1/ocr (Mistral OCR API format).
+ * Converted from OmniRoute TypeScript.
+ */
+
+const CORS_HEADERS = {
+  "Access-Control-Allow-Origin": "*",
+  "Access-Control-Allow-Methods": "GET, POST, PUT, DELETE, OPTIONS",
+  "Access-Control-Allow-Headers": "Content-Type, Authorization",
+};
+
+import { OCR_PROVIDERS, parseOcrModel, getOcrProvider } from "../config/ocrRegistry.js";
+
+// ── Inline stubs for @/ imports ──────────────────────────────────────
+function attachOmniRouteMetaHeaders(headers, meta) {
+  if (meta.provider) headers.set("X-Provider", meta.provider);
+  if (meta.model) headers.set("X-Model", meta.model);
+  if (meta.latencyMs != null) headers.set("X-Latency-Ms", String(meta.latencyMs));
+}
+
+function generateRequestId() {
+  return crypto.randomUUID();
+}
+
+import { errorResponse } from "../utils/error.js";
+
+/**
+ * Handle OCR request
+ */
+export async function handleOcr({ body, credentials }) {
+  const startTime = Date.now();
+  if (!body.document) {
+    return errorResponse(400, "document is required");
+  }
+
+  // Default to latest OCR model
+  const model = body.model || "mistral-ocr-latest";
+  const { provider: providerId, model: modelId } = parseOcrModel(model);
+  const providerConfig = providerId ? getOcrProvider(providerId) : null;
+
+  if (!providerConfig) {
+    return errorResponse(400, `No OCR provider found for model "${model}". Available: mistral`);
+  }
+
+  const token = credentials?.apiKey || credentials?.accessToken;
+  if (!token) {
+    return errorResponse(401, `No credentials for OCR provider: ${providerId}`);
+  }
+
+  try {
+    const res = await fetch(providerConfig.baseUrl, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${token}`,
+      },
+      body: JSON.stringify({
+        ...body,
+        model: modelId,
+      }),
+    });
+
+    if (!res.ok) {
+      const errText = await res.text();
+      return new Response(errText, {
+        status: res.status,
+        headers: {
+          "Content-Type": "application/json",
+          ...CORS_HEADERS,
+        },
+      });
+    }
+
+    const data = await res.json();
+    const headers = new Headers({ ...CORS_HEADERS, "Content-Type": "application/json" });
+    attachOmniRouteMetaHeaders(headers, {
+      provider: providerId,
+      model: modelId,
+      costUsd: 0,
+      latencyMs: Date.now() - startTime,
+      requestId: generateRequestId(),
+    });
+    return new Response(JSON.stringify(data), { status: 200, headers });
+  } catch (err) {
+    return errorResponse(500, `OCR request failed: ${err.message}`);
+  }
+}