@fudrouter/fsrouter 0.6.72 → 0.6.74

package/dist/open-sse/executors/perplexity-web.js

@@ -1,6 +1,7 @@
 import { BaseExecutor } from "./base.js";
 import { PROVIDERS } from "../config/providers.js";
-import { proxyAwareFetch } from "../utils/proxyFetch.js";
+import { SSE_DONE, SSE_HEADERS_NO_BUFFER } from "../utils/sseConstants.js";
+import { sseChunk } from "../utils/sse.js";
 
 const PPLX_SSE_ENDPOINT = PROVIDERS["perplexity-web"].baseUrl;
 const PPLX_API_VERSION = "2.18";
@@ -145,24 +146,6 @@ function parseOpenAIMessages(messages) {
     else if (Array.isArray(msg.content)) {
       content = msg.content.filter((c) => c.type === "text").map((c) => String(c.text || "")).join(" ");
     }
-
-    // Handle tool role messages — convert to user message with tool result context
-    if (role === "tool") {
-      const toolName = msg.name || "unknown_tool";
-      const toolCallId = msg.tool_call_id || "";
-      content = `[Tool Result for ${toolName}${toolCallId ? ` (call_id: ${toolCallId})` : ""}]:\n${content || "(empty result)"}`;
-      role = "user";
-    }
-
-    // Handle assistant messages with tool_calls — serialize them as text
-    if (role === "assistant" && msg.tool_calls && !content) {
-      const tcText = msg.tool_calls.map(tc => {
-        const fn = tc.function || {};
-        return `<tool_call>{"name":"${fn.name}","arguments":${fn.arguments || "{}"}}</tool_call>`;
-      }).join("\n");
-      content = tcText;
-    }
-
     if (!content.trim()) continue;
     if (role === "system") systemMsg += content + "\n";
     else if (role === "user" || role === "assistant") history.push({ role, content });
@@ -200,37 +183,13 @@ function buildPplxRequestBody(query, mode, modelPref, followUpUuid) {
 
 function formatToolsHint(tools) {
   if (!Array.isArray(tools) || tools.length === 0) return "";
-  const defs = tools.map((t) => {
+  const lines = tools.map((t) => {
     const fn = t?.function || t || {};
     const name = fn.name || "unnamed";
-    const desc = fn.description || "";
-    const params = fn.parameters ? JSON.stringify(fn.parameters) : "{}";
-    return `{"name":"${name}","description":${JSON.stringify(desc)},"parameters":${params}}`;
+    const desc = (fn.description || "").split("\n")[0].slice(0, 200);
+    return `- ${name}: ${desc}`;
   });
-  return `You have access to these tools:\n[${defs.join(",")}]\n\nTo call a tool, output EXACTLY this format with no other text:\n<tool_call>{"name":"<tool_name>","arguments":{<args>}}</tool_call>\n\nYou may call multiple tools by outputting multiple <tool_call> blocks. If no tool is needed, respond normally.`;
-}
-
-// Parse tool calls from Perplexity text response
-const TOOL_CALL_RE = /<tool_call>\s*([\s\S]*?)\s*<\/tool_call>/g;
-function parseToolCalls(text) {
-  const calls = [];
-  let match;
-  while ((match = TOOL_CALL_RE.exec(text)) !== null) {
-    try {
-      const obj = JSON.parse(match[1]);
-      if (obj.name) {
-        calls.push({
-          id: `call_${Math.random().toString(36).slice(2, 14)}`,
-          type: "function",
-          function: { name: obj.name, arguments: JSON.stringify(obj.arguments || {}) },
-        });
-      }
-    } catch { /* skip malformed */ }
-  }
-  return calls;
-}
-function stripToolCallTags(text) {
-  return text.replace(/<tool_call>[\s\S]*?<\/tool_call>/g, "").replace(/\n{3,}/g, "\n\n").trim();
+  return `Available tools (reference only, cannot invoke):\n${lines.join("\n")}`;
 }
 
 function buildQuery(parsed, followUpUuid, tools) {
@@ -332,10 +291,6 @@ async function* extractContent(eventStream, signal) {
   yield { delta: "", answer: fullAnswer, backendUuid: backendUuid ?? undefined, done: true };
 }
 
-function sseChunk(data) {
-  return `data: ${JSON.stringify(data)}\n\n`;
-}
-
 function buildStreamingResponse(eventStream, model, cid, created, history, currentMsg, signal) {
   const encoder = new TextEncoder();
   return new ReadableStream({
@@ -379,37 +334,19 @@ function buildStreamingResponse(eventStream, model, cid, created, history, curre
           if (chunk.answer) fullAnswer = chunk.answer;
         }
 
-        // Parse tool calls from final answer
-        const toolCalls = parseToolCalls(fullAnswer);
-        const cleanAnswer = stripToolCallTags(fullAnswer);
-
-        if (toolCalls.length > 0) {
-          // Emit tool calls as delta chunks
-          for (const tc of toolCalls) {
-            controller.enqueue(encoder.encode(sseChunk({
-              id: cid, object: "chat.completion.chunk", created, model, system_fingerprint: null,
-              choices: [{ index: 0, delta: { tool_calls: [tc] }, finish_reason: null, logprobs: null }],
-            })));
-          }
-          controller.enqueue(encoder.encode(sseChunk({
-            id: cid, object: "chat.completion.chunk", created, model, system_fingerprint: null,
-            choices: [{ index: 0, delta: {}, finish_reason: "tool_calls", logprobs: null }],
-          })));
-        } else {
-          controller.enqueue(encoder.encode(sseChunk({
-            id: cid, object: "chat.completion.chunk", created, model, system_fingerprint: null,
-            choices: [{ index: 0, delta: {}, finish_reason: "stop", logprobs: null }],
-          })));
-        }
-        controller.enqueue(encoder.encode("data: [DONE]\n\n"));
+        controller.enqueue(encoder.encode(sseChunk({
+          id: cid, object: "chat.completion.chunk", created, model, system_fingerprint: null,
+          choices: [{ index: 0, delta: {}, finish_reason: "stop", logprobs: null }],
+        })));
+        controller.enqueue(encoder.encode(SSE_DONE));
 
-        sessionStore(history, currentMsg, cleanResponse(cleanAnswer), respBackendUuid);
+        sessionStore(history, currentMsg, cleanResponse(fullAnswer), respBackendUuid);
       } catch (err) {
         controller.enqueue(encoder.encode(sseChunk({
           id: cid, object: "chat.completion.chunk", created, model, system_fingerprint: null,
           choices: [{ index: 0, delta: { content: `[Stream error: ${err.message || String(err)}]` }, finish_reason: "stop", logprobs: null }],
         })));
-        controller.enqueue(encoder.encode("data: [DONE]\n\n"));
+        controller.enqueue(encoder.encode(SSE_DONE));
       } finally {
         controller.close();
       }
@@ -435,27 +372,14 @@ async function buildNonStreamingResponse(eventStream, model, cid, created, histo
   }
 
   fullAnswer = cleanResponse(fullAnswer);
-  sessionStore(history, currentMsg, stripToolCallTags(fullAnswer), respBackendUuid);
+  sessionStore(history, currentMsg, fullAnswer, respBackendUuid);
 
   const reasoningContent = thinkingParts.length > 0 ? thinkingParts.join("\n") : undefined;
-  const toolCalls = parseToolCalls(fullAnswer);
-  const cleanAnswer = stripToolCallTags(fullAnswer);
+  const msg = { role: "assistant", content: fullAnswer };
+  if (reasoningContent) msg.reasoning_content = reasoningContent;
 
   const promptTokens = Math.ceil(currentMsg.length / 4);
-  const completionTokens = Math.ceil(cleanAnswer.length / 4);
-
-  if (toolCalls.length > 0) {
-    const msg = { role: "assistant", content: cleanAnswer || null, tool_calls: toolCalls };
-    if (reasoningContent) msg.reasoning_content = reasoningContent;
-    return new Response(JSON.stringify({
-      id: cid, object: "chat.completion", created, model, system_fingerprint: null,
-      choices: [{ index: 0, message: msg, finish_reason: "tool_calls", logprobs: null }],
-      usage: { prompt_tokens: promptTokens, completion_tokens: completionTokens, total_tokens: promptTokens + completionTokens },
-    }), { status: 200, headers: { "Content-Type": "application/json" } });
-  }
-
-  const msg = { role: "assistant", content: cleanAnswer };
-  if (reasoningContent) msg.reasoning_content = reasoningContent;
+  const completionTokens = Math.ceil(fullAnswer.length / 4);
 
   return new Response(JSON.stringify({
     id: cid, object: "chat.completion", created, model, system_fingerprint: null,
@@ -469,7 +393,7 @@ export class PerplexityWebExecutor extends BaseExecutor {
     super("perplexity-web", PROVIDERS["perplexity-web"]);
   }
 
-  async execute({ model, body, stream, credentials, signal, log, proxyOptions = null }) {
+  async execute({ model, body, stream, credentials, signal, log }) {
     const messages = body?.messages;
     if (!messages || !Array.isArray(messages) || messages.length === 0) {
       const errResp = new Response(JSON.stringify({
@@ -531,7 +455,7 @@ export class PerplexityWebExecutor extends BaseExecutor {
 
     let response;
     try {
-      response = await proxyAwareFetch(PPLX_SSE_ENDPOINT, fetchOptions, proxyOptions);
+      response = await fetch(PPLX_SSE_ENDPOINT, fetchOptions);
     } catch (err) {
       log?.error?.("PPLX-WEB", `Fetch failed: ${err.message || String(err)}`);
       const errResp = new Response(JSON.stringify({
@@ -567,7 +491,7 @@ export class PerplexityWebExecutor extends BaseExecutor {
       const sseStream = buildStreamingResponse(response.body, model, cid, created, parsed.history, parsed.currentMsg, signal);
       finalResponse = new Response(sseStream, {
         status: 200,
-        headers: { "Content-Type": "text/event-stream", "Cache-Control": "no-cache", "X-Accel-Buffering": "no" },
+        headers: { ...SSE_HEADERS_NO_BUFFER },
       });
     } else {
       finalResponse = await buildNonStreamingResponse(response.body, model, cid, created, parsed.history, parsed.currentMsg, signal);

package/dist/open-sse/executors/qoder.js

@@ -20,18 +20,20 @@
  *     different model upstream, so a missing entry is a hard error.
  */
 
-import { qoderEncodeBody } from '../../../dist/lib/qoder/encoding.js';
-import { buildCosyHeaders } from '../../../dist/lib/qoder/cosy.js';
+import { qoderEncodeBody } from "../shared/qoder/encoding.js";
+import { buildCosyHeaders } from "../shared/qoder/cosy.js";
 import { v4 as uuidv4 } from "uuid";
 import { createHash } from "crypto";
 
 import { BaseExecutor } from "./base.js";
 import { PROVIDERS } from "../config/providers.js";
 import { proxyAwareFetch } from "../utils/proxyFetch.js";
+import { SSE_DONE } from "../utils/sseConstants.js";
+import { FETCH_CONNECT_TIMEOUT_MS } from "../config/runtimeConfig.js";
 import {
   QODER_CHAT_URL_ENCODED,
   QODER_MODEL_MAP,
-} from '../../../dist/lib/qoder/constants.js';
+} from "../shared/qoder/constants.js";
 import { getQoderModelConfig, resolveQoderModels } from "../services/qoderModels.js";
 
 /**
@@ -124,7 +126,7 @@ function truncate(s, n) {
  * Map the OpenAI-style request body into the exact shape Qoder expects.
  */
 async function buildQoderRequestBody({ model, body, credentials, log, proxyOptions, signal }) {
-  const qoderKey = String(model || "").replace(/^(qoder|qd)\//, "");
+  const qoderKey = String(model || "").replace(/^qoder\//, "");
   
   // Fetch model config from dynamic API instead of relying on static QODER_MODEL_MAP.
   // This allows support for new Qoder models (e.g., qmodel_latest) without code changes.
@@ -240,9 +242,8 @@ function wrapQoderSSE(response, model) {
 
     const data = trimmed.slice(5).trimStart();
     if (data === "[DONE]") {
-      controller.enqueue(encoder.encode("data: [DONE]\n\n"));
+      controller.enqueue(encoder.encode(SSE_DONE));
       doneEmitted = true;
-      try { controller.terminate(); } catch {}
       return;
     }
 
@@ -260,16 +261,14 @@ function wrapQoderSSE(response, model) {
         choices: [{ index: 0, delta: { content: `\n[qoder error ${statusVal}: ${truncate(msg, 200)}]` }, finish_reason: "stop" }],
       });
       controller.enqueue(encoder.encode(`data: ${errChunk}\n\n`));
-      controller.enqueue(encoder.encode("data: [DONE]\n\n"));
+      controller.enqueue(encoder.encode(SSE_DONE));
       doneEmitted = true;
-      try { controller.terminate(); } catch {}
       return;
     }
     if (!inner) return;
     if (inner === "[DONE]") {
-      controller.enqueue(encoder.encode("data: [DONE]\n\n"));
+      controller.enqueue(encoder.encode(SSE_DONE));
       doneEmitted = true;
-      try { controller.terminate(); } catch {}
       return;
     }
     // Inner is an OpenAI-shaped chunk. Strip any embedded newlines so the
@@ -303,7 +302,7 @@ function wrapQoderSSE(response, model) {
         buffer = "";
       }
       if (!doneEmitted) {
-        controller.enqueue(encoder.encode("data: [DONE]\n\n"));
+        controller.enqueue(encoder.encode(SSE_DONE));
         doneEmitted = true;
       }
     },
@@ -410,15 +409,21 @@ export class QoderExecutor extends BaseExecutor {
       ...cosyHeaders,
     };
 
+    // Abort if upstream doesn't return response headers within connect timeout.
+    const timeoutMs = this.config?.timeoutMs || FETCH_CONNECT_TIMEOUT_MS;
+    const connectCtrl = new AbortController();
+    const connectTimer = setTimeout(() => connectCtrl.abort(new Error("fetch connect timeout")), timeoutMs);
+    const mergedSignal = signal ? AbortSignal.any([signal, connectCtrl.signal]) : connectCtrl.signal;
+
     let response;
     try {
       response = await proxyAwareFetch(
         url,
-        { method: "POST", headers, body: encodedBodyBuf, signal },
+        { method: "POST", headers, body: encodedBodyBuf, signal: mergedSignal },
         proxyOptions,
       );
-    } catch (err) {
-      throw err;
+    } finally {
+      clearTimeout(connectTimer);
     }
 
     if (!response.ok) {
@@ -430,10 +435,15 @@ export class QoderExecutor extends BaseExecutor {
     return { response: wrapped, url, headers, transformedBody: payload };
   }
 
-  // Refresh Qoder device tokens using openapi.qoder.sh/api/v1/deviceToken/refresh.
-  async refreshCredentials(credentials, log, proxyOptions = null) {
-    const { refreshQoderToken } = await import("../services/tokenRefresh.js");
-    return refreshQoderToken(credentials.refreshToken, log, proxyOptions);
+  // Qoder device tokens don't refresh through OAuth — the upstream returns
+  // 403 for our flow. Surfacing failure via 401-on-chat is enough; the
+  // dashboard tells users to re-login when their token expires (~30 days).
+  async refreshCredentials() {
+    return null;
+  }
+
+  needsRefresh() {
+    return false;
   }
 }
 

package/dist/open-sse/executors/vertex.js

@@ -1,11 +1,33 @@
 import { BaseExecutor } from "./base.js";
 import { PROVIDERS } from "../config/providers.js";
-import { parseVertexSaJson, refreshVertexToken } from "../services/tokenRefresh.js";
+import { parseVertexSaJson, refreshVertexToken, refreshGoogleToken } from "../services/tokenRefresh.js";
 import { proxyAwareFetch } from "../utils/proxyFetch.js";
 
 // Cache project IDs resolved from raw API keys { apiKey → projectId }
 const projectIdCache = new Map();
 
+/**
+ * Parse Google ADC user credential JSON from apiKey string.
+ * This is the format produced by `gcloud auth application-default login`.
+ */
+function parseVertexAdcJson(apiKey) {
+  if (typeof apiKey !== "string") return null;
+  try {
+    const parsed = JSON.parse(apiKey);
+    if (
+      parsed.type === "authorized_user" &&
+      parsed.client_id &&
+      parsed.client_secret &&
+      parsed.refresh_token
+    ) {
+      return parsed;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+
 /**
  * Resolve GCP project ID from a raw Vertex API key.
  * Sends a dummy 404 request and parses "projects/{id}" from the error message.
@@ -43,8 +65,13 @@ export class VertexExecutor extends BaseExecutor {
 
   buildUrl(model, stream, urlIndex = 0, credentials = null) {
     const saJson = parseVertexSaJson(credentials?.apiKey);
-    const rawKey = !saJson ? credentials?.apiKey : null;
-    const projectId = saJson?.project_id || credentials?.providerSpecificData?.projectId;
+    const adcJson = parseVertexAdcJson(credentials?.apiKey);
+    const usesOAuth = !!saJson || !!adcJson || !!credentials?.accessToken;
+    const rawKey = !usesOAuth ? credentials?.apiKey : null;
+    const projectId =
+      saJson?.project_id ||
+      adcJson?.quota_project_id ||
+      credentials?.providerSpecificData?.projectId;
 
     if (this.provider === "vertex-partner") {
       // Partner models require project_id in path regardless of auth method
@@ -56,8 +83,14 @@ export class VertexExecutor extends BaseExecutor {
     // Gemini on Vertex
     const action = stream ? "streamGenerateContent" : "generateContent";
 
-    if (saJson) {
-      // SA JSON + Bearer token: must use project-scoped path to avoid RESOURCE_PROJECT_INVALID
+    if (usesOAuth) {
+      // SA JSON / ADC / pre-set accessToken: must use project-scoped path to avoid RESOURCE_PROJECT_INVALID
+      if (!projectId) {
+        throw new Error(
+          "Vertex OAuth/ADC requires a project_id. " +
+          "Add quota_project_id to your ADC JSON or set providerSpecificData.projectId."
+        );
+      }
       const location = credentials?.providerSpecificData?.location || "us-central1";
       let url = `https://aiplatform.googleapis.com/v1/projects/${projectId}/locations/${location}/publishers/google/models/${model}:${action}`;
       if (stream) url += "?alt=sse";
@@ -97,16 +130,29 @@ export class VertexExecutor extends BaseExecutor {
 
   async execute({ model, body, stream, credentials, signal, log, proxyOptions = null }) {
     const saJson = parseVertexSaJson(credentials?.apiKey);
+    const adcJson = parseVertexAdcJson(credentials?.apiKey);
 
-    // SA JSON flow: mint Bearer token (cached)
+    // SA JSON flow: mint Bearer token via JWT assertion (cached)
     if (saJson) {
       const result = await refreshVertexToken(saJson, log);
       if (!result?.accessToken) throw new Error("Vertex: failed to mint access token from Service Account JSON");
       credentials.accessToken = result.accessToken;
     }
 
+    // ADC user credential flow: refresh Bearer token via Google OAuth2 token endpoint
+    if (adcJson) {
+      const result = await refreshGoogleToken(
+        adcJson.refresh_token,
+        adcJson.client_id,
+        adcJson.client_secret,
+        log
+      );
+      if (!result?.accessToken) throw new Error("Vertex: failed to refresh access token from ADC JSON (authorized_user)");
+      credentials.accessToken = result.accessToken;
+    }
+
     // vertex-partner with raw key: auto-resolve project_id if not provided
-    if (this.provider === "vertex-partner" && !saJson && !credentials?.providerSpecificData?.projectId) {
+    if (this.provider === "vertex-partner" && !saJson && !adcJson && !credentials?.providerSpecificData?.projectId) {
       const projectId = await resolveProjectId(credentials.apiKey);
       if (!projectId) throw new Error("Vertex: could not resolve project_id from API key. Please add it manually in provider settings.");
       log?.debug?.("VERTEX", `Resolved project_id: ${projectId}`);

package/dist/open-sse/executors/xiaomi-tokenplan.js

@@ -1,18 +1,19 @@
 import { DefaultExecutor } from "./default.js";
 import { resolveXiaomiTokenplanBaseUrl } from "../config/providers.js";
-import { getModelTargetFormat } from "../config/providerModels.js";
-import { FORMATS } from "../translator/formats.js";
+// import { getModelTargetFormat } from "../config/providerModels.js";
+// import { FORMATS } from "../translator/formats.js";
 
 export class XiaomiTokenplanExecutor extends DefaultExecutor {
   constructor() {
     super("xiaomi-tokenplan");
   }
 
-  // Claude-native aliases route to the Anthropic-compatible messages endpoint
+  // Token Plan keys are region-specific. Route per sourceFormat-matched transport:
+  // claude → Anthropic /anthropic/v1/messages, openai → /chat/completions.
   buildUrl(model, stream, urlIndex = 0, credentials = null) {
     const baseUrl = resolveXiaomiTokenplanBaseUrl(credentials);
-    if (getModelTargetFormat(model, model) === FORMATS.CLAUDE) {
-      return `${baseUrl.replace(/\/v1\/?$/, "/anthropic/v1")}/messages`;
+    if (credentials?.runtimeTransport?.format === "claude") {
+      return `${baseUrl.replace(/\/v1\/?$/, "")}/anthropic/v1/messages`;
     }
     return `${baseUrl}/chat/completions`;
   }