@fudrouter/fsrouter 0.6.64 → 0.6.66

package/open-sse/executors/glm.js

@@ -0,0 +1,361 @@
+import { randomUUID } from "node:crypto";
+import { DefaultExecutor } from "./default.ts";
+import {
+  applyConfiguredUserAgent,
+  mergeAbortSignals,
+  mergeUpstreamExtraHeaders
+} from "./base.ts";
+import {
+  buildGlmBaseHeaders,
+  buildGlmChatUrl,
+  buildGlmCodingHeaders,
+  buildGlmCountTokensUrl,
+  GLM_COUNT_TOKENS_TIMEOUT_MS,
+  getGlmTransport
+} from "../config/glmProvider.ts";
+import { applyProviderRequestDefaults } from "../services/providerRequestDefaults.ts";
+import { getRotatingApiKey } from "../services/apiKeyRotator.ts";
+import { CLAUDE_CLI_STAINLESS_PACKAGE_VERSION } from "../config/anthropicHeaders.ts";
+import {
+  getRuntimeVersion,
+  normalizeStainlessArch,
+  normalizeStainlessPlatform
+} from "../config/providerHeaderProfiles.ts";
+import { translateNonStreamingResponse } from "../handlers/responseTranslator.ts";
+import { translateRequest } from "../translator/index.ts";
+import { FORMATS } from "../translator/formats.ts";
+import { createSSETransformStreamWithLogger } from "../utils/stream.ts";
+import { ensureStreamReadiness } from "../utils/streamReadiness.ts";
+import { STREAM_READINESS_TIMEOUT_MS } from "../config/constants.ts";
+import { resolveSuppressThinkClose, THINKING_MARKER_HEADER } from "../utils/thinkCloseMarker.ts";
+function asRecord(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function getEffectiveKey(credentials) {
+  const extraKeys = credentials.providerSpecificData?.extraApiKeys ?? [];
+  if (credentials.apiKey && credentials.connectionId && extraKeys.length > 0) {
+    return getRotatingApiKey(credentials.connectionId, credentials.apiKey, extraKeys);
+  }
+  return credentials.apiKey || credentials.accessToken || "";
+}
+function parseGlm52Effort(model) {
+  if (model === "glm-5.2-high") return { baseModel: "glm-5.2", effort: "high" };
+  if (model === "glm-5.2-max") return { baseModel: "glm-5.2", effort: "max" };
+  return null;
+}
+const GLM_THINKING_MODEL_PATTERN = /^glm-5\.(?:[2-9]|\d{2,})/i;
+function isGlmThinkingModel(model) {
+  return GLM_THINKING_MODEL_PATTERN.test(model);
+}
+const GLM_THINKING_DEFAULT_MAX_TOKENS = 131072;
+function applyGlmRequestDefaults(body, defaults) {
+  const record = asRecord(body);
+  if (!record || !defaults) return body;
+  const next = { ...applyProviderRequestDefaults(record, defaults) };
+  const thinkingType = typeof defaults.thinkingType === "string" ? defaults.thinkingType : null;
+  if (thinkingType && next.thinking === void 0) {
+    next.thinking = { type: thinkingType };
+  } else if (thinkingType && asRecord(next.thinking)?.type === "enabled") {
+    next.thinking = { ...asRecord(next.thinking), type: thinkingType };
+  }
+  return next;
+}
+function hasTools(body) {
+  const record = asRecord(body);
+  return Array.isArray(record?.tools) && record.tools.length > 0;
+}
+function isRetryableGlmFallbackStatus(status) {
+  return status === 404 || status === 408 || status === 409 || status === 429 || status >= 500;
+}
+function isRetryableGlmFallbackError(error) {
+  if (!error) return false;
+  const err = error instanceof Error ? error : new Error(String(error));
+  if (err.name === "AbortError") return false;
+  return true;
+}
+function cloneHeaders(headers) {
+  const next = new Headers();
+  headers.forEach((value, key) => next.set(key, value));
+  return next;
+}
+function isJsonResponse(response) {
+  return (response.headers.get("content-type") || "").toLowerCase().includes("application/json");
+}
+async function translateJsonResponse(response) {
+  const parsed = await response.json().catch(() => null);
+  const translated = translateNonStreamingResponse(parsed, FORMATS.CLAUDE, FORMATS.OPENAI);
+  const headers = cloneHeaders(response.headers);
+  headers.set("content-type", "application/json");
+  headers.delete("content-length");
+  return new Response(JSON.stringify(translated), {
+    status: response.status,
+    statusText: response.statusText,
+    headers
+  });
+}
+async function translateAnthropicJsonResponse(response) {
+  const parsed = await response.json().catch(() => null);
+  const translated = response.ok ? translateNonStreamingResponse(parsed, FORMATS.CLAUDE, FORMATS.OPENAI) : translateAnthropicJsonError(parsed);
+  const headers = cloneHeaders(response.headers);
+  headers.set("content-type", "application/json");
+  headers.delete("content-length");
+  return new Response(JSON.stringify(translated), {
+    status: response.status,
+    statusText: response.statusText,
+    headers
+  });
+}
+function translateAnthropicJsonError(parsed) {
+  const root = asRecord(parsed) || {};
+  const error = asRecord(root.error) || root;
+  const message = typeof error.message === "string" && error.message.trim() ? error.message : typeof root.message === "string" && root.message.trim() ? root.message : "GLM Anthropic transport error";
+  const type = typeof error.type === "string" && error.type.trim() ? error.type : typeof root.type === "string" && root.type.trim() ? root.type : "upstream_error";
+  return {
+    error: {
+      message,
+      type
+    }
+  };
+}
+function translateSseResponse(response, provider, model, suppressThinkClose = false) {
+  if (!response.body) return response;
+  const transform = createSSETransformStreamWithLogger(
+    FORMATS.CLAUDE,
+    FORMATS.OPENAI,
+    provider,
+    null,
+    null,
+    model,
+    null,
+    null,
+    null,
+    null,
+    null,
+    false,
+    suppressThinkClose
+  );
+  const headers = cloneHeaders(response.headers);
+  headers.set("content-type", "text/event-stream");
+  headers.delete("content-length");
+  return new Response(response.body.pipeThrough(transform), {
+    status: response.status,
+    statusText: response.statusText,
+    headers
+  });
+}
+class GlmExecutor extends DefaultExecutor {
+  constructor(provider = "glm") {
+    super(provider);
+  }
+  buildUrl(_model, _stream, _urlIndex = 0, credentials = null) {
+    const primaryTransport = getGlmTransport(credentials?.providerSpecificData);
+    const transport = _urlIndex === 1 ? primaryTransport === "openai" ? "anthropic" : "openai" : primaryTransport;
+    return buildGlmChatUrl(credentials?.providerSpecificData, transport, this.config.baseUrl);
+  }
+  buildCountTokensUrl(_model, credentials = null) {
+    return buildGlmCountTokensUrl(credentials?.providerSpecificData, this.config.baseUrl);
+  }
+  getCountTokensTimeoutMs() {
+    return GLM_COUNT_TOKENS_TIMEOUT_MS;
+  }
+  buildHeaders(credentials, stream = true, _clientHeaders, _model, transport = getGlmTransport(credentials.providerSpecificData)) {
+    if (transport === "openai") {
+      return buildGlmCodingHeaders(getEffectiveKey(credentials), stream);
+    }
+    return {
+      ...buildGlmBaseHeaders(getEffectiveKey(credentials), stream),
+      "X-Stainless-Arch": normalizeStainlessArch(),
+      "X-Stainless-OS": normalizeStainlessPlatform(),
+      "X-Stainless-Runtime-Version": getRuntimeVersion(),
+      "X-Stainless-Package-Version": CLAUDE_CLI_STAINLESS_PACKAGE_VERSION,
+      "X-Claude-Code-Session-Id": randomUUID(),
+      "x-client-request-id": randomUUID()
+    };
+  }
+  transformRequest(model, body, stream, credentials) {
+    const cleanedBody = super.transformRequest(model, body, stream, credentials);
+    return applyGlmRequestDefaults(cleanedBody, this.config.requestDefaults);
+  }
+  async transformForTransport(model, body, stream, credentials, transport) {
+    const effortTier = parseGlm52Effort(model);
+    const effectiveModel = effortTier ? effortTier.baseModel : model;
+    const transformed = this.transformRequest(effectiveModel, body, stream, credentials);
+    const record = asRecord(transformed);
+    if (record && effortTier) {
+      record.model = effectiveModel;
+    }
+    if (record && isGlmThinkingModel(effectiveModel)) {
+      const clientBody = asRecord(body);
+      const clientMaxTokens = clientBody?.max_tokens ?? clientBody?.max_completion_tokens;
+      if (!clientMaxTokens) {
+        record.max_tokens = GLM_THINKING_DEFAULT_MAX_TOKENS;
+      }
+    }
+    if (transport === "openai") {
+      if (record && stream && hasTools(record) && record.tool_stream === void 0) {
+        return { ...record, tool_stream: true };
+      }
+      return transformed;
+    }
+    const translated = await translateRequest(
+      FORMATS.OPENAI,
+      FORMATS.CLAUDE,
+      effectiveModel,
+      { ...record ?? {}, _disableToolPrefix: true },
+      stream,
+      credentials,
+      this.provider,
+      null,
+      { preserveCacheControl: false }
+    );
+    if (effortTier) {
+      const translatedRecord = asRecord(translated);
+      if (translatedRecord) {
+        translatedRecord.effort = effortTier.effort;
+        const existingThinking = asRecord(translatedRecord.thinking);
+        if (!existingThinking || existingThinking.type !== "enabled") {
+          translatedRecord.thinking = {
+            ...existingThinking,
+            type: "enabled"
+          };
+        }
+      }
+    }
+    return translated;
+  }
+  async executeTransport(input, transport) {
+    const credentials = input.credentials;
+    const url = buildGlmChatUrl(credentials?.providerSpecificData, transport, this.config.baseUrl);
+    const headers = this.buildHeaders(
+      credentials,
+      input.stream,
+      input.clientHeaders,
+      input.model,
+      transport
+    );
+    applyConfiguredUserAgent(headers, credentials.providerSpecificData);
+    mergeUpstreamExtraHeaders(headers, input.upstreamExtraHeaders);
+    const transformedBody = this.transformForTransport(
+      input.model,
+      input.body,
+      input.stream,
+      credentials,
+      transport
+    );
+    const fetchStartTimeoutMs = this.getTimeoutMs();
+    const timeoutController = fetchStartTimeoutMs > 0 ? new AbortController() : null;
+    let timeoutId = null;
+    if (timeoutController) {
+      timeoutId = setTimeout(() => {
+        const timeoutError = new Error(`Fetch timeout after ${fetchStartTimeoutMs}ms on ${url}`);
+        timeoutError.name = "TimeoutError";
+        timeoutController.abort(timeoutError);
+      }, fetchStartTimeoutMs);
+    }
+    const timeoutSignal = timeoutController?.signal ?? null;
+    const combinedSignal = input.signal && timeoutSignal ? mergeAbortSignals(input.signal, timeoutSignal) : input.signal || timeoutSignal;
+    let response;
+    try {
+      response = await fetch(url, {
+        method: "POST",
+        headers,
+        body: JSON.stringify(transformedBody),
+        signal: combinedSignal || void 0
+      });
+    } finally {
+      if (timeoutId) clearTimeout(timeoutId);
+    }
+    if (input.stream && response.ok) {
+      const readiness = await ensureStreamReadiness(response, {
+        timeoutMs: STREAM_READINESS_TIMEOUT_MS,
+        provider: this.provider,
+        model: input.model,
+        log: input.log
+      });
+      response = readiness.response;
+    }
+    const result = { response, url, headers, transformedBody };
+    if (transport === "anthropic") {
+      const clientHeaders = input.clientHeaders ?? {};
+      const suppressThinkClose = resolveSuppressThinkClose({
+        userAgent: clientHeaders["user-agent"] ?? clientHeaders["User-Agent"] ?? null,
+        thinkingMarkerHeader: clientHeaders[THINKING_MARKER_HEADER] ?? clientHeaders["x-omniroute-thinking-marker"] ?? null
+      });
+      const translatedResponse = input.stream && result.response.ok ? translateSseResponse(result.response, this.provider, input.model, suppressThinkClose) : isJsonResponse(result.response) ? await translateAnthropicJsonResponse(result.response) : result.response;
+      return {
+        ...result,
+        response: translatedResponse,
+        url,
+        headers,
+        transformedBody,
+        targetFormat: FORMATS.OPENAI
+      };
+    }
+    return {
+      ...result,
+      url,
+      headers,
+      transformedBody,
+      targetFormat: FORMATS.OPENAI
+    };
+  }
+  async execute(input) {
+    const effortTier = parseGlm52Effort(input.model);
+    if (effortTier) {
+      return this.executeTransport(input, "anthropic");
+    }
+    const primaryTransport = getGlmTransport(
+      input.credentials.providerSpecificData,
+      this.config.baseUrl
+    );
+    const fallbackTransport = primaryTransport === "openai" ? "anthropic" : "openai";
+    let primaryResult = null;
+    try {
+      primaryResult = await this.executeTransport(input, primaryTransport);
+      if (!isRetryableGlmFallbackStatus(primaryResult.response.status)) {
+        return primaryResult;
+      }
+      input.log?.debug?.(
+        "GLM_FALLBACK",
+        `${primaryTransport} returned ${primaryResult.response.status}; trying ${fallbackTransport}`
+      );
+    } catch (error) {
+      if (!isRetryableGlmFallbackError(error)) throw error;
+      input.log?.debug?.(
+        "GLM_FALLBACK",
+        `${primaryTransport} error (${error instanceof Error ? error.message : String(error)}); trying ${fallbackTransport}`
+      );
+    }
+    try {
+      const fallbackResult = await this.executeTransport(input, fallbackTransport);
+      if (fallbackResult.response.ok || !primaryResult) {
+        return fallbackResult;
+      }
+    } catch (error) {
+      if (!primaryResult) throw error;
+      input.log?.debug?.(
+        "GLM_FALLBACK",
+        `${fallbackTransport} fallback failed (${error instanceof Error ? error.message : String(error)}); returning primary response`
+      );
+    }
+    return primaryResult;
+  }
+  async countTokens(input) {
+    return super.countTokens({
+      ...input,
+      credentials: {
+        ...input.credentials,
+        providerSpecificData: {
+          ...input.credentials.providerSpecificData || {},
+          primaryTransport: "anthropic"
+        }
+      }
+    });
+  }
+}
+var glm_default = GlmExecutor;
+export {
+  GlmExecutor,
+  glm_default as default,
+  translateSseResponse
+};

package/open-sse/executors/grok-cli.js

@@ -0,0 +1,119 @@
+/**
+ * Grok CLI Executor — uses xAI API (api.x.ai) with token from ~/.grok/auth.json.
+ * Auth: reads OIDC token from ~/.grok/auth.json (set by `grok login`).
+ * OpenAI-compatible format.
+ * 
+ * NOTE: Requires xAI credits or Grok subscription.
+ * Free Grok 4.5 is only available via the Grok CLI TUI, not via API.
+ */
+
+import { BaseExecutor } from "./base.js";
+import { PROVIDERS } from "../config/providers.js";
+import { readFileSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+
+const XAI_API = "https://api.x.ai/v1/chat/completions";
+const AUTH_JSON_PATH = join(homedir(), ".grok", "auth.json");
+
+function readCliToken() {
+  try {
+    const raw = readFileSync(AUTH_JSON_PATH, "utf-8");
+    const data = JSON.parse(raw);
+    for (const [_scope, entry] of Object.entries(data)) {
+      if (entry && typeof entry === "object" && entry.key) {
+        return entry.key;
+      }
+    }
+    return data.session_token || data.token || data.access_token || data.key || null;
+  } catch {
+    return null;
+  }
+}
+
+export class GrokCliExecutor extends BaseExecutor {
+  constructor() {
+    super("grok-cli", PROVIDERS["grok-cli"]);
+  }
+
+  async execute({ model, body, stream, credentials, signal, log }) {
+    let token = credentials?.apiKey || readCliToken();
+    if (!token || token === "cli-auth") {
+      token = readCliToken();
+    }
+    if (!token) {
+      return {
+        response: new Response(JSON.stringify({
+          error: {
+            message: "Grok CLI not authenticated. Run `grok login` on the server, or paste xAI API key.",
+            type: "authentication_error",
+          },
+        }), { status: 401, headers: { "Content-Type": "application/json" } }),
+        url: XAI_API,
+        headers: {},
+        transformedBody: body,
+      };
+    }
+
+    if (token.startsWith("Bearer ")) token = token.slice(7);
+
+    const headers = {
+      "Content-Type": "application/json",
+      "Authorization": `Bearer ${token}`,
+    };
+
+    // Map grok-4.5 to actual xAI model ID
+    const MODEL_MAP = {
+      "grok-4.5": "grok-4-0709",
+      "grok-4": "grok-4-0709",
+      "grok-3": "grok-3",
+    };
+
+    const upstreamModel = MODEL_MAP[model] || model;
+    const upstreamBody = { ...body, model: upstreamModel, stream: stream !== false };
+
+    log?.info?.("GROK-CLI", `→ ${model} (upstream: ${upstreamModel}) via api.x.ai`);
+
+    let response;
+    try {
+      response = await fetch(XAI_API, {
+        method: "POST",
+        headers,
+        body: JSON.stringify(upstreamBody),
+        signal,
+      });
+    } catch (err) {
+      log?.error?.("GROK-CLI", `Fetch failed: ${err.message}`);
+      return {
+        response: new Response(JSON.stringify({
+          error: { message: `Grok connection failed: ${err.message}`, type: "upstream_error" },
+        }), { status: 502, headers: { "Content-Type": "application/json" } }),
+        url: XAI_API,
+        headers,
+        transformedBody: upstreamBody,
+      };
+    }
+
+    if (!response.ok) {
+      const status = response.status;
+      const errBody = await response.text().catch(() => "");
+      let errMsg;
+      if (status === 401) errMsg = "Grok token expired. Run `grok login` to refresh, or paste a new xAI API key.";
+      else if (status === 429) errMsg = "Grok rate limited. Wait and retry.";
+      else if (errBody.includes("spending-limit")) errMsg = "No xAI credits. Add credits at https://console.x.ai or use Grok subscription.";
+      else errMsg = `Grok returned HTTP ${status}: ${errBody.slice(0, 200)}`;
+      log?.warn?.("GROK-CLI", errMsg);
+      return {
+        response: new Response(JSON.stringify({
+          error: { message: errMsg, type: "upstream_error", code: `HTTP_${status}` },
+        }), { status: status === 403 ? 402 : status, headers: { "Content-Type": "application/json" } }),
+        url: XAI_API,
+        headers,
+        transformedBody: upstreamBody,
+      };
+    }
+
+    // Pass through — xAI API is OpenAI-compatible
+    return { response, url: XAI_API, headers, transformedBody: upstreamBody };
+  }
+}