@fudrouter/fsrouter 0.6.63 → 0.6.64

package/open-sse/executors/t3-chat-web.js

@@ -1,417 +0,0 @@
-import { BaseExecutor } from "./base.ts";
-import { errorResponse } from "../utils/error.js";
-import { prepareToolMessages, buildToolAwareResult } from "../translator/webTools.ts";
-const T3_CHAT_BASE = "https://t3.chat";
-const SERVER_FN_PREFIX = `${T3_CHAT_BASE}/_serverFn/`;
-const USER_AGENT = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/149.0.0.0 Safari/537.36";
-const TSS_ACCEPT = "application/x-tss-framed, application/x-ndjson, application/json";
-function parseT3Credentials(creds) {
-  const rawCreds = typeof creds === "object" && creds !== null ? creds : {};
-  const raw = String(rawCreds.apiKey ?? rawCreds.accessToken ?? "").trim();
-  if (!raw) {
-    return { cookieHeader: "", cookies: "", convexSessionId: "" };
-  }
-  let cookieHeader = raw;
-  let convexSessionId = "";
-  if (raw.includes("convexSessionId") || raw.includes("convex-session-id")) {
-    const parts = raw.split(/[,;\n]/).map((s) => s.trim());
-    const cookieParts = [];
-    for (const part of parts) {
-      if (part.startsWith("convexSessionId=") || part.startsWith("convex-session-id=")) {
-        convexSessionId = part.split("=").slice(1).join("=");
-      } else if (part.startsWith("cookies=")) {
-        cookieParts.push(part.slice("cookies=".length));
-      } else if (part.includes("=")) {
-        cookieParts.push(part);
-      }
-    }
-    if (cookieParts.length) cookieHeader = cookieParts.join("; ");
-  }
-  const finalCookie = convexSessionId && !cookieHeader.includes("convex-session-id") ? `${cookieHeader}; convex-session-id=${convexSessionId}` : cookieHeader;
-  if (!convexSessionId) {
-    const m = finalCookie.match(/convex-session-id=([^;]+)/);
-    if (m) convexSessionId = m[1].trim();
-  }
-  return { cookieHeader: finalCookie, cookies: cookieHeader, convexSessionId };
-}
-function validateT3Credentials(creds) {
-  if (!creds) return false;
-  return typeof creds.cookieHeader === "string" && creds.cookieHeader.length > 0 && typeof creds.convexSessionId === "string" && creds.convexSessionId.length > 0;
-}
-function buildErrorResponse(status, message) {
-  return errorResponse(status, message);
-}
-function buildServerFnHeaders(cookieHeader) {
-  return {
-    "Content-Type": "application/json",
-    "User-Agent": USER_AGENT,
-    Accept: TSS_ACCEPT,
-    Cookie: cookieHeader,
-    Referer: `${T3_CHAT_BASE}/`,
-    Origin: T3_CHAT_BASE
-  };
-}
-function transformTSSStream(upstreamStream, model) {
-  const encoder = new TextEncoder();
-  const decoder = new TextDecoder();
-  const id = `chatcmpl-t3-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
-  const created = Math.floor(Date.now() / 1e3);
-  let emittedRole = false;
-  return new ReadableStream(
-    {
-      async start(controller) {
-        const reader = upstreamStream.getReader();
-        let buffer = "";
-        const emit = (obj) => {
-          controller.enqueue(encoder.encode(`data: ${JSON.stringify(obj)}
-
-`));
-        };
-        const chunk = (delta, finish) => {
-          emit({
-            id,
-            object: "chat.completion.chunk",
-            created,
-            model,
-            choices: [{ index: 0, delta, finish_reason: finish ?? null }]
-          });
-        };
-        const close = () => {
-          if (!emittedRole) {
-            emittedRole = true;
-            chunk({ role: "assistant", content: "" });
-          }
-          chunk({}, "stop");
-          controller.enqueue(encoder.encode("data: [DONE]\n\n"));
-          controller.close();
-        };
-        try {
-          while (true) {
-            const { done, value } = await reader.read();
-            if (done) break;
-            buffer += decoder.decode(value, { stream: true });
-            const lines = buffer.split("\n");
-            buffer = lines.pop() || "";
-            for (const line of lines) {
-              const trimmed = line.trim();
-              if (!trimmed) continue;
-              const payload = trimmed.startsWith("data: ") ? trimmed.slice(6).trim() : trimmed;
-              if (payload === "[DONE]") {
-                close();
-                return;
-              }
-              let data;
-              try {
-                data = JSON.parse(payload);
-              } catch {
-                continue;
-              }
-              const textContent = extractTextFromTSS(data);
-              if (typeof textContent === "string" && textContent.length > 0) {
-                if (!emittedRole) {
-                  emittedRole = true;
-                  chunk({ role: "assistant", content: "" });
-                }
-                chunk({ content: textContent });
-              }
-              if (isTSSDone(data)) {
-                close();
-                return;
-              }
-            }
-          }
-        } catch {
-        }
-        close();
-      }
-    },
-    { highWaterMark: 16384 }
-  );
-}
-function extractTextFromTSS(data) {
-  if (typeof data?.text === "string") return data.text;
-  if (typeof data?.delta === "string") return data.delta;
-  if (typeof data?.content === "string") return data.content;
-  const p = data?.p;
-  if (p?.k && p?.v && Array.isArray(p.k) && Array.isArray(p.v)) {
-    for (let i = 0; i < p.k.length; i++) {
-      if (p.k[i] === "content" || p.k[i] === "text" || p.k[i] === "delta") {
-        const val = p.v[i];
-        if (typeof val === "string") return val;
-        if (val?.t === 2 && typeof val?.s === "string") return val.s;
-      }
-    }
-  }
-  if (data?.t === 2 && typeof data?.s === "string") return data.s;
-  return null;
-}
-function isTSSDone(data) {
-  const d = data;
-  return d?.type === "done" || d?.done === true || d?.status === "complete" || d?.finish_reason === "stop";
-}
-async function collectStreamContent(upstreamStream) {
-  const decoder = new TextDecoder();
-  const reader = upstreamStream.getReader();
-  let buffer = "";
-  const parts = [];
-  while (true) {
-    const { done, value } = await reader.read();
-    if (done) break;
-    buffer += decoder.decode(value, { stream: true });
-    const lines = buffer.split("\n");
-    buffer = lines.pop() || "";
-    for (const line of lines) {
-      const trimmed = line.trim();
-      if (!trimmed) continue;
-      const payload = trimmed.startsWith("data: ") ? trimmed.slice(6).trim() : trimmed;
-      if (payload === "[DONE]") break;
-      try {
-        const data = JSON.parse(payload);
-        const text = extractTextFromTSS(data);
-        if (typeof text === "string") parts.push(text);
-      } catch {
-      }
-    }
-  }
-  return parts.join("");
-}
-class T3ChatWebExecutor extends BaseExecutor {
-  constructor() {
-    super("t3-web", { baseUrl: T3_CHAT_BASE });
-  }
-  async testConnection(credentials, signal) {
-    try {
-      const parsed = parseT3Credentials(credentials);
-      if (!validateT3Credentials(parsed)) return false;
-      const resp = await fetch(T3_CHAT_BASE, {
-        method: "HEAD",
-        headers: {
-          "User-Agent": USER_AGENT,
-          Cookie: parsed.cookieHeader
-        },
-        signal
-      });
-      return resp.status < 500;
-    } catch {
-      return false;
-    }
-  }
-  async execute({ model, body, stream, credentials, signal, log }) {
-    const bodyObj = body || {};
-    const rawMessages = Array.isArray(bodyObj.messages) ? bodyObj.messages : [];
-    const { hasTools, requestedTools, effectiveMessages } = prepareToolMessages(
-      bodyObj,
-      rawMessages
-    );
-    const parsed = parseT3Credentials(credentials);
-    if (!validateT3Credentials(parsed)) {
-      return {
-        response: buildErrorResponse(
-          400,
-          "t3.chat credentials invalid: paste your full Cookie header (including convex-session-id) from t3.chat."
-        ),
-        url: `${SERVER_FN_PREFIX}...`,
-        headers: {},
-        transformedBody: body
-      };
-    }
-    const cookieHeader = parsed.cookieHeader;
-    const headers = buildServerFnHeaders(cookieHeader);
-    try {
-      const requestPayload = {
-        model,
-        messages: effectiveMessages,
-        stream: stream !== false
-      };
-      const completionUrl = `${T3_CHAT_BASE}/api/chat`;
-      log?.info?.("T3-CHAT-WEB", `POST ${completionUrl} model=${model}`);
-      const resp = await fetch(completionUrl, {
-        method: "POST",
-        headers,
-        body: JSON.stringify(requestPayload),
-        signal
-      });
-      if (!resp.ok) {
-        const status = resp.status;
-        let errMsg = `t3.chat API error (${status})`;
-        if (status === 401 || status === 403) {
-          errMsg = "t3.chat session expired or unauthorized \u2014 re-paste your cookies and convex-session-id.";
-        } else if (status === 429) {
-          errMsg = "t3.chat rate limited. Wait and retry.";
-        }
-        log?.warn?.("T3-CHAT-WEB", errMsg);
-        return {
-          response: buildErrorResponse(status, errMsg),
-          url: completionUrl,
-          headers,
-          transformedBody: requestPayload
-        };
-      }
-      const ct = resp.headers.get("content-type") || "";
-      if (ct.includes("application/json") && !ct.includes("ndjson")) {
-        const json = await resp.json();
-        if (json?.error) {
-          const errMsg = `t3.chat error: ${json.error?.message ?? JSON.stringify(json.error)}`;
-          log?.warn?.("T3-CHAT-WEB", errMsg);
-          return {
-            response: buildErrorResponse(502, errMsg),
-            url: completionUrl,
-            headers,
-            transformedBody: requestPayload
-          };
-        }
-        if (json?.choices) {
-          return {
-            response: new Response(JSON.stringify(json), {
-              status: 200,
-              headers: { "Content-Type": "application/json" }
-            }),
-            url: completionUrl,
-            headers,
-            transformedBody: requestPayload
-          };
-        }
-        const content = extractTextFromTSS(json) ?? json?.message?.content ?? "";
-        const openaiResponse2 = {
-          id: `chatcmpl-t3-${Date.now()}`,
-          object: "chat.completion",
-          created: Math.floor(Date.now() / 1e3),
-          model: model || "unknown",
-          choices: [
-            {
-              index: 0,
-              message: { role: "assistant", content: String(content) },
-              finish_reason: "stop"
-            }
-          ],
-          usage: { prompt_tokens: 0, completion_tokens: 0, total_tokens: 0 }
-        };
-        return {
-          response: new Response(JSON.stringify(openaiResponse2), {
-            status: 200,
-            headers: { "Content-Type": "application/json" }
-          }),
-          url: completionUrl,
-          headers,
-          transformedBody: requestPayload
-        };
-      }
-      if (!resp.body) {
-        return {
-          response: buildErrorResponse(502, "t3.chat returned an empty response body"),
-          url: completionUrl,
-          headers,
-          transformedBody: requestPayload
-        };
-      }
-      if (stream !== false) {
-        const openaiStream = transformTSSStream(resp.body, model || "unknown");
-        return {
-          response: new Response(openaiStream, {
-            status: 200,
-            headers: { "Content-Type": "text/event-stream", "Cache-Control": "no-cache" }
-          }),
-          url: completionUrl,
-          headers,
-          transformedBody: requestPayload
-        };
-      }
-      const rawContent = await collectStreamContent(resp.body);
-      if (hasTools) {
-        const { content, toolCalls, finishReason } = buildToolAwareResult(
-          rawContent,
-          requestedTools,
-          "t3"
-        );
-        if (toolCalls) {
-          return {
-            response: new Response(
-              JSON.stringify({
-                id: `chatcmpl-t3-${Date.now()}`,
-                object: "chat.completion",
-                created: Math.floor(Date.now() / 1e3),
-                model: model || "unknown",
-                choices: [
-                  {
-                    index: 0,
-                    message: { role: "assistant", content: null, tool_calls: toolCalls },
-                    finish_reason: finishReason
-                  }
-                ]
-              }),
-              { status: 200, headers: { "Content-Type": "application/json" } }
-            ),
-            url: completionUrl,
-            headers,
-            transformedBody: requestPayload
-          };
-        }
-        const openaiResponse2 = {
-          id: `chatcmpl-t3-${Date.now()}`,
-          object: "chat.completion",
-          created: Math.floor(Date.now() / 1e3),
-          model: model || "unknown",
-          choices: [{ index: 0, message: { role: "assistant", content }, finish_reason: "stop" }],
-          usage: { prompt_tokens: 0, completion_tokens: 0, total_tokens: 0 }
-        };
-        return {
-          response: new Response(JSON.stringify(openaiResponse2), {
-            status: 200,
-            headers: { "Content-Type": "application/json" }
-          }),
-          url: completionUrl,
-          headers,
-          transformedBody: requestPayload
-        };
-      }
-      const openaiResponse = {
-        id: `chatcmpl-t3-${Date.now()}`,
-        object: "chat.completion",
-        created: Math.floor(Date.now() / 1e3),
-        model: model || "unknown",
-        choices: [
-          {
-            index: 0,
-            message: { role: "assistant", content: rawContent },
-            finish_reason: "stop"
-          }
-        ],
-        usage: { prompt_tokens: 0, completion_tokens: 0, total_tokens: 0 }
-      };
-      return {
-        response: new Response(JSON.stringify(openaiResponse), {
-          status: 200,
-          headers: { "Content-Type": "application/json" }
-        }),
-        url: completionUrl,
-        headers,
-        transformedBody: requestPayload
-      };
-    } catch (err) {
-      const msg = err instanceof Error ? err.message : String(err);
-      log?.error?.("T3-CHAT-WEB", `Execute failed: ${msg}`);
-      if (err instanceof DOMException && err.name === "AbortError") {
-        return {
-          response: buildErrorResponse(499, "Request cancelled"),
-          url: `${SERVER_FN_PREFIX}...`,
-          headers: {},
-          transformedBody: body
-        };
-      }
-      return {
-        response: buildErrorResponse(502, `t3.chat connection error: ${msg}`),
-        url: `${SERVER_FN_PREFIX}...`,
-        headers,
-        transformedBody: body
-      };
-    }
-  }
-}
-const t3ChatWebExecutor = new T3ChatWebExecutor();
-export {
-  T3ChatWebExecutor,
-  T3_CHAT_BASE,
-  parseT3Credentials,
-  t3ChatWebExecutor,
-  validateT3Credentials
-};

package/open-sse/executors/theoldllm.js

@@ -1,290 +0,0 @@
-import { BaseExecutor } from "./base.ts";
-const API_BASE = "https://theoldllm.vercel.app";
-const API_PATH = "/api/chatgpt";
-const API_URL = `${API_BASE}${API_PATH}`;
-const CHROME_UA = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/149.0.0.0 Safari/537.36";
-const GPT_MODELS = {
-  "gpt-5.4": "GPT_5_4",
-  "gpt-5.3": "GPT_5_3",
-  "gpt-5.2": "GPT_5_2",
-  "gpt-5.1": "GPT_5_1",
-  "gpt-5": "GPT_5",
-  gpt5_4: "GPT_5_4",
-  gpt5_3: "GPT_5_3",
-  gpt5_2: "GPT_5_2",
-  gpt5_1: "GPT_5_1",
-  gpt_4o: "GPT_4O",
-  "gpt-4o": "GPT_4O",
-  gpt_5_3: "GPT_5_3",
-  gpt_5_2: "GPT_5_2",
-  gpt_5_1: "GPT_5_1",
-  gpt_5: "GPT_5"
-};
-const CLAUDE_NAMES = {
-  "claude-4.6-opus": "CLAUDE_4_6_OPUS",
-  "claude-4.6-sonnet": "CLAUDE_4_6_SONNET",
-  "claude-4.5-haiku": "CLAUDE_4_5_HAIKU",
-  claude_opus_4: "CLAUDE_4_6_OPUS",
-  claude_sonnet_4: "CLAUDE_4_6_SONNET",
-  claude_haiku_3_5: "CLAUDE_4_5_HAIKU",
-  "claude opus 4": "CLAUDE_4_6_OPUS",
-  "claude sonnet 4": "CLAUDE_4_6_SONNET",
-  "claude haiku 3.5": "CLAUDE_4_5_HAIKU"
-};
-const CHATGPT_UPSTREAM_MODELS = /* @__PURE__ */ new Set([
-  "GPT_5_4",
-  "GPT_5_3",
-  "GPT_5_2",
-  "GPT_5_1",
-  "GPT_5",
-  "GPT_o4_mini",
-  "GPT_o3_mini",
-  "gemini_3_pro",
-  "gemini_2_5_pro",
-  "gemini_2_0_flash",
-  "gemini_1_5_flash",
-  "CLAUDE_4_6_OPUS",
-  "CLAUDE_4_6_SONNET",
-  "CLAUDE_4_5_HAIKU",
-  "openrouter_gpt_4_o",
-  "openrouter_gpt_4_o_mini",
-  "openrouter_gpt_4",
-  "openrouter_grok_4",
-  "together_deepseek_r1",
-  "openrouter_deepseek_r1",
-  "together_deepseek_v3",
-  "openrouter_deepseek_v3",
-  "sonar-deep-research",
-  "sonar-pro",
-  "openrouter_web_search"
-]);
-function mapModel(model) {
-  const trimmed = model.trim();
-  if (CHATGPT_UPSTREAM_MODELS.has(trimmed)) return trimmed;
-  const n = model.toLowerCase().trim();
-  const gptKey = n.replace(/[_\s]+/g, "-");
-  if (GPT_MODELS[gptKey]) return GPT_MODELS[gptKey];
-  const gptKey2 = n.replace(/[-\s]+/g, "_");
-  if (GPT_MODELS[gptKey2]) return GPT_MODELS[gptKey2];
-  if (CLAUDE_NAMES[n]) return CLAUDE_NAMES[n];
-  if (n.includes("claude")) {
-    if (n.includes("opus")) return "CLAUDE_4_6_OPUS";
-    if (n.includes("sonnet")) return "CLAUDE_4_6_SONNET";
-    if (n.includes("haiku")) return "CLAUDE_4_5_HAIKU";
-  }
-  if (n.includes("gpt") && n.includes("5")) return "GPT_5_4";
-  return "GPT_5_4";
-}
-const TOKEN_SEED = "oldllm-client-2026";
-const UA_PREFIX = CHROME_UA.slice(0, 20);
-function generateRequestToken() {
-  const n = Date.now();
-  const e = `${n}-${TOKEN_SEED}-${UA_PREFIX}`;
-  let t = 0;
-  for (let i = 0; i < e.length; i++) {
-    const s = e.charCodeAt(i);
-    t = (t << 5) - t + s;
-    t = t & t;
-  }
-  const r = crypto.randomUUID().replace(/-/g, "").slice(0, 8);
-  return `${n.toString(36)}-${Math.abs(t).toString(36)}-${r}`;
-}
-const tokenCache = { value: "", expiresAt: 0 };
-async function directFetch(reqBody, signal) {
-  const controller = new AbortController();
-  const timer = setTimeout(() => controller.abort(), 12e4);
-  const onSignal = signal ? () => controller.abort(signal.reason) : void 0;
-  signal?.addEventListener("abort", onSignal, { once: true });
-  try {
-    return await fetch(API_URL, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        "X-Client-Version": "3.8.4",
-        "X-Request-Token": generateRequestToken(),
-        "User-Agent": CHROME_UA
-      },
-      body: JSON.stringify(reqBody),
-      signal: controller.signal
-    });
-  } finally {
-    clearTimeout(timer);
-    if (onSignal) signal?.removeEventListener("abort", onSignal);
-  }
-}
-function isTokenRejected(status, body) {
-  if (status === 401 || status === 403) return true;
-  try {
-    const p = JSON.parse(body);
-    return p?.error?.type === "access_denied" || typeof p?.error === "string" && /blocked|denied|invalid/i.test(p.error);
-  } catch {
-    return false;
-  }
-}
-function parseSseContent(sseText) {
-  let content = "";
-  for (const line of sseText.split("\n")) {
-    if (line.startsWith("data: ") && line !== "data: [DONE]") {
-      try {
-        const d = JSON.parse(line.slice(6));
-        content += d.choices?.[0]?.delta?.content || d.choices?.[0]?.delta?.text || "";
-      } catch {
-      }
-    }
-  }
-  return content;
-}
-function buildChatCompletion(content, model) {
-  return JSON.stringify({
-    id: `chatcmpl-${Date.now()}`,
-    object: "chat.completion",
-    created: Math.floor(Date.now() / 1e3),
-    model: mapModel(model),
-    choices: [{ index: 0, message: { role: "assistant", content }, finish_reason: "stop" }],
-    usage: { prompt_tokens: 0, completion_tokens: 0, total_tokens: 0 }
-  });
-}
-function buildErrorResponse(status, body) {
-  let detail = body;
-  for (const line of body.split("\n")) {
-    if (line.startsWith("data: ") && line !== "data: [DONE]") {
-      try {
-        const p = JSON.parse(line.slice(6));
-        if (p.error) {
-          detail = JSON.stringify(p.error);
-          break;
-        }
-      } catch {
-      }
-    }
-  }
-  return JSON.stringify({
-    error: { message: detail, type: "upstream_error", code: `HTTP_${status}` }
-  });
-}
-class TheOldLlmExecutor extends BaseExecutor {
-  constructor() {
-    super("theoldllm", { format: "openai" });
-  }
-  buildUrl(_model, _stream) {
-    return API_URL;
-  }
-  buildHeaders(_credentials) {
-    return {
-      "Content-Type": "application/json",
-      "X-Client-Version": "3.8.4",
-      "User-Agent": CHROME_UA
-    };
-  }
-  transformRequest(model, body, _stream) {
-    if (typeof body === "object" && body !== null) {
-      return { ...body, model: mapModel(model) };
-    }
-    return body;
-  }
-  async testConnection(_credentials, _signal, log) {
-    try {
-      const resp = await fetch(API_URL, {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-          "X-Client-Version": "3.8.4",
-          "X-Request-Token": generateRequestToken(),
-          "User-Agent": CHROME_UA
-        },
-        body: JSON.stringify({
-          model: "GPT_5_4",
-          messages: [{ role: "user", content: "ping" }],
-          stream: false
-        }),
-        signal: _signal ?? void 0
-      });
-      return resp.status === 200;
-    } catch {
-      log?.warn?.("THEOLDLLM", "testConnection network error");
-      return false;
-    }
-  }
-  async execute(input) {
-    const { model, stream, body, signal, log } = input;
-    const encoder = new TextEncoder();
-    if (signal?.aborted) {
-      return {
-        response: new Response(
-          encoder.encode(
-            JSON.stringify({
-              error: { message: "Request aborted", type: "abort", code: "ABORTED" }
-            })
-          ),
-          { status: 499, headers: { "Content-Type": "application/json" } }
-        ),
-        url: API_URL,
-        headers: this.buildHeaders(input.credentials),
-        transformedBody: body
-      };
-    }
-    try {
-      const reqBody = {
-        ...body,
-        model: mapModel(model),
-        stream: true
-      };
-      let upstream = await directFetch(reqBody, signal);
-      let finalBody = await upstream.text();
-      if (isTokenRejected(upstream.status, finalBody)) {
-        log?.warn?.("THEOLDLLM", `Token rejected (${upstream.status}), retrying with fresh token\u2026`);
-        upstream = await directFetch(reqBody, signal);
-        finalBody = await upstream.text();
-      }
-      if (upstream.status === 200 && finalBody) {
-        const payload = stream ? finalBody : buildChatCompletion(parseSseContent(finalBody), model);
-        return {
-          response: new Response(encoder.encode(payload), {
-            status: 200,
-            headers: {
-              "Content-Type": stream ? "text/event-stream" : "application/json",
-              "Cache-Control": "no-cache"
-            }
-          }),
-          url: API_URL,
-          headers: this.buildHeaders(input.credentials),
-          transformedBody: body
-        };
-      }
-      return {
-        response: new Response(encoder.encode(buildErrorResponse(upstream.status, finalBody)), {
-          status: upstream.status,
-          headers: { "Content-Type": "application/json" }
-        }),
-        url: API_URL,
-        headers: this.buildHeaders(input.credentials),
-        transformedBody: body
-      };
-    } catch (err) {
-      const msg = err instanceof Error ? err.message : String(err);
-      log?.error?.("THEOLDLLM", `Executor error: ${msg}`);
-      return {
-        response: new Response(
-          encoder.encode(
-            JSON.stringify({
-              error: { message: msg, type: "upstream_error", code: "EXECUTOR_ERROR" }
-            })
-          ),
-          { status: 502, headers: { "Content-Type": "application/json" } }
-        ),
-        url: API_URL,
-        headers: this.buildHeaders(input.credentials),
-        transformedBody: body
-      };
-    }
-  }
-}
-var theoldllm_default = TheOldLlmExecutor;
-export {
-  CHATGPT_UPSTREAM_MODELS,
-  TheOldLlmExecutor,
-  theoldllm_default as default,
-  generateRequestToken,
-  mapModel,
-  tokenCache
-};