wyxrouter 0.4.71

package/open-sse/services/provider.js

@@ -0,0 +1,356 @@
+import { PROVIDERS } from "../config/providers.js";
+import { buildClineHeaders } from "../../src/shared/utils/clineAuth.js";
+
+const OPENAI_COMPATIBLE_PREFIX = "openai-compatible-";
+const OPENAI_COMPATIBLE_DEFAULTS = {
+  baseUrl: "https://api.openai.com/v1",
+};
+
+const ANTHROPIC_COMPATIBLE_PREFIX = "anthropic-compatible-";
+const ANTHROPIC_COMPATIBLE_DEFAULTS = {
+  baseUrl: "https://api.anthropic.com/v1",
+};
+
+function isOpenAICompatible(provider) {
+  return typeof provider === "string" && provider.startsWith(OPENAI_COMPATIBLE_PREFIX);
+}
+
+function isAnthropicCompatible(provider) {
+  return typeof provider === "string" && provider.startsWith(ANTHROPIC_COMPATIBLE_PREFIX);
+}
+
+function getOpenAICompatibleType(provider) {
+  if (!isOpenAICompatible(provider)) return "chat";
+  return provider.includes("responses") ? "responses" : "chat";
+}
+
+function buildOpenAICompatibleUrl(baseUrl, apiType) {
+  const normalized = baseUrl.replace(/\/$/, "");
+  const path = apiType === "responses" ? "/responses" : "/chat/completions";
+  return `${normalized}${path}`;
+}
+
+function buildAnthropicCompatibleUrl(baseUrl) {
+  const normalized = baseUrl.replace(/\/$/, "");
+  return `${normalized}/messages`;
+}
+
+function buildQwenBaseUrl(resourceUrl, fallbackBaseUrl) {
+  const fallback = (fallbackBaseUrl || "").replace(/\/chat\/completions$/, "");
+  const raw = typeof resourceUrl === "string" ? resourceUrl.trim() : "";
+  if (!raw) return fallback;
+  if (raw.startsWith("http://") || raw.startsWith("https://")) {
+    return raw.replace(/\/$/, "");
+  }
+  return `https://${raw.replace(/\/$/, "")}/v1`;
+}
+
+// Detect request format from body structure
+export function detectFormat(body) {
+  // OpenAI Responses API: has input (array or string) instead of messages[]
+  // The Responses API accepts both input as array and input as a plain string
+  if (body.input && (Array.isArray(body.input) || typeof body.input === "string") && !body.messages) {
+    return "openai-responses";
+  }
+
+  // Antigravity format: Gemini wrapped in body.request
+  if (body.request?.contents && body.userAgent === "antigravity") {
+    return "antigravity";
+  }
+
+  // Gemini format: has contents array
+  if (body.contents && Array.isArray(body.contents)) {
+    return "gemini";
+  }
+
+  // OpenAI-specific indicators (check BEFORE Claude)
+  // These fields are OpenAI-specific and never appear in Claude format
+  if (
+    body.stream_options ||           // OpenAI streaming options
+    body.response_format ||           // JSON mode, etc.
+    body.logprobs !== undefined ||    // Log probabilities
+    body.top_logprobs !== undefined ||
+    body.n !== undefined ||           // Number of completions
+    body.presence_penalty !== undefined ||  // Penalties
+    body.frequency_penalty !== undefined ||
+    body.logit_bias ||                // Token biasing
+    body.user                         // User identifier
+  ) {
+    return "openai";
+  }
+
+  // Claude format: messages with content as array of objects with type
+  // Claude requires content to be array with specific structure
+  if (body.messages && Array.isArray(body.messages)) {
+    const firstMsg = body.messages[0];
+    
+    // If content is array, check if it follows Claude structure
+    if (firstMsg?.content && Array.isArray(firstMsg.content)) {
+      const firstContent = firstMsg.content[0];
+      
+      // Claude format has specific types: text, image, tool_use, tool_result
+      // OpenAI multimodal has: text, image_url (note the difference)
+      if (firstContent?.type === "text" && !body.model?.includes("/")) {
+        // Could be Claude or OpenAI multimodal
+        // Check for Claude-specific fields
+        if (body.system || body.anthropic_version) {
+          return "claude";
+        }
+        // Check if image format is Claude (source.type) vs OpenAI (image_url.url)
+        const hasClaudeImage = firstMsg.content.some(c => 
+          c.type === "image" && c.source?.type === "base64"
+        );
+        const hasOpenAIImage = firstMsg.content.some(c => 
+          c.type === "image_url" && c.image_url?.url
+        );
+        if (hasClaudeImage) return "claude";
+        if (hasOpenAIImage) return "openai";
+        
+        // If still unclear, check for tool format
+        const hasClaudeTool = firstMsg.content.some(c => 
+          c.type === "tool_use" || c.type === "tool_result"
+        );
+        if (hasClaudeTool) return "claude";
+      }
+    }
+    
+    // If content is string, it's likely OpenAI (Claude also supports this)
+    // Check for other Claude-specific indicators
+    if (body.system !== undefined || body.anthropic_version) {
+      return "claude";
+    }
+  }
+
+  // Default to OpenAI format
+  return "openai";
+}
+
+// Get provider config
+export function getProviderConfig(provider) {
+  if (isOpenAICompatible(provider)) {
+    const apiType = getOpenAICompatibleType(provider);
+    return {
+      ...PROVIDERS.openai,
+      format: apiType === "responses" ? "openai-responses" : "openai",
+      baseUrl: OPENAI_COMPATIBLE_DEFAULTS.baseUrl,
+    };
+  }
+  if (isAnthropicCompatible(provider)) {
+    return {
+      ...PROVIDERS.anthropic, // Use Anthropic defaults (header: x-api-key)
+      format: "claude",
+      baseUrl: ANTHROPIC_COMPATIBLE_DEFAULTS.baseUrl,
+    };
+  }
+  return PROVIDERS[provider] || PROVIDERS.openai;
+}
+
+// Get number of fallback URLs for provider (for retry logic)
+export function getProviderFallbackCount(provider) {
+  const config = getProviderConfig(provider);
+  return config.baseUrls?.length || 1;
+}
+
+// Build provider URL
+export function buildProviderUrl(provider, model, stream = true, options = {}) {
+  if (isOpenAICompatible(provider)) {
+    const apiType = getOpenAICompatibleType(provider);
+    const baseUrl = options?.baseUrl || OPENAI_COMPATIBLE_DEFAULTS.baseUrl;
+    return buildOpenAICompatibleUrl(baseUrl, apiType);
+  }
+  if (isAnthropicCompatible(provider)) {
+    const baseUrl = options?.baseUrl || ANTHROPIC_COMPATIBLE_DEFAULTS.baseUrl;
+    return buildAnthropicCompatibleUrl(baseUrl);
+  }
+  const config = getProviderConfig(provider);
+
+  switch (provider) {
+    case "claude":
+      return `${config.baseUrl}?beta=true`;
+
+    case "gemini": {
+      const action = stream ? "streamGenerateContent?alt=sse" : "generateContent";
+      return `${config.baseUrl}/${model}:${action}`;
+    }
+
+    case "gemini-cli": {
+      const action = stream ? "streamGenerateContent?alt=sse" : "generateContent";
+      return `${config.baseUrl}:${action}`;
+    }
+
+    case "antigravity": {
+      // Use baseUrlIndex from options or default to 0
+      const urlIndex = options?.baseUrlIndex || 0;
+      const baseUrl = config.baseUrls[urlIndex] || config.baseUrls[0];
+      const path = stream ? "/v1internal:streamGenerateContent?alt=sse" : "/v1internal:generateContent";
+      return `${baseUrl}${path}`;
+    }
+
+    case "codex":
+      return config.baseUrl;
+
+    case "qwen": {
+      const baseUrl = buildQwenBaseUrl(options?.qwenResourceUrl, config.baseUrl);
+      return `${baseUrl}/chat/completions`;
+    }
+
+    case "github":
+      return config.baseUrl;
+
+    case "glm":
+    case "kimi":
+    case "minimax":
+      // Claude-compatible providers
+      return `${config.baseUrl}?beta=true`;
+
+    default:
+      return config.baseUrl;
+  }
+}
+
+// Build provider headers
+export function buildProviderHeaders(provider, credentials, stream = true, body = null) {
+  const config = getProviderConfig(provider);
+  const headers = {
+    "Content-Type": "application/json",
+    ...config.headers
+  };
+
+  // Add auth header
+  // Specific override for Anthropic Compatible
+  if (isAnthropicCompatible(provider)) {
+    if (credentials.apiKey) {
+      headers["x-api-key"] = credentials.apiKey;
+      // Do NOT send Authorization header when apiKey is present for Anthropic Compatible
+      // as it causes issues with some providers (e.g. opencode.ai)
+    } else if (credentials.accessToken) {
+      headers["Authorization"] = `Bearer ${credentials.accessToken}`;
+    }
+    // Add default Anthropic version if not present (some proxies require it)
+    if (!headers["anthropic-version"]) {
+      headers["anthropic-version"] = "2023-06-01";
+    }
+  } else {
+    switch (provider) {
+      case "gemini":
+        if (credentials.apiKey) {
+          headers["x-goog-api-key"] = credentials.apiKey;
+        } else if (credentials.accessToken) {
+          headers["Authorization"] = `Bearer ${credentials.accessToken}`;
+        }
+        break;
+  
+      case "antigravity":
+      case "gemini-cli":
+        // Antigravity and Gemini CLI use OAuth access token
+        headers["Authorization"] = `Bearer ${credentials.accessToken}`;
+        break;
+  
+      case "claude":
+        // Claude uses x-api-key header for API key, or Authorization for OAuth
+        if (credentials.apiKey) {
+          headers["x-api-key"] = credentials.apiKey;
+        } else if (credentials.accessToken) {
+          headers["Authorization"] = `Bearer ${credentials.accessToken}`;
+        }
+        break;
+  
+      case "github": {
+        // GitHub Copilot requires special headers to mimic VSCode
+        // Prioritize copilotToken from providerSpecificData, fallback to accessToken
+        const githubToken = credentials.copilotToken || credentials.accessToken;
+        // Add headers in exact same order as test endpoint
+        headers["Authorization"] = `Bearer ${githubToken}`;
+        headers["Content-Type"] = "application/json";
+        headers["copilot-integration-id"] = "vscode-chat";
+        headers["editor-version"] = "vscode/1.107.1";
+        headers["editor-plugin-version"] = "copilot-chat/0.26.7";
+        headers["user-agent"] = "GitHubCopilotChat/0.26.7";
+        headers["openai-intent"] = "conversation-panel";
+        headers["x-github-api-version"] = "2025-04-01";
+        // Generate a UUID for x-request-id (Cloudflare Workers compatible)
+        headers["x-request-id"] = crypto.randomUUID ? crypto.randomUUID() : 
+          'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function(c) {
+            const r = Math.random() * 16 | 0;
+            const v = c == 'x' ? r : (r & 0x3 | 0x8);
+            return v.toString(16);
+          });
+        headers["x-vscode-user-agent-library-version"] = "electron-fetch";
+        headers["X-Initiator"] = "user";
+        headers["Accept"] = "application/json";
+        break;
+      }
+  
+      case "codex":
+      case "qwen":
+      case "openai":
+      case "openrouter":
+        headers["Authorization"] = `Bearer ${credentials.apiKey || credentials.accessToken}`;
+        break;
+
+      case "cline":
+        Object.assign(headers, buildClineHeaders(credentials.apiKey || credentials.accessToken));
+        break;
+  
+      case "glm":
+      case "kimi":
+      case "minimax":
+        // Claude-compatible API providers use x-api-key
+        headers["x-api-key"] = credentials.apiKey;
+        break;
+
+      case "vertex":
+      case "vertex-partner":
+        // Vertex uses async token minting — headers are set by VertexExecutor._buildHeadersAsync()
+        // Do NOT set Authorization here; it would leak the raw SA JSON as Bearer token
+        break;
+  
+      default:
+        headers["Authorization"] = `Bearer ${credentials.apiKey || credentials.accessToken}`;
+        break;
+    }
+  }
+
+  // Stream accept header
+  if (stream) {
+    headers["Accept"] = "text/event-stream";
+  }
+
+  return headers;
+}
+
+// Get target format for provider
+export function getTargetFormat(provider) {
+  if (isOpenAICompatible(provider)) {
+    return getOpenAICompatibleType(provider) === "responses" ? "openai-responses" : "openai";
+  }
+  if (isAnthropicCompatible(provider)) {
+    return "claude";
+  }
+  const config = getProviderConfig(provider);
+  return config.format || "openai";
+}
+
+// Check if last message is from user
+export function isLastMessageFromUser(body) {
+  const messages = body.messages || body.contents;
+  if (!messages?.length) return true;
+  const lastMsg = messages[messages.length - 1];
+  return lastMsg?.role === "user";
+}
+
+// Check if request has thinking config
+export function hasThinkingConfig(body) {
+  return !!(body.reasoning_effort || body.thinking?.type === "enabled");
+}
+
+// Normalize thinking config based on last message role
+// - If lastMessage is not user → remove thinking config
+// - If lastMessage is user AND has thinking config → keep it (force enable)
+export function normalizeThinkingConfig(body) {
+  if (!isLastMessageFromUser(body)) {
+    delete body.reasoning_effort;
+    delete body.thinking;
+  }
+  return body;
+}

package/open-sse/services/qoderModels.js

@@ -0,0 +1,214 @@
+/**
+ * Qoder model catalog fetcher.
+ *
+ * Calls /algo/api/v2/model/list (COSY-signed) on the inference host to get
+ * the live catalog for an authenticated Qoder account, then caches the
+ * per-model `model_config` blocks by key. Chat requests later look up the
+ * exact server-published metadata for the model they want — Qoder's chat
+ * endpoint silently downgrades to a different model when the wrong
+ * model_config is sent.
+ *
+ * On any error the live cache stays empty and chatExecuteCall surfaces the
+ * problem to the user as "model config not yet fetched, retry shortly".
+ */
+
+import { createHash } from "crypto";
+
+import { proxyAwareFetch } from "../utils/proxyFetch.js";
+import { buildCosyHeaders } from "@/lib/qoder/cosy.js";
+import {
+  QODER_MODEL_LIST_URL,
+} from "@/lib/qoder/constants.js";
+
+const FETCH_TIMEOUT_MS = 15_000;
+const CACHE_TTL_MS = 60 * 60 * 1000; // 1h, same as the Kiro catalog
+
+/** @type {Map<string, { expiresAt: number, models: any[], rawConfigs: Map<string, object>, fetched: boolean }>} */
+const catalogCache = new Map();
+
+/**
+ * In-flight fetch promises keyed by cacheKey. Concurrent first-time
+ * callers (parallel chat windows) all observe the same Promise so we
+ * fan-out exactly one upstream request per credential per miss.
+ * @type {Map<string, Promise<{ expiresAt: number, models: any[], rawConfigs: Map<string, object>, fetched: boolean } | null>>}
+ */
+const inflight = new Map();
+
+/**
+ * Stable cache key per credential (so different login sessions for the same
+ * account share an entry).
+ */
+function cacheKey(credentials) {
+  const psd = credentials?.providerSpecificData || {};
+  const seed = psd.userId || credentials?.refreshToken || credentials?.accessToken || "anonymous";
+  return createHash("sha256").update(`qoder:${seed}`).digest("hex");
+}
+
+/**
+ * Strip credential -> COSY creds for buildCosyHeaders.
+ */
+function cosyCredsFromConnection(credentials) {
+  const psd = credentials?.providerSpecificData || {};
+  return {
+    userId: psd.userId,
+    authToken: credentials.accessToken,
+    name: credentials.displayName || "",
+    email: credentials.email || "",
+    machineId: psd.machineId || "",
+  };
+}
+
+/**
+ * Fetch the live model list for this credential. Returns:
+ *   { models: [{ id, name, contextLength, isVL, isReasoning, ... }, ...],
+ *     rawConfigs: Map<modelKey, modelConfigObject> }
+ * or `null` on any error.
+ */
+async function fetchQoderCatalogRaw(credentials, signal, proxyOptions = null) {
+  const creds = cosyCredsFromConnection(credentials);
+  if (!creds.userId || !creds.authToken) return null;
+
+  const headers = {
+    Accept: "application/json",
+    "Accept-Encoding": "identity",
+    ...buildCosyHeaders(Buffer.alloc(0), QODER_MODEL_LIST_URL, creds),
+  };
+
+  const controller = new AbortController();
+  let timer = null;
+  let abortListener = null;
+  let response;
+  try {
+    timer = setTimeout(() => controller.abort("timeout"), FETCH_TIMEOUT_MS);
+    if (signal && typeof signal.addEventListener === "function") {
+      // If the parent signal already aborted before we got here, the
+      // 'abort' event has already fired and addEventListener won't
+      // re-trigger it. Propagate the cancellation immediately.
+      if (signal.aborted) {
+        controller.abort(signal.reason);
+      } else {
+        abortListener = () => controller.abort(signal.reason);
+        signal.addEventListener("abort", abortListener);
+      }
+    }
+    response = await proxyAwareFetch(
+      QODER_MODEL_LIST_URL,
+      {
+        method: "GET",
+        headers,
+        signal: controller.signal,
+      },
+      proxyOptions,
+    );
+  } finally {
+    if (timer) clearTimeout(timer);
+    if (signal && abortListener) signal.removeEventListener("abort", abortListener);
+  }
+
+  if (!response.ok) return null;
+
+  const body = await response.json().catch(() => null);
+  if (!body || !Array.isArray(body.chat)) return null;
+
+  const models = [];
+  const rawConfigs = new Map();
+  for (const entry of body.chat) {
+    if (!entry || typeof entry !== "object") continue;
+    const key = entry.key;
+    if (!key) continue;
+
+    // Always cache the config — chat needs model_config even for UI-hidden
+    // models (enable:false). Upstream still accepts chat for these keys.
+    rawConfigs.set(key, entry);
+    if (entry.enable === false) continue;
+
+    const display = entry.display_name || key;
+    const ctx = Number(entry.max_input_tokens) || 131_072;
+    models.push({
+      id: key,
+      name: `${display}`,
+      contextLength: ctx,
+      isVL: !!entry.is_vl,
+      isReasoning: !!entry.is_reasoning,
+      maxOutputTokens: Number(entry.max_output_tokens) || 0,
+      description: entry.description || "",
+    });
+  }
+
+  return { models, rawConfigs };
+}
+
+/**
+ * Get the cached model_config block for a given model key, fetching the
+ * catalog first if needed. Returns null when the catalog can't be fetched
+ * (so callers can fall back to the static registry).
+ */
+export async function getQoderModelConfig(credentials, modelKey, options = {}) {
+  const cached = await resolveQoderModels(credentials, options);
+  if (!cached) return null;
+  const config = cached.rawConfigs.get(modelKey);
+  if (!config) return null;
+  // Defensive copy — chat code may mutate `key` to align with the alias path.
+  return { ...config, key: modelKey };
+}
+
+/**
+ * Resolve the live model catalog + raw configs for a credential. Caches
+ * results for CACHE_TTL_MS so repeated chat requests don't re-fetch, and
+ * deduplicates concurrent misses so parallel chat windows fan-out exactly
+ * one upstream request per credential.
+ */
+export async function resolveQoderModels(credentials, options = {}) {
+  if (!credentials?.accessToken) return null;
+  const psd = credentials.providerSpecificData || {};
+  if (!psd.userId) return null;
+
+  const key = cacheKey(credentials);
+  const now = Date.now();
+  if (!options.forceRefresh) {
+    const cached = catalogCache.get(key);
+    if (cached && cached.expiresAt > now) {
+      return cached;
+    }
+  }
+
+  // Coalesce concurrent misses on the same credential into one upstream call.
+  // forceRefresh callers still get their own fetch (they wanted fresh data).
+  const existing = inflight.get(key);
+  if (existing && !options.forceRefresh) {
+    return existing;
+  }
+
+  const fetchPromise = (async () => {
+    const fetched = await fetchQoderCatalogRaw(credentials, options.signal, options.proxyOptions);
+    if (!fetched) return null;
+    const entry = {
+      expiresAt: Date.now() + CACHE_TTL_MS,
+      models: fetched.models,
+      rawConfigs: fetched.rawConfigs,
+      fetched: true,
+    };
+    catalogCache.set(key, entry);
+    return entry;
+  })();
+
+  inflight.set(key, fetchPromise);
+  try {
+    return await fetchPromise;
+  } finally {
+    // Clear only if this is still the in-flight entry — a forceRefresh
+    // call that started later may have replaced it.
+    if (inflight.get(key) === fetchPromise) {
+      inflight.delete(key);
+    }
+  }
+}
+
+export function invalidateQoderCatalog(credentials) {
+  if (!credentials) return;
+  catalogCache.delete(cacheKey(credentials));
+}
+
+export function clearQoderCatalog() {
+  catalogCache.clear();
+}