wyxrouter 0.4.71

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

@@ -0,0 +1,40 @@
+// OpenAI-compatible adapter (used by openai, minimax, openrouter, recraft)
+
+const ENDPOINTS = {
+  openai: "https://api.openai.com/v1/images/generations",
+  minimax: "https://api.minimaxi.com/v1/images/generations",
+  openrouter: "https://openrouter.ai/api/v1/images/generations",
+  recraft: "https://external.api.recraft.ai/v1/images/generations",
+  xai: "https://api.x.ai/v1/images/generations",
+};
+
+export default function createOpenAIAdapter(providerId) {
+  return {
+    buildUrl: () => ENDPOINTS[providerId],
+    buildHeaders: (creds) => {
+      const headers = { "Content-Type": "application/json" };
+      const key = creds?.apiKey || creds?.accessToken;
+      if (key) headers["Authorization"] = `Bearer ${key}`;
+      if (providerId === "openrouter") {
+        headers["HTTP-Referer"] = "https://endpoint-proxy.local";
+        headers["X-Title"] = "Endpoint Proxy";
+      }
+      return headers;
+    },
+    buildBody: (model, body) => {
+      const { prompt, n = 1, size = "1024x1024", quality, style, response_format } = body;
+      // xAI only accepts prompt, model, n, response_format
+      if (providerId === "xai") {
+        const req = { model, prompt, n };
+        if (response_format) req.response_format = response_format;
+        return req;
+      }
+      const req = { model, prompt, n, size };
+      if (quality) req.quality = quality;
+      if (style) req.style = style;
+      if (response_format) req.response_format = response_format;
+      return req;
+    },
+    normalize: (responseBody) => responseBody,
+  };
+}

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

@@ -0,0 +1,47 @@
+// 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,17 @@
+// 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,34 @@
+// 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/responsesHandler.js

@@ -0,0 +1,103 @@
+/**
+ * Responses API Handler for Workers
+ * Converts Chat Completions to Codex Responses API format
+ */
+
+import { handleChatCore } from "./chatCore.js";
+import { convertResponsesApiFormat } from "../translator/helpers/responsesApiHelper.js";
+import { createResponsesApiTransformStream } from "../transformer/responsesTransformer.js";
+import { convertResponsesStreamToJson } from "../transformer/streamToJsonConverter.js";
+
+/**
+ * Handle /v1/responses request
+ * @param {object} options
+ * @param {object} options.body - Request body (Responses API format)
+ * @param {object} options.modelInfo - { provider, model }
+ * @param {object} options.credentials - Provider credentials
+ * @param {object} options.log - Logger instance (optional)
+ * @param {function} options.onCredentialsRefreshed - Callback when credentials are refreshed
+ * @param {function} options.onRequestSuccess - Callback when request succeeds
+ * @param {function} options.onDisconnect - Callback when client disconnects
+ * @param {string} options.connectionId - Connection ID for usage tracking
+ * @returns {Promise<{success: boolean, response?: Response, status?: number, error?: string}>}
+ */
+export async function handleResponsesCore({ body, modelInfo, credentials, log, onCredentialsRefreshed, onRequestSuccess, onDisconnect, connectionId }) {
+  // Convert Responses API format to Chat Completions format
+  const convertedBody = convertResponsesApiFormat(body);
+
+  // Preserve client's stream preference (matches OpenClaw behavior)
+  // Default to false if omitted: Boolean(undefined) = false
+  const clientRequestedStreaming = convertedBody.stream === true;
+  if (convertedBody.stream === undefined) {
+    convertedBody.stream = false;
+  }
+
+  // Call chat core handler — force sourceFormat so streaming path knows this is a Responses API client
+  const result = await handleChatCore({
+    body: convertedBody,
+    modelInfo,
+    credentials,
+    log,
+    onCredentialsRefreshed,
+    onRequestSuccess,
+    onDisconnect,
+    connectionId,
+    sourceFormatOverride: "openai-responses"
+  });
+
+  if (!result.success || !result.response) {
+    return result;
+  }
+
+  const response = result.response;
+  const contentType = response.headers.get("Content-Type") || "";
+
+  // Case 1: Client wants non-streaming, but got SSE (provider forced it, e.g., Codex)
+  if (!clientRequestedStreaming && contentType.includes("text/event-stream")) {
+    try {
+      const jsonResponse = await convertResponsesStreamToJson(response.body);
+
+      return {
+        success: true,
+        response: new Response(JSON.stringify(jsonResponse), {
+          status: 200,
+          headers: {
+            "Content-Type": "application/json",
+            "Cache-Control": "no-cache",
+            "Access-Control-Allow-Origin": "*"
+          }
+        })
+      };
+    } catch (error) {
+      console.error("[Responses API] Stream-to-JSON conversion failed:", error);
+      return {
+        success: false,
+        status: 500,
+        error: "Failed to convert streaming response to JSON"
+      };
+    }
+  }
+
+  // Case 2: Client wants streaming, got SSE - transform it
+  if (clientRequestedStreaming && contentType.includes("text/event-stream")) {
+    const transformStream = createResponsesApiTransformStream(null);
+    const transformedBody = response.body.pipeThrough(transformStream);
+
+    return {
+      success: true,
+      response: new Response(transformedBody, {
+        status: 200,
+        headers: {
+          "Content-Type": "text/event-stream",
+          "Cache-Control": "no-cache",
+          "Connection": "keep-alive",
+          "Access-Control-Allow-Origin": "*"
+        }
+      })
+    };
+  }
+
+  // Case 3: Non-SSE response (error or non-streaming from provider) - return as-is
+  return result;
+}
+

package/open-sse/handlers/search/callers.js

@@ -0,0 +1,371 @@
+/**
+ * Search Provider Request Builders
+ *
+ * Ported from OmniRoute open-sse/handlers/search.ts (lines 223-610).
+ * Builds HTTP request `{ url, init }` for 10 search providers.
+ *
+ * @typedef {Object} SearchProviderConfig
+ * @property {string} id
+ * @property {string} baseUrl
+ * @property {string} [method]
+ *
+ * @typedef {Object} ContentOptions
+ * @property {boolean} [snippet]
+ * @property {boolean} [full_page]
+ * @property {string}  [format]
+ * @property {number}  [max_characters]
+ *
+ * @typedef {Object} SearchRequestParams
+ * @property {string}   query
+ * @property {string}   searchType
+ * @property {number}   maxResults
+ * @property {string}   [token]
+ * @property {string}   [country]
+ * @property {string}   [language]
+ * @property {string}   [timeRange]
+ * @property {number}   [offset]
+ * @property {string[]} [domainFilter]
+ * @property {ContentOptions}        [contentOptions]
+ * @property {Record<string,unknown>} [providerOptions]
+ * @property {Record<string,unknown>} [providerSpecificData]
+ */
+
+// ── Helpers ─────────────────────────────────────────────────────────────
+
+/**
+ * Split domain filter into includes / excludes (excludes prefixed with "-").
+ * @param {string[]} [domainFilter]
+ * @returns {{includes: string[], excludes: string[]}}
+ */
+export function parseDomainFilter(domainFilter) {
+  if (!domainFilter?.length) return { includes: [], excludes: [] };
+  const includes = domainFilter.filter((d) => !d.startsWith("-"));
+  const excludes = domainFilter.filter((d) => d.startsWith("-")).map((d) => d.slice(1));
+  return { includes, excludes };
+}
+
+/**
+ * Read string setting from providerOptions first, then providerSpecificData.
+ * @param {SearchRequestParams} params
+ * @param {string} key
+ * @returns {string|undefined}
+ */
+export function getProviderSetting(params, key) {
+  const fromOptions = params.providerOptions?.[key];
+  if (typeof fromOptions === "string" && fromOptions.trim().length > 0) {
+    return fromOptions.trim();
+  }
+  const fromProviderData = params.providerSpecificData?.[key];
+  if (typeof fromProviderData === "string" && fromProviderData.trim().length > 0) {
+    return fromProviderData.trim();
+  }
+  return undefined;
+}
+
+/**
+ * Resolve base URL with optional override from providerOptions.baseUrl.
+ * @param {SearchProviderConfig} config
+ * @param {SearchRequestParams} params
+ * @returns {string}
+ */
+export function resolveBaseUrl(config, params) {
+  const override = getProviderSetting(params, "baseUrl");
+  return (override || config.baseUrl).replace(/\/+$/, "");
+}
+
+/**
+ * Convert offset+maxResults to 1-indexed page number.
+ * @param {number|undefined} offset
+ * @param {number} maxResults
+ * @returns {number|undefined}
+ */
+export function toPageNumber(offset, maxResults) {
+  if (typeof offset !== "number" || offset <= 0 || maxResults <= 0) return undefined;
+  return Math.floor(offset / maxResults) + 1;
+}
+
+// ── Provider Request Builders ───────────────────────────────────────────
+
+function buildSerperRequest(config, params) {
+  const endpoint = params.searchType === "news" ? "/news" : "/search";
+  const body = { q: params.query, num: params.maxResults };
+  if (params.country) body.gl = params.country.toLowerCase();
+  if (params.language) body.hl = params.language;
+  return {
+    url: `${resolveBaseUrl(config, params)}${endpoint}`,
+    init: {
+      method: "POST",
+      headers: { "Content-Type": "application/json", "X-API-Key": params.token },
+      body: JSON.stringify(body),
+    },
+  };
+}
+
+function buildBraveRequest(config, params) {
+  const endpoint = params.searchType === "news" ? "/news/search" : "/web/search";
+  const qp = new URLSearchParams({ q: params.query, count: String(params.maxResults) });
+  if (params.country) qp.set("country", params.country);
+  if (params.language) qp.set("search_lang", params.language);
+  return {
+    url: `${resolveBaseUrl(config, params)}${endpoint}?${qp}`,
+    init: {
+      method: "GET",
+      headers: { Accept: "application/json", "X-Subscription-Token": params.token },
+    },
+  };
+}
+
+function buildPerplexityRequest(config, params) {
+  const body = { query: params.query, max_results: params.maxResults };
+  if (params.country) body.country = params.country;
+  if (params.language) body.search_language_filter = [params.language];
+  if (params.domainFilter?.length) body.search_domain_filter = params.domainFilter;
+  return {
+    url: resolveBaseUrl(config, params),
+    init: {
+      method: "POST",
+      headers: { "Content-Type": "application/json", Authorization: `Bearer ${params.token}` },
+      body: JSON.stringify(body),
+    },
+  };
+}
+
+function buildExaRequest(config, params) {
+  const { includes, excludes } = parseDomainFilter(params.domainFilter);
+  const body = {
+    query: params.query,
+    numResults: params.maxResults,
+    type: "auto",
+    text: true,
+    highlights: true,
+  };
+  if (includes.length) body.includeDomains = includes;
+  if (excludes.length) body.excludeDomains = excludes;
+  if (params.searchType === "news") body.category = "news";
+  return {
+    url: resolveBaseUrl(config, params),
+    init: {
+      method: "POST",
+      headers: { "Content-Type": "application/json", "x-api-key": params.token },
+      body: JSON.stringify(body),
+    },
+  };
+}
+
+function buildTavilyRequest(config, params) {
+  const { includes, excludes } = parseDomainFilter(params.domainFilter);
+  const body = {
+    query: params.query,
+    max_results: params.maxResults,
+    topic: params.searchType === "news" ? "news" : "general",
+  };
+  if (includes.length) body.include_domains = includes;
+  if (excludes.length) body.exclude_domains = excludes;
+  if (params.country) body.country = params.country;
+  return {
+    url: resolveBaseUrl(config, params),
+    init: {
+      method: "POST",
+      headers: { "Content-Type": "application/json", Authorization: `Bearer ${params.token}` },
+      body: JSON.stringify(body),
+    },
+  };
+}
+
+function buildGooglePseRequest(config, params) {
+  const apiKey = params.token;
+  const cx = getProviderSetting(params, "cx");
+  if (!apiKey || !cx) {
+    throw new Error("Google Programmable Search requires both apiKey and cx");
+  }
+  const qp = new URLSearchParams({
+    key: apiKey,
+    cx,
+    q: params.query,
+    num: String(Math.min(params.maxResults, 10)),
+  });
+  if (params.country) qp.set("gl", params.country.toLowerCase());
+  if (params.language) qp.set("hl", params.language);
+  if (params.timeRange && params.timeRange !== "any") {
+    const dateRestrictMap = { day: "d1", week: "w1", month: "m1", year: "y1" };
+    const dateRestrict = dateRestrictMap[params.timeRange];
+    if (dateRestrict) qp.set("dateRestrict", dateRestrict);
+  }
+  if (typeof params.offset === "number" && params.offset > 0) {
+    qp.set("start", String(Math.min(params.offset + 1, 91)));
+  }
+  return {
+    url: `${resolveBaseUrl(config, params)}?${qp}`,
+    init: {
+      method: "GET",
+      headers: { Accept: "application/json" },
+    },
+  };
+}
+
+function buildLinkupRequest(config, params) {
+  const apiKey = params.token;
+  if (!apiKey) throw new Error("Linkup Search requires an API key");
+
+  const { includes, excludes } = parseDomainFilter(params.domainFilter);
+  const requestedDepth = getProviderSetting(params, "depth");
+  const depth =
+    requestedDepth && ["fast", "standard", "deep"].includes(requestedDepth)
+      ? requestedDepth
+      : "standard";
+
+  const body = {
+    q: params.query,
+    depth,
+    outputType: "searchResults",
+    maxResults: params.maxResults,
+  };
+  if (includes.length) body.includeDomains = includes;
+  if (excludes.length) body.excludeDomains = excludes;
+  if (params.timeRange && params.timeRange !== "any") {
+    const today = new Date();
+    const toDate = today.toISOString().slice(0, 10);
+    const from = new Date(today);
+    if (params.timeRange === "day") from.setUTCDate(from.getUTCDate() - 1);
+    if (params.timeRange === "week") from.setUTCDate(from.getUTCDate() - 7);
+    if (params.timeRange === "month") from.setUTCMonth(from.getUTCMonth() - 1);
+    if (params.timeRange === "year") from.setUTCFullYear(from.getUTCFullYear() - 1);
+    body.fromDate = from.toISOString().slice(0, 10);
+    body.toDate = toDate;
+  }
+
+  return {
+    url: resolveBaseUrl(config, params),
+    init: {
+      method: "POST",
+      headers: { "Content-Type": "application/json", Authorization: `Bearer ${apiKey}` },
+      body: JSON.stringify(body),
+    },
+  };
+}
+
+function buildSearchApiRequest(config, params) {
+  const apiKey = params.token;
+  if (!apiKey) throw new Error("SearchAPI requires an API key");
+
+  const qp = new URLSearchParams({
+    engine: params.searchType === "news" ? "google_news" : "google",
+    q: params.query,
+    api_key: apiKey,
+  });
+  if (params.country) qp.set("gl", params.country.toLowerCase());
+  if (params.language) qp.set("hl", params.language);
+
+  const page = toPageNumber(params.offset, params.maxResults);
+  if (page) qp.set("page", String(page));
+
+  return {
+    url: `${resolveBaseUrl(config, params)}?${qp}`,
+    init: {
+      method: "GET",
+      headers: { Accept: "application/json" },
+    },
+  };
+}
+
+function buildYouComRequest(config, params) {
+  const apiKey = params.token;
+  if (!apiKey) throw new Error("You.com Search requires an API key");
+
+  const { includes, excludes } = parseDomainFilter(params.domainFilter);
+  const qp = new URLSearchParams({
+    query: params.query,
+    count: String(Math.min(params.maxResults, 100)),
+  });
+
+  if (params.timeRange && params.timeRange !== "any") qp.set("freshness", params.timeRange);
+  if (typeof params.offset === "number" && params.offset > 0 && params.maxResults > 0) {
+    qp.set("offset", String(Math.min(Math.floor(params.offset / params.maxResults), 9)));
+  }
+  if (params.country) qp.set("country", params.country);
+  if (params.language) qp.set("language", params.language);
+  if (includes.length) qp.set("include_domains", includes.join(","));
+  if (excludes.length) qp.set("exclude_domains", excludes.join(","));
+
+  if (params.contentOptions?.full_page) {
+    qp.set("livecrawl", params.searchType === "news" ? "news" : "web");
+    qp.append(
+      "livecrawl_formats",
+      params.contentOptions.format === "markdown" ? "markdown" : "html"
+    );
+  }
+
+  return {
+    url: `${resolveBaseUrl(config, params)}?${qp}`,
+    init: {
+      method: "GET",
+      headers: { Accept: "application/json", "X-API-Key": apiKey },
+    },
+  };
+}
+
+function buildSearxngRequest(config, params) {
+  const baseUrl = resolveBaseUrl(config, params);
+  const url = baseUrl.endsWith("/search") ? baseUrl : `${baseUrl}/search`;
+  const qp = new URLSearchParams({
+    q: params.query,
+    format: "json",
+    categories: params.searchType === "news" ? "news" : "general",
+  });
+  if (params.language) qp.set("language", params.language);
+  if (params.timeRange && params.timeRange !== "any") qp.set("time_range", params.timeRange);
+
+  const page = toPageNumber(params.offset, params.maxResults);
+  if (page) qp.set("pageno", String(page));
+
+  return {
+    url: `${url}?${qp}`,
+    init: {
+      method: "GET",
+      headers: { Accept: "application/json" },
+    },
+  };
+}
+
+// ── Dispatcher ──────────────────────────────────────────────────────────
+
+const BUILDERS = {
+  "serper": buildSerperRequest,
+  "brave-search": buildBraveRequest,
+  "perplexity": buildPerplexityRequest,
+  "exa": buildExaRequest,
+  "tavily": buildTavilyRequest,
+  "google-pse": buildGooglePseRequest,
+  "linkup": buildLinkupRequest,
+  "searchapi": buildSearchApiRequest,
+  "youcom": buildYouComRequest,
+  "searxng": buildSearxngRequest,
+};
+
+/**
+ * Dispatch to the correct provider builder by `provider.id`.
+ * Falls back to generic POST + bearer auth for unknown providers.
+ * @param {SearchProviderConfig} provider
+ * @param {SearchRequestParams} params
+ * @returns {{url: string, init: RequestInit}}
+ */
+export function buildSearchRequest(provider, params) {
+  const builder = BUILDERS[provider.id];
+  if (builder) return builder(provider, params);
+
+  return {
+    url: resolveBaseUrl(provider, params),
+    init: {
+      method: provider.method || "POST",
+      headers: {
+        "Content-Type": "application/json",
+        ...(params.token ? { Authorization: `Bearer ${params.token}` } : {}),
+      },
+      body: JSON.stringify({
+        query: params.query,
+        max_results: params.maxResults,
+        search_type: params.searchType,
+      }),
+    },
+  };
+}