zevairouter 1.0.153 → 1.0.155

package/open-sse/handlers/fetch/index.js

@@ -1,237 +0,0 @@
-// Web Fetch handler — dispatches to firecrawl, jina-reader, tavily, exa
-// Returns normalized shape across all providers
-
-const DEFAULT_TIMEOUT_MS = 15000;
-const DEFAULT_FORMAT = "markdown";
-
-/**
- * @typedef {Object} FetchResult
- * @property {boolean} success
- * @property {number} [status]
- * @property {string} [error]
- * @property {Object} [data]
- */
-
-/**
- * Fetch with timeout abort.
- * @param {string} url
- * @param {RequestInit} init
- * @param {number} timeoutMs
- */
-// Strip non-ASCII chars from header values (HTTP headers must be ByteString).
-function sanitizeHeaders(headers) {
-  if (!headers) return headers;
-  const out = {};
-  for (const [k, v] of Object.entries(headers)) {
-    out[k] = typeof v === "string" ? v.replace(/[^\x00-\xFF]/g, "").trim() : v;
-  }
-  return out;
-}
-
-async function tryFetch(url, init, timeoutMs) {
-  const ctrl = new AbortController();
-  const timer = setTimeout(() => ctrl.abort(), timeoutMs);
-  try {
-    const res = await fetch(url, { ...init, headers: sanitizeHeaders(init.headers), signal: ctrl.signal });
-    return { ok: true, res };
-  } catch (err) {
-    const isAbort = err?.name === "AbortError";
-    return { ok: false, timeout: isAbort, error: err?.message || String(err) };
-  } finally {
-    clearTimeout(timer);
-  }
-}
-
-function truncate(text, max) {
-  if (!text || typeof text !== "string") return text || "";
-  if (!max || max <= 0) return text;
-  return text.length > max ? text.slice(0, max) : text;
-}
-
-function parseJinaTitle(text) {
-  const m = String(text || "").match(/^\s*#\s+(.+)$/m);
-  return m ? m[1].trim() : null;
-}
-
-function buildData({ provider, url, title, format, text, costUsd, responseMs, upstreamMs }) {
-  return {
-    provider,
-    url,
-    title: title || null,
-    content: { format, text: text || "", length: (text || "").length },
-    metadata: { author: null, published_at: null, language: null },
-    usage: { fetch_cost_usd: costUsd ?? null },
-    metrics: { response_time_ms: responseMs, upstream_latency_ms: upstreamMs }
-  };
-}
-
-async function readJsonOrText(res) {
-  const ct = res.headers.get("content-type") || "";
-  if (ct.includes("application/json")) {
-    try { return { json: await res.json() }; } catch { return { text: "" }; }
-  }
-  return { text: await res.text() };
-}
-
-/**
- * Main handler.
- * @param {Object} params
- * @param {string} params.url
- * @param {string} [params.format]
- * @param {number} [params.maxCharacters]
- * @param {string} params.provider
- * @param {Object} [params.providerConfig]
- * @param {Object} [params.credentials]
- * @param {Function} [params.log]
- * @returns {Promise<FetchResult>}
- */
-export async function handleFetchCore({ url, format, maxCharacters, provider, providerConfig, credentials, log }) {
-  if (!url || typeof url !== "string") {
-    return { success: false, status: 400, error: "url is required" };
-  }
-  if (!provider) {
-    return { success: false, status: 400, error: "provider is required" };
-  }
-
-  const fmt = format || DEFAULT_FORMAT;
-  const timeoutMs = providerConfig?.timeoutMs || DEFAULT_TIMEOUT_MS;
-  const apiKey = credentials?.apiKey || credentials?.key || credentials?.token || "";
-  const costPerQuery = providerConfig?.costPerQuery ?? null;
-  const startedAt = Date.now();
-
-  try {
-    if (provider === "firecrawl") {
-      return await runFirecrawl({ url, fmt, timeoutMs, apiKey, maxCharacters, costPerQuery, startedAt });
-    }
-    if (provider === "jina-reader") {
-      return await runJina({ url, fmt, timeoutMs, apiKey, maxCharacters, costPerQuery, startedAt });
-    }
-    if (provider === "tavily") {
-      return await runTavily({ url, fmt, timeoutMs, apiKey, maxCharacters, costPerQuery, startedAt });
-    }
-    if (provider === "exa") {
-      return await runExa({ url, fmt, timeoutMs, apiKey, maxCharacters, costPerQuery, startedAt });
-    }
-    return { success: false, status: 400, error: `Unsupported provider: ${provider}` };
-  } catch (err) {
-    log?.("fetch handler error:", err?.message || err);
-    return { success: false, status: 502, error: err?.message || "Internal fetch error" };
-  }
-}
-
-async function runFirecrawl({ url, fmt, timeoutMs, apiKey, maxCharacters, costPerQuery, startedAt }) {
-  const upstreamStart = Date.now();
-  const r = await tryFetch("https://api.firecrawl.dev/v1/scrape", {
-    method: "POST",
-    headers: {
-      "content-type": "application/json",
-      ...(apiKey ? { authorization: `Bearer ${apiKey}` } : {})
-    },
-    body: JSON.stringify({ url, formats: [fmt] })
-  }, timeoutMs);
-
-  if (!r.ok) {
-    return { success: false, status: r.timeout ? 504 : 502, error: r.error };
-  }
-  const upstreamMs = Date.now() - upstreamStart;
-  const { json } = await readJsonOrText(r.res);
-  if (!r.res.ok) {
-    return { success: false, status: r.res.status, error: json?.error || `Firecrawl error: ${r.res.status}` };
-  }
-  const d = json?.data || {};
-  const text = truncate(d.markdown || d.html || d.text || "", maxCharacters);
-  const title = d.metadata?.title || null;
-  return {
-    success: true,
-    data: buildData({
-      provider: "firecrawl", url, title, format: fmt, text,
-      costUsd: costPerQuery, responseMs: Date.now() - startedAt, upstreamMs
-    })
-  };
-}
-
-async function runJina({ url, fmt, timeoutMs, apiKey, maxCharacters, costPerQuery, startedAt }) {
-  const target = `https://r.jina.ai/${encodeURIComponent(url)}`;
-  const upstreamStart = Date.now();
-  const r = await tryFetch(target, {
-    method: "GET",
-    headers: apiKey ? { authorization: `Bearer ${apiKey}` } : {}
-  }, timeoutMs);
-
-  if (!r.ok) {
-    return { success: false, status: r.timeout ? 504 : 502, error: r.error };
-  }
-  const upstreamMs = Date.now() - upstreamStart;
-  const body = await r.res.text();
-  if (!r.res.ok) {
-    return { success: false, status: r.res.status, error: body?.slice(0, 500) || `Jina error: ${r.res.status}` };
-  }
-  const text = truncate(body, maxCharacters);
-  return {
-    success: true,
-    data: buildData({
-      provider: "jina-reader", url, title: parseJinaTitle(body), format: fmt, text,
-      costUsd: costPerQuery, responseMs: Date.now() - startedAt, upstreamMs
-    })
-  };
-}
-
-async function runTavily({ url, fmt, timeoutMs, apiKey, maxCharacters, costPerQuery, startedAt }) {
-  const upstreamStart = Date.now();
-  const r = await tryFetch("https://api.tavily.com/extract", {
-    method: "POST",
-    headers: {
-      "content-type": "application/json",
-      ...(apiKey ? { authorization: `Bearer ${apiKey}` } : {})
-    },
-    body: JSON.stringify({ urls: [url], extract_depth: "basic" })
-  }, timeoutMs);
-
-  if (!r.ok) {
-    return { success: false, status: r.timeout ? 504 : 502, error: r.error };
-  }
-  const upstreamMs = Date.now() - upstreamStart;
-  const { json } = await readJsonOrText(r.res);
-  if (!r.res.ok) {
-    return { success: false, status: r.res.status, error: json?.error || `Tavily error: ${r.res.status}` };
-  }
-  const first = json?.results?.[0] || {};
-  const text = truncate(first.raw_content || "", maxCharacters);
-  return {
-    success: true,
-    data: buildData({
-      provider: "tavily", url, title: null, format: fmt, text,
-      costUsd: costPerQuery, responseMs: Date.now() - startedAt, upstreamMs
-    })
-  };
-}
-
-async function runExa({ url, fmt, timeoutMs, apiKey, maxCharacters, costPerQuery, startedAt }) {
-  const upstreamStart = Date.now();
-  const r = await tryFetch("https://api.exa.ai/contents", {
-    method: "POST",
-    headers: {
-      "content-type": "application/json",
-      ...(apiKey ? { "x-api-key": apiKey } : {})
-    },
-    body: JSON.stringify({ ids: [url], text: true })
-  }, timeoutMs);
-
-  if (!r.ok) {
-    return { success: false, status: r.timeout ? 504 : 502, error: r.error };
-  }
-  const upstreamMs = Date.now() - upstreamStart;
-  const { json } = await readJsonOrText(r.res);
-  if (!r.res.ok) {
-    return { success: false, status: r.res.status, error: json?.error || `Exa error: ${r.res.status}` };
-  }
-  const first = json?.results?.[0] || {};
-  const text = truncate(first.text || "", maxCharacters);
-  return {
-    success: true,
-    data: buildData({
-      provider: "exa", url, title: first.title || null, format: fmt, text,
-      costUsd: costPerQuery, responseMs: Date.now() - startedAt, upstreamMs
-    })
-  };
-}

package/open-sse/handlers/imageGenerationCore.js

@@ -1,189 +0,0 @@
-import { createErrorResult, parseUpstreamError, formatProviderError } from "../utils/error.js";
-import { HTTP_STATUS } from "../config/runtimeConfig.js";
-import { refreshWithRetry } from "../services/tokenRefresh.js";
-import { getExecutor } from "../executors/index.js";
-import { getImageAdapter } from "./imageProviders/index.js";
-import { urlToBase64 } from "./imageProviders/_base.js";
-
-function serializeRequestBody(requestBody) {
-  if (typeof FormData !== "undefined" && requestBody instanceof FormData) return requestBody;
-  if (typeof requestBody === "string") return requestBody;
-  return JSON.stringify(requestBody);
-}
-
-/**
- * Core image generation handler — orchestrator only.
- * Provider-specific URL/headers/body/parse/normalize live in `./imageProviders/{id}.js`.
- *
- * @param {object} options
- * @param {object} options.body - Request body { model, prompt, n, size, ... }
- * @param {object} options.modelInfo - { provider, model }
- * @param {object} options.credentials - Provider credentials
- * @param {object} [options.log] - Logger
- * @param {boolean} [options.streamToClient] - Pipe SSE to client (codex)
- * @param {boolean} [options.binaryOutput] - Return raw image bytes
- * @param {function} [options.onCredentialsRefreshed]
- * @param {function} [options.onRequestSuccess]
- * @returns {Promise<{ success: boolean, response: Response, status?: number, error?: string }>}
- */
-export async function handleImageGenerationCore({
-  body,
-  modelInfo,
-  credentials,
-  log,
-  streamToClient = false,
-  binaryOutput = false,
-  onCredentialsRefreshed,
-  onRequestSuccess,
-}) {
-  const { provider, model } = modelInfo;
-
-  if (!body.prompt) {
-    return createErrorResult(HTTP_STATUS.BAD_REQUEST, "Missing required field: prompt");
-  }
-
-  const adapter = getImageAdapter(provider);
-  if (!adapter) {
-    return createErrorResult(
-      HTTP_STATUS.BAD_REQUEST,
-      `Provider '${provider}' does not support image generation`
-    );
-  }
-
-  let url;
-  let headers;
-  let requestBody;
-
-  try {
-    url = adapter.buildUrl(model, credentials);
-    requestBody = await adapter.buildBody(model, body);
-    headers = adapter.buildHeaders(credentials, requestBody, model, body);
-  } catch (error) {
-    return createErrorResult(HTTP_STATUS.BAD_REQUEST, error.message || `Invalid ${provider} image request`);
-  }
-
-  log?.debug?.("IMAGE", `${provider.toUpperCase()} | ${model} | prompt="${body.prompt.slice(0, 50)}..."`);
-
-  let providerResponse;
-  try {
-    providerResponse = await fetch(url, {
-      method: "POST",
-      headers,
-      body: serializeRequestBody(requestBody),
-    });
-  } catch (error) {
-    const errMsg = formatProviderError(error, provider, model, HTTP_STATUS.BAD_GATEWAY);
-    log?.debug?.("IMAGE", `Fetch error: ${errMsg}`);
-    return createErrorResult(HTTP_STATUS.BAD_GATEWAY, errMsg);
-  }
-
-  // Handle 401/403 — try token refresh (skipped for noAuth providers)
-  const executor = getExecutor(provider);
-  if (
-    !executor?.noAuth &&
-    !adapter.noAuth &&
-    (providerResponse.status === HTTP_STATUS.UNAUTHORIZED ||
-      providerResponse.status === HTTP_STATUS.FORBIDDEN)
-  ) {
-    const newCredentials = await refreshWithRetry(
-      () => executor.refreshCredentials(credentials, log),
-      3,
-      log
-    );
-
-    if (newCredentials?.accessToken || newCredentials?.apiKey) {
-      log?.info?.("TOKEN", `${provider.toUpperCase()} | refreshed for image generation`);
-      Object.assign(credentials, newCredentials);
-      if (onCredentialsRefreshed) await onCredentialsRefreshed(newCredentials);
-
-      try {
-        const retryBody = await adapter.buildBody(model, body);
-        const retryHeaders = adapter.buildHeaders(credentials, retryBody, model, body);
-        const retryUrl = adapter.buildUrl(model, credentials);
-        providerResponse = await fetch(retryUrl, {
-          method: "POST",
-          headers: retryHeaders,
-          body: serializeRequestBody(retryBody),
-        });
-      } catch {
-        log?.warn?.("TOKEN", `${provider.toUpperCase()} | retry after refresh failed`);
-      }
-    } else {
-      log?.warn?.("TOKEN", `${provider.toUpperCase()} | refresh failed`);
-    }
-  }
-
-  if (!providerResponse.ok) {
-    const { statusCode, message } = await parseUpstreamError(providerResponse);
-    const errMsg = formatProviderError(new Error(message), provider, model, statusCode);
-    log?.debug?.("IMAGE", `Provider error: ${errMsg}`);
-    return createErrorResult(statusCode, errMsg);
-  }
-
-  // Parse provider response — adapter may override (codex SSE / async polling / binary)
-  let parsed;
-  try {
-    if (adapter.parseResponse) {
-      parsed = await adapter.parseResponse(providerResponse, {
-        headers,
-        log,
-        streamToClient,
-        onRequestSuccess,
-        url,
-        requestBody,
-        model,
-        body,
-      });
-      // Codex streaming case: returns an SSE Response directly
-      if (parsed?.sseResponse) {
-        return { success: true, response: parsed.sseResponse };
-      }
-    } else {
-      parsed = await providerResponse.json();
-    }
-  } catch (parseError) {
-    return createErrorResult(HTTP_STATUS.BAD_GATEWAY, parseError.message || `Invalid response from ${provider}`);
-  }
-
-  if (onRequestSuccess) await onRequestSuccess();
-
-  // Normalize → OpenAI-compatible shape
-  const normalized = adapter.normalize(parsed, body.prompt);
-
-  // Already in OpenAI shape? skip re-normalize
-  const finalBody = (normalized.created && Array.isArray(normalized.data)) ? normalized : parsed;
-
-  // Binary output: decode first b64_json (or fetch url) into raw bytes
-  if (binaryOutput) {
-    const first = finalBody.data?.[0];
-    let b64 = first?.b64_json;
-    if (!b64 && first?.url) {
-      try { b64 = await urlToBase64(first.url); } catch {}
-    }
-    if (b64) {
-      const buf = Buffer.from(b64, "base64");
-      const fmt = (body.output_format || "png").toLowerCase();
-      const mime = fmt === "jpeg" || fmt === "jpg" ? "image/jpeg" : fmt === "webp" ? "image/webp" : "image/png";
-      return {
-        success: true,
-        response: new Response(buf, {
-          headers: {
-            "Content-Type": mime,
-            "Content-Disposition": `inline; filename="image.${fmt === "jpeg" ? "jpg" : fmt}"`,
-            "Access-Control-Allow-Origin": "*",
-          },
-        }),
-      };
-    }
-  }
-
-  return {
-    success: true,
-    response: new Response(JSON.stringify(finalBody), {
-      headers: {
-        "Content-Type": "application/json",
-        "Access-Control-Allow-Origin": "*",
-      },
-    }),
-  };
-}

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

@@ -1,31 +0,0 @@
-// Shared helpers for image provider adapters
-
-export const POLL_INTERVAL_MS = 1500;
-export const POLL_TIMEOUT_MS = 120000;
-
-export const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
-
-// Map OpenAI size to provider-specific aspect ratio
-export function sizeToAspectRatio(size) {
-  if (!size || typeof size !== "string") return "1:1";
-  const map = {
-    "1024x1024": "1:1",
-    "1024x1792": "9:16",
-    "1792x1024": "16:9",
-    "1024x1536": "2:3",
-    "1536x1024": "3:2",
-  };
-  return map[size] || "1:1";
-}
-
-// Fetch URL → base64 (for providers returning image URLs)
-export async function urlToBase64(url) {
-  const res = await fetch(url);
-  if (!res.ok) throw new Error(`Failed to fetch image: ${res.status}`);
-  const buf = await res.arrayBuffer();
-  return Buffer.from(buf).toString("base64");
-}
-
-export function nowSec() {
-  return Math.floor(Date.now() / 1000);
-}

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

@@ -1,46 +0,0 @@
-// Black Forest Labs (FLUX) — async submit + polling_url
-import { sleep, nowSec, POLL_INTERVAL_MS, POLL_TIMEOUT_MS } from "./_base.js";
-
-const BASE_URL = "https://api.bfl.ai/v1";
-
-const blackForestLabs = {
-  async: true,
-  buildUrl: (model) => `${BASE_URL}/${model}`,
-  buildHeaders: (creds) => {
-    const key = creds?.apiKey || creds?.accessToken;
-    return { "Content-Type": "application/json", "x-key": key };
-  },
-  buildBody: (_model, body) => {
-    const req = { prompt: body.prompt };
-    if (body.size) {
-      const [w, h] = body.size.split("x").map(Number);
-      if (w) req.width = w;
-      if (h) req.height = h;
-    }
-    if (body.image) req.image_prompt = body.image;
-    return req;
-  },
-  async parseResponse(response, { headers }) {
-    const data = await response.json();
-    const pollingUrl = data.polling_url;
-    if (!pollingUrl) throw new Error("BFL: no polling_url returned");
-    const deadline = Date.now() + POLL_TIMEOUT_MS;
-    while (Date.now() < deadline) {
-      await sleep(POLL_INTERVAL_MS);
-      const r = await fetch(pollingUrl, { headers: { "x-key": headers["x-key"], "Accept": "application/json" } });
-      if (!r.ok) throw new Error(`BFL status ${r.status}`);
-      const s = await r.json();
-      if (s.status === "Ready") return s;
-      if (s.status === "Error" || s.status === "Failed") throw new Error(s.error || "BFL generation failed");
-    }
-    throw new Error("BFL polling timeout");
-  },
-  normalize: (responseBody) => {
-    const sample = responseBody.result?.sample;
-    if (sample) return { created: nowSec(), data: [{ url: sample }] };
-    return { created: nowSec(), data: [] };
-  },
-};
-
-
-export default blackForestLabs;

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

@@ -1,181 +0,0 @@
-import { nowSec, urlToBase64 } from "./_base.js";
-
-const BASE_URL = "https://api.cloudflare.com/client/v4/accounts";
-
-const MULTIPART_MODELS = new Set([
-  "@cf/black-forest-labs/flux-2-dev",
-  "@cf/black-forest-labs/flux-2-klein-4b",
-  "@cf/black-forest-labs/flux-2-klein-9b",
-]);
-
-const OPTIONAL_FIELDS = [
-  "negative_prompt",
-  "guidance",
-  "seed",
-  "num_steps",
-  "steps",
-  "strength",
-];
-
-function sizeToDimensions(size) {
-  const match = /^(\d+)x(\d+)$/.exec(String(size || ""));
-  if (!match) return {};
-  return {
-    width: Number(match[1]),
-    height: Number(match[2]),
-  };
-}
-
-function getDimensions(body) {
-  return {
-    ...sizeToDimensions(body.size),
-    ...(Number.isFinite(Number(body.width)) ? { width: Number(body.width) } : {}),
-    ...(Number.isFinite(Number(body.height)) ? { height: Number(body.height) } : {}),
-  };
-}
-
-async function resolveImageInput(value) {
-  if (Array.isArray(value)) {
-    return { bytes: value, b64: Buffer.from(value).toString("base64") };
-  }
-  if (typeof value !== "string") return null;
-  const trimmed = value.trim();
-  if (!trimmed) return null;
-  if (/^https?:\/\//i.test(trimmed)) {
-    const b64 = await urlToBase64(trimmed);
-    return { bytes: base64ToBytes(b64), b64 };
-  }
-  const match = /^data:image\/[^;]+;base64,(.+)$/i.exec(trimmed);
-  const b64 = match ? match[1] : trimmed;
-  return { bytes: base64ToBytes(b64), b64 };
-}
-
-function base64ToBytes(value) {
-  try {
-    return Array.from(Buffer.from(value, "base64"));
-  } catch {
-    return value;
-  }
-}
-
-function addOptionalFields(target, body, append) {
-  for (const key of OPTIONAL_FIELDS) {
-    const value = body[key];
-    if (value === undefined || value === null || value === "") continue;
-    append(target, key, value);
-  }
-}
-
-async function buildJsonBody(body) {
-  const req = { prompt: body.prompt, ...getDimensions(body) };
-
-  addOptionalFields(req, body, (target, key, value) => {
-    target[key] = value;
-  });
-
-  const imageData = await resolveImageInput(body.image);
-  if (imageData) {
-    req.image_b64 = imageData.b64;
-    req.image = imageData.bytes;
-  }
-
-  const maskData = await resolveImageInput(body.mask_image || body.maskImage || body.mask);
-  if (maskData) {
-    req.mask_b64 = maskData.b64;
-    req.mask = maskData.bytes;
-    req.mask_image = maskData.bytes;
-  }
-
-  return req;
-}
-
-function buildMultipartBody(body) {
-  const form = new FormData();
-  form.append("prompt", body.prompt);
-
-  const dimensions = getDimensions(body);
-  for (const [key, value] of Object.entries(dimensions)) {
-    form.append(key, String(value));
-  }
-
-  addOptionalFields(form, body, (target, key, value) => {
-    target.append(key, String(value));
-  });
-
-  return form;
-}
-
-function imageItemFromString(value) {
-  if (typeof value !== "string" || !value) return null;
-  if (/^data:image\/[^;]+;base64,/i.test(value)) {
-    return { b64_json: value.replace(/^data:image\/[^;]+;base64,/i, "") };
-  }
-  if (/^https?:\/\//i.test(value)) return { url: value };
-  return { b64_json: value };
-}
-
-function normalizeCloudflareResponse(responseBody) {
-  if (responseBody?.created && Array.isArray(responseBody?.data)) return responseBody;
-
-  const result = responseBody?.result ?? responseBody;
-  const queuedResponse = Array.isArray(result?.responses)
-    ? result.responses.find((item) => item?.success !== false)?.result
-    : null;
-  if (queuedResponse) return normalizeCloudflareResponse(queuedResponse);
-
-  const image =
-    (typeof result === "string" ? result : null) ||
-    result?.image ||
-    result?.data?.[0]?.b64_json ||
-    result?.data?.[0]?.url;
-
-  const item = imageItemFromString(image);
-  return {
-    created: nowSec(),
-    data: item ? [item] : [],
-  };
-}
-
-const cloudflareAi = {
-  buildUrl: (model, creds) => {
-    const accountId = creds?.providerSpecificData?.accountId;
-    if (!accountId) throw new Error("cloudflare-ai requires accountId in providerSpecificData");
-    return `${BASE_URL}/${accountId}/ai/run/${model}`;
-  },
-
-  buildHeaders: (creds, requestBody) => {
-    const headers = {};
-    const isMultipart = typeof FormData !== "undefined" && requestBody instanceof FormData;
-    if (!isMultipart) {
-      headers["Content-Type"] = "application/json";
-    }
-    const key = creds?.apiKey || creds?.accessToken;
-    if (key) headers.Authorization = `Bearer ${key}`;
-    return headers;
-  },
-
-  buildBody: async (model, body) => (
-    MULTIPART_MODELS.has(model)
-      ? buildMultipartBody(body)
-      : await buildJsonBody(body)
-  ),
-
-  async parseResponse(response) {
-    const contentType = (response.headers.get("Content-Type") || "").toLowerCase();
-    if (contentType.startsWith("image/")) {
-      const buf = await response.arrayBuffer();
-      return {
-        created: nowSec(),
-        data: [{ b64_json: Buffer.from(buf).toString("base64") }],
-      };
-    }
-
-    const json = await response.json();
-    return normalizeCloudflareResponse(json);
-  },
-
-  normalize: normalizeCloudflareResponse,
-};
-
-
-export default cloudflareAi;