@fudrouter/fsrouter 0.6.64 → 0.6.66

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

@@ -0,0 +1,417 @@
+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

@@ -0,0 +1,290 @@
+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
+};