@fudrouter/fsrouter 0.6.63 → 0.6.64

package/open-sse/executors/trae.js

@@ -1,418 +0,0 @@
-import { BaseExecutor, mergeUpstreamExtraHeaders } from "./base.ts";
-import { PROVIDERS } from "../config/constants.ts";
-import { sanitizeErrorMessage } from "../utils/error.js";
-const STREAM_TIMEOUT_MS = parseInt(process.env.TRAE_STREAM_TIMEOUT_MS || "300000", 10);
-function flattenQuery(messages) {
-  const parts = [];
-  for (const m of messages) {
-    let content = "";
-    if (typeof m.content === "string") content = m.content;
-    else if (Array.isArray(m.content)) {
-      content = m.content.map((p) => {
-        if (typeof p === "string") return p;
-        if (p && typeof p === "object") return String(p.text ?? "");
-        return "";
-      }).join("");
-    }
-    if (m.role === "system") parts.push(`[System]
-${content}`);
-    else if (m.role === "assistant") parts.push(`[Assistant]
-${content}`);
-    else parts.push(content);
-  }
-  const text = parts.join("\n\n");
-  return JSON.stringify([{ type: "text", data: { content: text } }]);
-}
-class TraeExecutor extends BaseExecutor {
-  constructor() {
-    super("trae", PROVIDERS["trae"]);
-  }
-  base() {
-    return (this.config.baseUrl || "https://core-normal.trae.ai/api/remote/v1").replace(/\/$/, "");
-  }
-  buildHeaders(credentials) {
-    const token = credentials.accessToken || "";
-    const psd = credentials.providerSpecificData || {};
-    return {
-      Authorization: `Cloud-IDE-JWT ${token}`,
-      "Content-Type": "application/json",
-      "X-Trae-Client-Type": "web",
-      "X-Preferenced-Language": psd.appLanguage || "en",
-      "x-user-region": psd.userRegion || "US",
-      Referer: "https://solo.trae.ai/",
-      "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/149.0.0.0 Safari/537.36"
-    };
-  }
-  /**
-   * SOLO exposes two session modes (the toggle on solo.trae.ai):
-   *   - "code" (default): full model picker — `auto` plus named models
-   *     (gpt-5.4, kimi-k2.5, gemini-3.1-pro, …).
-   *   - "work": a single, faster "auto" agent with no model picker.
-   * We surface "work" as its own model id (`trae/work`) so callers can opt into
-   * the fast lane; any other model id runs in "code" mode. "work" forces the
-   * auto strategy with an empty model_name, since it has no model selection.
-   */
-  resolveMode(model) {
-    const m = (model || "").trim().toLowerCase();
-    if (m === "work" || m === "auto-work" || m === "solo-work") {
-      return { mode: "work", strategy: "auto", modelName: "" };
-    }
-    const auto = !m || m === "auto";
-    return { mode: "code", strategy: auto ? "auto" : "manual", modelName: auto ? "" : model };
-  }
-  commonParams(psd, mode, sessionId) {
-    const cp = {
-      language: "en-us",
-      app_language: psd.appLanguage || "en",
-      quality: "stable",
-      app_version: psd.appVersion || "1.0.0.1229",
-      web_id: psd.webId || "",
-      user_identity: psd.userIdentity || "Free",
-      is_freshman: "0",
-      biz_user_id: psd.bizUserId || "",
-      user_unique_id: psd.userUniqueId || "",
-      scope: psd.scope || "marscode-us",
-      tenant: psd.tenant || "marscode",
-      region: psd.region || "US-East",
-      aiRegion: psd.aiRegion || psd.region || "US-East",
-      is_privacy_mode: 0,
-      privacy_mode: "off",
-      solo_chat_mode: mode
-    };
-    if (sessionId) cp.biz_session_id = sessionId;
-    return JSON.stringify(cp);
-  }
-  /** POST /chat_sessions — creates a session and submits the first turn. */
-  async createSession(headers, query, model, psd, signal) {
-    const { mode, strategy, modelName } = this.resolveMode(model);
-    const body = {
-      mode,
-      environment_id: "default",
-      initial_message: {
-        chat_session_id: "",
-        content: [],
-        query,
-        model_name: modelName,
-        agent_type: "solo_agent_remote",
-        model_selection_strategy: strategy,
-        common_params: this.commonParams(psd, mode)
-      },
-      env: "remote",
-      auto_create_project: false,
-      origin: "web"
-    };
-    const res = await fetch(`${this.base()}/chat_sessions`, {
-      method: "POST",
-      headers,
-      body: JSON.stringify(body),
-      signal: signal || void 0
-    });
-    const text = await res.text();
-    if (!res.ok) throw new Error(`[${res.status}] ${text}`);
-    const json = JSON.parse(text);
-    if (json?.code !== 0) throw new Error(`Trae create_session: ${JSON.stringify(json)}`);
-    return { sessionId: json.data.chat_session_id, messageId: json.data.message_id };
-  }
-  /**
-   * GET /events SSE → invoke onEvent(eventType, dataObj) per frame.
-   * Resolves when `done`/`error` arrives, the stream ends, or timeout fires.
-   */
-  async streamEvents(headers, sessionId, replyTo, onEvent, signal) {
-    const url = `${this.base()}/chat_sessions/${sessionId}/events?reply_to_message_id=${encodeURIComponent(replyTo)}`;
-    const ctrl = new AbortController();
-    if (signal?.aborted) ctrl.abort();
-    const timer = setTimeout(() => ctrl.abort(new Error("trae stream timeout")), STREAM_TIMEOUT_MS);
-    const onAbort = () => ctrl.abort();
-    if (signal) signal.addEventListener("abort", onAbort, { once: true });
-    try {
-      const res = await fetch(url, { method: "GET", headers, signal: ctrl.signal });
-      if (!res.ok || !res.body) throw new Error(`[${res.status}] events stream failed`);
-      const reader = res.body.getReader();
-      const decoder = new TextDecoder();
-      let buf = "";
-      let ev = null;
-      for (; ; ) {
-        const { done, value } = await reader.read();
-        if (done) break;
-        buf += decoder.decode(value, { stream: true });
-        let nl;
-        while ((nl = buf.indexOf("\n")) >= 0) {
-          const line = buf.slice(0, nl).replace(/\r$/, "");
-          buf = buf.slice(nl + 1);
-          if (line.startsWith("event:")) ev = line.slice(6).trim();
-          else if (line.startsWith("data:")) {
-            const payload = line.slice(5).trim();
-            let data;
-            try {
-              data = JSON.parse(payload);
-            } catch {
-              data = { _raw: payload };
-            }
-            if (onEvent(ev, data)) {
-              await reader.cancel().catch(() => {
-              });
-              return;
-            }
-          } else if (line === "") ev = null;
-        }
-      }
-    } finally {
-      clearTimeout(timer);
-      if (signal) signal.removeEventListener("abort", onAbort);
-    }
-  }
-  async execute({ model, body, stream, credentials, signal, upstreamExtraHeaders }) {
-    const headers = this.buildHeaders(credentials);
-    mergeUpstreamExtraHeaders(headers, upstreamExtraHeaders);
-    const psd = credentials.providerSpecificData || {};
-    const reqBody = body;
-    const query = flattenQuery(reqBody.messages || []);
-    const responseId = `chatcmpl-trae-${Date.now()}`;
-    const created = Math.floor(Date.now() / 1e3);
-    const errResponse = (status, message) => new Response(
-      JSON.stringify({
-        error: { message: sanitizeErrorMessage(message), type: "api_error", code: "" }
-      }),
-      { status, headers: { "Content-Type": "application/json" } }
-    );
-    let session;
-    try {
-      session = await this.createSession(
-        headers,
-        query,
-        model,
-        psd,
-        signal
-      );
-    } catch (err) {
-      return {
-        response: errResponse(502, err instanceof Error ? err.message : String(err)),
-        url: this.base(),
-        headers,
-        transformedBody: body
-      };
-    }
-    const order = [];
-    const thoughts = {};
-    let sent = 0;
-    let usage = null;
-    let errorEvent = null;
-    const renderNewText = (data) => {
-      const pid = data.id;
-      if (!pid) return "";
-      if (!(pid in thoughts)) order.push(pid);
-      const t = data.thought || "";
-      if (t.length >= (thoughts[pid] || "").length) thoughts[pid] = t;
-      const full = order.map((i) => thoughts[i]).join("");
-      const piece = full.slice(sent);
-      sent = full.length;
-      return piece;
-    };
-    if (stream !== false) {
-      const enc = new TextEncoder();
-      const sse = new ReadableStream({
-        start: async (controller) => {
-          const emit = (obj) => controller.enqueue(enc.encode(`data: ${JSON.stringify(obj)}
-
-`));
-          let roleEmitted = false;
-          try {
-            emit({
-              id: responseId,
-              object: "chat.completion.chunk",
-              created,
-              model,
-              choices: [{ index: 0, delta: { role: "assistant" }, finish_reason: null }]
-            });
-            roleEmitted = true;
-            await this.streamEvents(
-              headers,
-              session.sessionId,
-              session.messageId,
-              (ev, data) => {
-                if (ev === "error") {
-                  errorEvent = data;
-                  return true;
-                }
-                if (ev === "token_usage") usage = data;
-                if (ev === "plan_item") {
-                  const piece = renderNewText(data);
-                  if (piece)
-                    emit({
-                      id: responseId,
-                      object: "chat.completion.chunk",
-                      created,
-                      model,
-                      choices: [{ index: 0, delta: { content: piece }, finish_reason: null }]
-                    });
-                }
-                return ev === "done";
-              },
-              signal
-            );
-            void roleEmitted;
-            if (errorEvent) {
-              emit({
-                id: responseId,
-                object: "chat.completion.chunk",
-                created,
-                model,
-                choices: [],
-                error: {
-                  message: `trae ${errorEvent.code}: ${errorEvent.message}`,
-                  type: "api_error"
-                }
-              });
-            } else {
-              emit({
-                id: responseId,
-                object: "chat.completion.chunk",
-                created,
-                model,
-                choices: [{ index: 0, delta: {}, finish_reason: "stop" }]
-              });
-              if (usage)
-                emit({
-                  id: responseId,
-                  object: "chat.completion.chunk",
-                  created,
-                  model,
-                  choices: [],
-                  usage: {
-                    prompt_tokens: usage.prompt_tokens || 0,
-                    completion_tokens: usage.completion_tokens || 0,
-                    total_tokens: usage.total_tokens || 0
-                  }
-                });
-            }
-            controller.enqueue(enc.encode("data: [DONE]\n\n"));
-            controller.close();
-          } catch (err) {
-            controller.error(err);
-          }
-        }
-      });
-      return {
-        response: new Response(sse, {
-          status: 200,
-          headers: {
-            "Content-Type": "text/event-stream",
-            "Cache-Control": "no-cache",
-            Connection: "keep-alive"
-          }
-        }),
-        url: this.base(),
-        headers,
-        transformedBody: body
-      };
-    }
-    try {
-      await this.streamEvents(
-        headers,
-        session.sessionId,
-        session.messageId,
-        (ev, data) => {
-          if (ev === "error") {
-            errorEvent = data;
-            return true;
-          }
-          if (ev === "token_usage") usage = data;
-          if (ev === "plan_item") renderNewText(data);
-          return ev === "done";
-        },
-        signal
-      );
-    } catch (err) {
-      return {
-        response: errResponse(502, err instanceof Error ? err.message : String(err)),
-        url: this.base(),
-        headers,
-        transformedBody: body
-      };
-    }
-    if (errorEvent) {
-      return {
-        response: errResponse(502, `trae ${errorEvent.code}: ${errorEvent.message}`),
-        url: this.base(),
-        headers,
-        transformedBody: body
-      };
-    }
-    const content = order.map((i) => thoughts[i]).join("");
-    const out = {
-      id: responseId,
-      object: "chat.completion",
-      created,
-      model,
-      choices: [{ index: 0, message: { role: "assistant", content }, finish_reason: "stop" }]
-    };
-    if (usage)
-      out.usage = {
-        prompt_tokens: usage.prompt_tokens || 0,
-        completion_tokens: usage.completion_tokens || 0,
-        total_tokens: usage.total_tokens || 0
-      };
-    return {
-      response: new Response(JSON.stringify(out), {
-        status: 200,
-        headers: { "Content-Type": "application/json" }
-      }),
-      url: this.base(),
-      headers,
-      transformedBody: body
-    };
-  }
-  /**
-   * Headless refresh of the 14-day Cloud-IDE-JWT using the long-lived (~7 month)
-   * RefreshToken captured during /authorize. Mirrors the desktop client's call to
-   *   POST {apiHost}/cloudide/api/v3/trae/oauth/ExchangeToken
-   *   { ClientID, RefreshToken, ClientSecret: "-", UserID: "" }
-   * The response uses the same envelope as GetUserToken:
-   *   { ResponseMetadata: { Error?: { Code, Message } }, Result: { Token, RefreshToken,
-   *     TokenExpireAt, RefreshExpireAt, TokenExpireDuration, UserID, TenantID } }
-   * On Error.Code === "RefreshTokenInvalid" the caller must re-authorize via
-   * the browser flow — we throw so the connection is marked unusable.
-   */
-  async refreshCredentials(credentials) {
-    const psd = credentials?.providerSpecificData || {};
-    const refreshToken = credentials?.refreshToken;
-    if (!refreshToken) return null;
-    const host = (psd.host || "https://api-us-east.trae.ai").replace(/\/$/, "");
-    const clientId = psd.clientId || "en1oxy7wnw8j9n";
-    const url = `${host}/cloudide/api/v3/trae/oauth/ExchangeToken`;
-    const body = { ClientID: clientId, RefreshToken: refreshToken, ClientSecret: "-", UserID: "" };
-    const res = await fetch(url, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify(body)
-    });
-    const text = await res.text();
-    if (!res.ok) {
-      throw new Error(`Trae ExchangeToken HTTP ${res.status}: ${text.slice(0, 200)}`);
-    }
-    let parsed;
-    try {
-      parsed = JSON.parse(text);
-    } catch {
-      throw new Error("Trae ExchangeToken: response was not JSON");
-    }
-    const errCode = parsed?.ResponseMetadata?.Error?.Code;
-    if (errCode) {
-      throw new Error(`Trae ExchangeToken error: ${errCode}`);
-    }
-    const result = parsed?.Result;
-    if (!result?.Token) {
-      throw new Error("Trae ExchangeToken: response missing Result.Token");
-    }
-    return {
-      accessToken: result.Token,
-      refreshToken: result.RefreshToken || refreshToken,
-      expiresAt: result.TokenExpireAt ? new Date(Number(result.TokenExpireAt)).toISOString() : void 0
-    };
-  }
-}
-var trae_default = TraeExecutor;
-export {
-  TraeExecutor,
-  trae_default as default
-};

package/open-sse/executors/v0-vercel-web.js

@@ -1,141 +0,0 @@
-import { BaseExecutor } from "./base.ts";
-import { makeExecutorErrorResult as makeErrorResult, normalizeCookie } from "../utils/error.js";
-const BASE_URL = "https://v0.dev";
-const CHAT_URL = `${BASE_URL}/api/chat`;
-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";
-class V0VercelWebExecutor extends BaseExecutor {
-  constructor() {
-    super("v0-vercel-web", { id: "v0-vercel-web", baseUrl: "https://v0.dev" });
-  }
-  async execute(input) {
-    const { body, credentials, signal, stream: wantStream } = input;
-    const bodyObj = body || {};
-    const rawCookie = normalizeCookie(String(credentials?.apiKey ?? "").trim());
-    const messages = bodyObj.messages || [];
-    const modelId = bodyObj.model || "v0-default";
-    const reqBody = {
-      messages: messages.map((m) => ({ role: m.role, content: m.content })),
-      model: modelId,
-      stream: wantStream
-    };
-    const reqHeaders = {
-      "Content-Type": "application/json",
-      "User-Agent": USER_AGENT,
-      Accept: wantStream ? "text/event-stream" : "application/json",
-      Referer: `${BASE_URL}/`,
-      Origin: BASE_URL
-    };
-    if (rawCookie) reqHeaders.Cookie = rawCookie;
-    let upstream;
-    try {
-      upstream = await fetch(CHAT_URL, {
-        method: "POST",
-        headers: reqHeaders,
-        body: JSON.stringify(reqBody),
-        signal
-      });
-    } catch (err) {
-      return makeErrorResult(
-        502,
-        `v0 fetch failed: ${err instanceof Error ? err.message : "unknown"}`,
-        body,
-        CHAT_URL
-      );
-    }
-    if (!upstream.ok) {
-      const errText = await upstream.text().catch(() => "");
-      return makeErrorResult(upstream.status, `v0 error: ${errText}`, body, CHAT_URL);
-    }
-    if (!wantStream) {
-      const data = await upstream.json();
-      const content = data?.choices?.[0]?.message?.content || data?.content || "";
-      return {
-        response: new Response(
-          JSON.stringify({
-            id: `chatcmpl-v0-${Date.now()}`,
-            object: "chat.completion",
-            created: Math.floor(Date.now() / 1e3),
-            model: modelId,
-            choices: [
-              {
-                index: 0,
-                message: { role: "assistant", content },
-                finish_reason: "stop"
-              }
-            ]
-          }),
-          { headers: { "Content-Type": "application/json" } }
-        ),
-        url: CHAT_URL,
-        headers: reqHeaders,
-        transformedBody: reqBody
-      };
-    }
-    const encoder = new TextEncoder();
-    const decoder = new TextDecoder();
-    const stream = new ReadableStream({
-      async start(controller) {
-        const reader = upstream.body?.getReader();
-        if (!reader) {
-          controller.close();
-          return;
-        }
-        let buffer = "";
-        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) {
-              if (!line.startsWith("data:")) continue;
-              const data = line.slice(5).trim();
-              if (data === "[DONE]") {
-                controller.enqueue(encoder.encode("data: [DONE]\n\n"));
-                continue;
-              }
-              try {
-                const parsed = JSON.parse(data);
-                const text = parsed.choices?.[0]?.delta?.content || "";
-                if (text) {
-                  const chunk = {
-                    id: `chatcmpl-v0-${Date.now()}`,
-                    object: "chat.completion.chunk",
-                    created: Math.floor(Date.now() / 1e3),
-                    model: modelId,
-                    choices: [{ index: 0, delta: { content: text }, finish_reason: null }]
-                  };
-                  controller.enqueue(encoder.encode(`data: ${JSON.stringify(chunk)}
-
-`));
-                }
-              } catch {
-              }
-            }
-          }
-        } catch (err) {
-          if (!signal?.aborted) controller.error(err);
-        } finally {
-          controller.enqueue(encoder.encode("data: [DONE]\n\n"));
-          controller.close();
-        }
-      }
-    });
-    return {
-      response: new Response(stream, {
-        headers: {
-          "Content-Type": "text/event-stream",
-          "Cache-Control": "no-cache",
-          Connection: "keep-alive"
-        }
-      }),
-      url: CHAT_URL,
-      headers: reqHeaders,
-      transformedBody: reqBody
-    };
-  }
-}
-export {
-  V0VercelWebExecutor
-};

package/open-sse/executors/venice-web.js

@@ -1,142 +0,0 @@
-import { BaseExecutor } from "./base.ts";
-import { makeExecutorErrorResult as makeErrorResult, normalizeCookie } from "../utils/error.js";
-const BASE_URL = "https://venice.ai";
-const CHAT_URL = `${BASE_URL}/api/chat`;
-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";
-class VeniceWebExecutor extends BaseExecutor {
-  constructor() {
-    super("venice-web", { id: "venice-web", baseUrl: "https://venice.ai" });
-  }
-  async execute(input) {
-    const { body, credentials, signal, stream: wantStream } = input;
-    const bodyObj = body || {};
-    const rawCookie = normalizeCookie(String(credentials?.apiKey ?? "").trim());
-    const messages = bodyObj.messages || [];
-    const modelId = bodyObj.model || "venice-default";
-    const reqBody = {
-      messages: messages.map((m) => ({ role: m.role, content: m.content })),
-      model: modelId,
-      stream: wantStream,
-      max_tokens: bodyObj.max_tokens || 4096
-    };
-    const reqHeaders = {
-      "Content-Type": "application/json",
-      "User-Agent": USER_AGENT,
-      Accept: wantStream ? "text/event-stream" : "application/json",
-      Referer: `${BASE_URL}/`,
-      Origin: BASE_URL
-    };
-    if (rawCookie) reqHeaders.Cookie = rawCookie;
-    let upstream;
-    try {
-      upstream = await fetch(CHAT_URL, {
-        method: "POST",
-        headers: reqHeaders,
-        body: JSON.stringify(reqBody),
-        signal
-      });
-    } catch (err) {
-      return makeErrorResult(
-        502,
-        `Venice fetch failed: ${err instanceof Error ? err.message : "unknown"}`,
-        body,
-        CHAT_URL
-      );
-    }
-    if (!upstream.ok) {
-      const errText = await upstream.text().catch(() => "");
-      return makeErrorResult(upstream.status, `Venice error: ${errText}`, body, CHAT_URL);
-    }
-    if (!wantStream) {
-      const data = await upstream.json();
-      const content = data?.choices?.[0]?.message?.content || data?.content || "";
-      return {
-        response: new Response(
-          JSON.stringify({
-            id: `chatcmpl-ven-${Date.now()}`,
-            object: "chat.completion",
-            created: Math.floor(Date.now() / 1e3),
-            model: modelId,
-            choices: [
-              {
-                index: 0,
-                message: { role: "assistant", content },
-                finish_reason: "stop"
-              }
-            ]
-          }),
-          { headers: { "Content-Type": "application/json" } }
-        ),
-        url: CHAT_URL,
-        headers: reqHeaders,
-        transformedBody: reqBody
-      };
-    }
-    const encoder = new TextEncoder();
-    const decoder = new TextDecoder();
-    const stream = new ReadableStream({
-      async start(controller) {
-        const reader = upstream.body?.getReader();
-        if (!reader) {
-          controller.close();
-          return;
-        }
-        let buffer = "";
-        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) {
-              if (!line.startsWith("data:")) continue;
-              const data = line.slice(5).trim();
-              if (data === "[DONE]") {
-                controller.enqueue(encoder.encode("data: [DONE]\n\n"));
-                continue;
-              }
-              try {
-                const parsed = JSON.parse(data);
-                const text = parsed.choices?.[0]?.delta?.content || "";
-                if (text) {
-                  const chunk = {
-                    id: `chatcmpl-ven-${Date.now()}`,
-                    object: "chat.completion.chunk",
-                    created: Math.floor(Date.now() / 1e3),
-                    model: modelId,
-                    choices: [{ index: 0, delta: { content: text }, finish_reason: null }]
-                  };
-                  controller.enqueue(encoder.encode(`data: ${JSON.stringify(chunk)}
-
-`));
-                }
-              } catch {
-              }
-            }
-          }
-        } catch (err) {
-          if (!signal?.aborted) controller.error(err);
-        } finally {
-          controller.enqueue(encoder.encode("data: [DONE]\n\n"));
-          controller.close();
-        }
-      }
-    });
-    return {
-      response: new Response(stream, {
-        headers: {
-          "Content-Type": "text/event-stream",
-          "Cache-Control": "no-cache",
-          Connection: "keep-alive"
-        }
-      }),
-      url: CHAT_URL,
-      headers: reqHeaders,
-      transformedBody: reqBody
-    };
-  }
-}
-export {
-  VeniceWebExecutor
-};