n9router 0.4.44 → 0.4.46

package/app/open-sse/executors/default.js

@@ -1,10 +1,80 @@
 import { BaseExecutor } from "./base.js";
-import { PROVIDERS } from "../config/providers.js";
+import { PROVIDERS, PROVIDER_OAUTH } from "../config/providers.js";
+import { ANTHROPIC_API_VERSION, OPENAI_COMPAT_BASE, ANTHROPIC_COMPAT_BASE } from "../providers/shared.js";
 import { OAUTH_ENDPOINTS, buildKimiHeaders } from "../config/appConstants.js";
-import { buildClineHeaders } from "../../src/shared/utils/clineAuth.js";
+import { buildClineHeaders } from "../shared/clineAuth.js";
 import { getCachedClaudeHeaders } from "../utils/claudeHeaderCache.js";
 import { proxyAwareFetch } from "../utils/proxyFetch.js";
 import { injectReasoningContent } from "../utils/reasoningContentInjector.js";
+import { stripUnsupportedParams } from "../translator/concerns/paramSupport.js";
+
+// Auth header descriptors — derived from registry transport.auth, fallback to hardcoded defaults.
+const BEARER = { combined: true, header: "Authorization", scheme: "bearer" };
+const XAPIKEY = { combined: true, header: "x-api-key", scheme: "raw" };
+const AUTH_DESCRIPTORS = Object.fromEntries(
+  Object.entries(PROVIDERS)
+    .filter(([, t]) => t.auth)
+    .map(([id, t]) => [id, t.auth])
+);
+
+// Apply a token to a header per scheme (matches legacy: combined always sets, even when undefined).
+function setAuth(headers, spec, token) {
+  headers[spec.header] = spec.scheme === "bearer" ? `Bearer ${token}` : token;
+}
+
+// Resolve auth onto headers from a descriptor.
+function applyAuth(headers, desc, credentials) {
+  if (desc.combined) {
+    // combined providers always set the header (legacy behavior, incl. noAuth → "Bearer undefined")
+    setAuth(headers, desc, credentials.apiKey || credentials.accessToken);
+    if (desc.anthropicVersion && !headers["anthropic-version"]) headers["anthropic-version"] = ANTHROPIC_API_VERSION;
+    return;
+  }
+  // split apiKey/oauth: set only the matching branch (legacy: anthropic-compatible skips when both absent)
+  if (credentials.apiKey) setAuth(headers, desc.apiKey, credentials.apiKey);
+  else if (credentials.accessToken) setAuth(headers, desc.oauth, credentials.accessToken);
+  if (desc.anthropicVersion && !headers["anthropic-version"]) headers["anthropic-version"] = ANTHROPIC_API_VERSION;
+}
+
+// Provider-specific header quirks kept as small hooks (not pure auth).
+const HEADER_HOOKS = {
+  kimiHeaders: (h) => Object.assign(h, buildKimiHeaders()),
+  clineHeaders: (h, c) => Object.assign(h, buildClineHeaders(c.apiKey || c.accessToken)),
+  kilocodeOrg: (h, c) => { if (c.providerSpecificData?.orgId) h["X-Kilocode-OrganizationID"] = c.providerSpecificData.orgId; },
+  claudeOverlay: (h) => {
+    const cached = getCachedClaudeHeaders();
+    if (!cached) return;
+    for (const lcKey of Object.keys(cached)) {
+      const titleKey = lcKey.replace(/(^|-)([a-z])/g, (_, sep, ch) => sep + ch.toUpperCase());
+      if (lcKey === "anthropic-beta") {
+        const staticBetaStr = h[titleKey] || h[lcKey] || "";
+        const flags = new Set(staticBetaStr.split(",").map(f => f.trim()).filter(Boolean));
+        for (const f of cached[lcKey].split(",").map(f => f.trim()).filter(Boolean)) flags.add(f);
+        cached[lcKey] = Array.from(flags).join(",");
+      }
+      if (titleKey !== lcKey && h[titleKey] !== undefined) delete h[titleKey];
+    }
+    Object.assign(h, cached);
+  },
+};
+
+// Config-driven OAuth refresh grants — derived from registry oauth.refresh.
+const REFRESH_GRANTS = Object.fromEntries(
+  Object.entries(PROVIDER_OAUTH)
+    .filter(([, o]) => o.refresh)
+    .map(([id, o]) => {
+      const tokenUrl = o.tokenUrl;
+      const encoding = o.refresh.encoding;
+      const extraParams = o.refresh.scope ? { scope: o.refresh.scope } : {};
+      return [id, {
+        encoding,
+        url: () => tokenUrl,
+        params: (ex) => id === "gemini"
+          ? { client_id: ex.config.clientId, client_secret: ex.config.clientSecret, ...extraParams }
+          : { client_id: o.clientId, ...extraParams },
+      }];
+    })
+);
 
 export class DefaultExecutor extends BaseExecutor {
   constructor(provider) {
@@ -13,6 +83,15 @@ export class DefaultExecutor extends BaseExecutor {
 
   transformRequest(model, body) {
     const transformed = this.applyJsonSchemaFallback(body);
+
+    if (transformed && typeof transformed === "object") {
+      // quirk: some openai-compatible providers reject Anthropic's client_metadata field
+      if (this.config.quirks?.dropClientMetadata) {
+        delete transformed.client_metadata;
+      }
+      stripUnsupportedParams(this.provider, model, transformed);
+    }
+
     return injectReasoningContent({ provider: this.provider, model, body: transformed });
   }
 
@@ -37,126 +116,69 @@ export class DefaultExecutor extends BaseExecutor {
   }
 
   buildUrl(model, stream, urlIndex = 0, credentials = null) {
+    // Runtime transport (multi-endpoint providers): use the sourceFormat-matched endpoint
+    const rt = credentials?.runtimeTransport;
+    if (rt?.baseUrl) {
+      return rt.urlSuffix ? `${rt.baseUrl}${rt.urlSuffix}` : rt.baseUrl;
+    }
     if (this.provider?.startsWith?.("openai-compatible-")) {
-      const baseUrl = credentials?.providerSpecificData?.baseUrl || "https://api.openai.com/v1";
+      const baseUrl = credentials?.providerSpecificData?.baseUrl || OPENAI_COMPAT_BASE;
       const normalized = baseUrl.replace(/\/$/, "");
       const path = this.provider.includes("responses") ? "/responses" : "/chat/completions";
       return `${normalized}${path}`;
     }
     if (this.provider?.startsWith?.("anthropic-compatible-")) {
-      const baseUrl = credentials?.providerSpecificData?.baseUrl || "https://api.anthropic.com/v1";
+      const baseUrl = credentials?.providerSpecificData?.baseUrl || ANTHROPIC_COMPAT_BASE;
       const normalized = baseUrl.replace(/\/$/, "");
       return `${normalized}/messages`;
     }
-    switch (this.provider) {
-      case "claude":
-      case "glm":
-      case "kimi":
-      case "minimax":
-      case "minimax-cn":
-        return `${this.config.baseUrl}?beta=true`;
-      case "kimi-coding":
-        return `${this.config.baseUrl}?beta=true`;
-      case "gemini":
-        return `${this.config.baseUrl}/${model}:${stream ? "streamGenerateContent?alt=sse" : "generateContent"}`;
-      default: {
-        const url = this.config.baseUrl;
-        if (url?.includes("{accountId}")) {
-          const accountId = credentials?.providerSpecificData?.accountId;
-          if (!accountId) throw new Error(`${this.provider} requires accountId in providerSpecificData`);
-          return url.replace("{accountId}", accountId);
-        }
-        return url;
-      }
+    // gemini-format: build :streamGenerateContent / :generateContent path
+    if (this.config.format === "gemini") {
+      return `${this.config.baseUrl}/${model}:${stream ? "streamGenerateContent?alt=sse" : "generateContent"}`;
+    }
+    // urlSuffix (e.g. ?beta=true) declared per-provider in registry
+    if (this.config.urlSuffix) {
+      return `${this.config.baseUrl}${this.config.urlSuffix}`;
     }
+    const url = this.config.baseUrl;
+    if (url?.includes("{accountId}")) {
+      const accountId = credentials?.providerSpecificData?.accountId;
+      if (!accountId) throw new Error(`${this.provider} requires accountId in providerSpecificData`);
+      return url.replace("{accountId}", accountId);
+    }
+    return url;
   }
 
-  buildHeaders(credentials, stream = true) {
-    const headers = { "Content-Type": "application/json", ...this.config.headers };
-
-    switch (this.provider) {
-      case "gemini":
-        credentials.apiKey ? headers["x-goog-api-key"] = credentials.apiKey : headers["Authorization"] = `Bearer ${credentials.accessToken}`;
-        break;
-      case "claude": {
-        // Overlay live cached headers from real Claude Code client over static defaults.
-        // Static headers (Title-Case) remain as cold-start fallback.
-        const cached = getCachedClaudeHeaders();
-        if (cached) {
-          // Remove Title-Case static keys that conflict with incoming lowercase cached keys
-          for (const lcKey of Object.keys(cached)) {
-            // Build the Title-Case equivalent: "anthropic-version" → "Anthropic-Version"
-            const titleKey = lcKey.replace(/(^|-)([a-z])/g, (_, sep, c) => sep + c.toUpperCase());
-
-            // Special handling for Anthropic-Beta to preserve required flags like OAuth
-            if (lcKey === "anthropic-beta") {
-              const staticBetaStr = headers[titleKey] || headers[lcKey] || "";
-              const staticFlags = new Set(staticBetaStr.split(",").map(f => f.trim()).filter(Boolean));
-              const cachedFlags = new Set(cached[lcKey].split(",").map(f => f.trim()).filter(Boolean));
-
-              // Merge all static flags (which contain oauth, thinking, etc) into the cached ones
-              for (const flag of staticFlags) {
-                cachedFlags.add(flag);
-              }
-
-              cached[lcKey] = Array.from(cachedFlags).join(",");
-            }
-
-            if (titleKey !== lcKey && headers[titleKey] !== undefined) {
-              delete headers[titleKey];
-            }
-          }
-          Object.assign(headers, cached);
-        }
-        credentials.apiKey
-          ? (headers["x-api-key"] = credentials.apiKey)
-          : (headers["Authorization"] = `Bearer ${credentials.accessToken}`);
-        break;
-      }
-      case "glm":
-      case "kimi":
-      case "minimax":
-      case "minimax-cn":
-      case "kimi-coding":
-        headers["x-api-key"] = credentials.apiKey || credentials.accessToken;
-        if (this.provider === "kimi-coding") Object.assign(headers, buildKimiHeaders());
-        break;
-      default:
-        if (this.provider?.startsWith?.("anthropic-compatible-")) {
-          if (credentials.apiKey) {
-            headers["x-api-key"] = credentials.apiKey;
-          } else if (credentials.accessToken) {
-            headers["Authorization"] = `Bearer ${credentials.accessToken}`;
-          }
-          if (!headers["anthropic-version"]) {
-            headers["anthropic-version"] = "2023-06-01";
-          }
-        } else if (this.provider === "gitlab") {
-          // GitLab Duo uses Bearer token (PAT with ai_features scope, or OAuth access token)
-          headers["Authorization"] = `Bearer ${credentials.apiKey || credentials.accessToken}`;
-        } else if (this.provider === "codebuddy") {
-          headers["Authorization"] = `Bearer ${credentials.apiKey || credentials.accessToken}`;
-        } else if (this.provider === "kilocode") {
-          headers["Authorization"] = `Bearer ${credentials.apiKey || credentials.accessToken}`;
-          if (credentials.providerSpecificData?.orgId) {
-            headers["X-Kilocode-OrganizationID"] = credentials.providerSpecificData.orgId;
-          }
-        } else if (this.provider === "cline") {
-          Object.assign(headers, buildClineHeaders(credentials.apiKey || credentials.accessToken));
-        } else if (this.config?.format === "claude") {
-          // Generic claude-format provider (e.g. agentrouter): x-api-key + anthropic-version
-          headers["x-api-key"] = credentials.apiKey || credentials.accessToken;
-          if (!headers["anthropic-version"]) headers["anthropic-version"] = "2023-06-01";
-        } else {
-          headers["Authorization"] = `Bearer ${credentials.apiKey || credentials.accessToken}`;
-        }
+  // Fallback descriptor for providers without an explicit entry in AUTH_DESCRIPTORS.
+  resolveAuthDescriptor() {
+    if (this.provider?.startsWith?.("anthropic-compatible-")) {
+      return { apiKey: { header: "x-api-key", scheme: "raw" }, oauth: { header: "Authorization", scheme: "bearer" }, anthropicVersion: true };
+    }
+    if (this.config?.format === "claude") {
+      return { ...XAPIKEY, anthropicVersion: true };
     }
+    return BEARER;
+  }
+
+  buildHeaders(credentials, stream = true) {
+    const rt = credentials?.runtimeTransport;
+    const headers = { "Content-Type": "application/json", ...(rt ? rt.headers : this.config.headers) };
+    const desc = rt?.auth || AUTH_DESCRIPTORS[this.provider] || this.resolveAuthDescriptor();
+    // Hooks run BEFORE auth so dynamic overlays (claude cached headers) can't clobber the token.
+    for (const hook of desc.hooks || []) HEADER_HOOKS[hook]?.(headers, credentials);
+    applyAuth(headers, desc, credentials);
 
     // Strip first-party Claude Code identity headers for non-Anthropic anthropic-compatible upstreams
     if (this.provider?.startsWith?.("anthropic-compatible-")) {
       const baseUrl = credentials?.providerSpecificData?.baseUrl || "";
       const isOfficialAnthropic = baseUrl === "" || baseUrl.includes("api.anthropic.com");
       if (!isOfficialAnthropic) {
+        // Some third-party Anthropic-compatible gateways require Bearer auth in
+        // addition to x-api-key. Send both (x-api-key already set above) so
+        // gateways that read either header succeed.
+        if (credentials.apiKey && !headers["Authorization"]) {
+          headers["Authorization"] = `Bearer ${credentials.apiKey}`;
+        }
         delete headers["anthropic-dangerous-direct-browser-access"];
         delete headers["Anthropic-Dangerous-Direct-Browser-Access"];
         delete headers["x-app"];
@@ -183,17 +205,28 @@ export class DefaultExecutor extends BaseExecutor {
     return headers;
   }
 
+  // Generic OAuth refresh for the common {grant_type, refresh_token, client_id[, ...]} shape.
+  // grant = REFRESH_GRANTS[provider]; client creds resolved from PROVIDERS or this.config.
+  refreshFromGrant(credentials, proxyOptions) {
+    const grant = REFRESH_GRANTS[this.provider];
+    const params = { grant_type: "refresh_token", refresh_token: credentials.refreshToken, ...grant.params(this) };
+    return grant.encoding === "json"
+      ? this.refreshWithJSON(grant.url(), params, proxyOptions)
+      : this.refreshWithForm(grant.url(), params, proxyOptions);
+  }
+
   async refreshCredentials(credentials, log, proxyOptions = null) {
     if (!credentials.refreshToken) return null;
 
     const refreshers = {
-      claude: () => this.refreshWithJSON(OAUTH_ENDPOINTS.anthropic.token, { grant_type: "refresh_token", refresh_token: credentials.refreshToken, client_id: PROVIDERS.claude.clientId }, proxyOptions),
-      codex: () => this.refreshWithForm(OAUTH_ENDPOINTS.openai.token, { grant_type: "refresh_token", refresh_token: credentials.refreshToken, client_id: PROVIDERS.codex.clientId, scope: "openid profile email offline_access" }, proxyOptions),
+      claude: () => this.refreshFromGrant(credentials, proxyOptions),
+      codex: () => this.refreshFromGrant(credentials, proxyOptions),
       qwen: () => this.refreshWithForm(OAUTH_ENDPOINTS.qwen.token, { grant_type: "refresh_token", refresh_token: credentials.refreshToken, client_id: PROVIDERS.qwen.clientId }, proxyOptions),
       iflow: () => this.refreshIflow(credentials.refreshToken, proxyOptions),
-      gemini: () => this.refreshGoogle(credentials.refreshToken, proxyOptions),
+      gemini: () => this.refreshFromGrant(credentials, proxyOptions),
       kiro: () => this.refreshKiro(credentials.refreshToken, proxyOptions),
       cline: () => this.refreshCline(credentials.refreshToken, proxyOptions),
+      clinepass: () => this.refreshCline(credentials.refreshToken, proxyOptions),
       "kimi-coding": () => this.refreshKimiCoding(credentials.refreshToken, proxyOptions),
       kilocode: () => this.refreshKilocode(credentials.refreshToken, proxyOptions)
     };
@@ -245,17 +278,6 @@ export class DefaultExecutor extends BaseExecutor {
     return { accessToken: tokens.access_token, refreshToken: tokens.refresh_token || refreshToken, expiresIn: tokens.expires_in };
   }
 
-  async refreshGoogle(refreshToken, proxyOptions = null) {
-    const response = await proxyAwareFetch(OAUTH_ENDPOINTS.google.token, {
-      method: "POST",
-      headers: { "Content-Type": "application/x-www-form-urlencoded", "Accept": "application/json" },
-      body: new URLSearchParams({ grant_type: "refresh_token", refresh_token: refreshToken, client_id: this.config.clientId, client_secret: this.config.clientSecret })
-    }, proxyOptions);
-    if (!response.ok) return null;
-    const tokens = await response.json();
-    return { accessToken: tokens.access_token, refreshToken: tokens.refresh_token || refreshToken, expiresIn: tokens.expires_in };
-  }
-
   async refreshKiro(refreshToken, proxyOptions = null) {
     const response = await proxyAwareFetch(PROVIDERS.kiro.tokenUrl, {
       method: "POST",
@@ -268,37 +290,33 @@ export class DefaultExecutor extends BaseExecutor {
   }
 
   async refreshCline(refreshToken, proxyOptions = null) {
-    console.log('[DEBUG] Refreshing Cline token, refreshToken length:', refreshToken?.length);
-    const response = await proxyAwareFetch("https://api.cline.bot/api/v1/auth/refresh", {
+    const response = await proxyAwareFetch(PROVIDERS.cline.refreshUrl, {
       method: "POST",
       headers: { "Content-Type": "application/json", "Accept": "application/json" },
       body: JSON.stringify({ refreshToken, grantType: "refresh_token", clientType: "extension" })
     }, proxyOptions);
-    console.log('[DEBUG] Cline refresh response status:', response.status);
-    if (!response.ok) {
-      const errorText = await response.text();
-      console.log('[DEBUG] Cline refresh error:', errorText);
-      return null;
-    }
+    if (!response.ok) return null;
     const payload = await response.json();
-    console.log('[DEBUG] Cline refresh payload:', JSON.stringify(payload).substring(0, 200));
     const data = payload?.data || payload;
     const expiresAtIso = data?.expiresAt;
     const expiresIn = expiresAtIso ? Math.max(1, Math.floor((new Date(expiresAtIso).getTime() - Date.now()) / 1000)) : undefined;
-    console.log('[DEBUG] Cline refresh success, expiresIn:', expiresIn);
-    return { accessToken: data?.accessToken, refreshToken: data?.refreshToken || refreshToken, expiresIn };
+    let accessToken = data?.accessToken;
+    if (accessToken && !accessToken.startsWith("workos:")) {
+      accessToken = `workos:${accessToken}`;
+    }
+    return { accessToken, refreshToken: data?.refreshToken || refreshToken, expiresIn };
   }
 
   async refreshKimiCoding(refreshToken, proxyOptions = null) {
     const kimiHeaders = buildKimiHeaders();
-    const response = await proxyAwareFetch("https://auth.kimi.com/api/oauth/token", {
+    const response = await proxyAwareFetch(PROVIDERS["kimi-coding"].refreshUrl, {
       method: "POST",
       headers: {
         "Content-Type": "application/x-www-form-urlencoded",
         "Accept": "application/json",
         ...kimiHeaders
       },
-      body: new URLSearchParams({ grant_type: "refresh_token", refresh_token: refreshToken, client_id: "17e5f671-d194-4dfb-9706-5516cb48c098" })
+      body: new URLSearchParams({ grant_type: "refresh_token", refresh_token: refreshToken, client_id: PROVIDERS["kimi-coding"].clientId })
     }, proxyOptions);
     if (!response.ok) return null;
     const tokens = await response.json();

package/app/open-sse/executors/github.js

@@ -7,6 +7,8 @@ import { openaiResponsesToOpenAIResponse } from "../translator/response/openai-r
 import { initState } from "../translator/index.js";
 import { parseSSELine, formatSSE } from "../utils/streamHelpers.js";
 import { proxyAwareFetch } from "../utils/proxyFetch.js";
+import { stripUnsupportedParams } from "../translator/concerns/paramSupport.js";
+import { SSE_DONE } from "../utils/sseConstants.js";
 import crypto from "crypto";
 
 export class GithubExecutor extends BaseExecutor {
@@ -108,54 +110,18 @@ export class GithubExecutor extends BaseExecutor {
     return /gpt-5|o[134]-/i.test(model);
   }
 
-  // Some models (like gpt-5.4) don't support the temperature parameter
-  supportsTemperature(model) {
-    // gpt-5.4 and similar newer models don't support temperature
-    return !/gpt-5\.4/i.test(model);
-  }
-
-  // GitHub Copilot /chat/completions rejects Claude-style thinking payloads
-  // (OpenClaw sends thinking: { type: "enabled" } → upstream 400).
-  // GPT-5 family on Copilot DOES honor reasoning_effort, so only strip for Claude. (#713)
-  supportsThinking(model) {
-    return !/claude/i.test(model);
-  }
-
-  // reasoning_effort works for GPT-5 family AND Claude Opus 4.6 / Sonnet 4.6
-  // on GitHub Copilot. Only strip for models that don't support it:
-  // Claude Haiku 4.5, Claude Opus 4.7 (rejected upstream).
-  supportsReasoningEffort(model) {
-    const m = model.toLowerCase();
-    // Claude models that DO support reasoning_effort
-    if (/claude.*opus.*4\.6/i.test(m) || /claude.*sonnet.*4\.6/i.test(m)) return true;
-    // All other Claude models: strip
-    if (/claude/i.test(model)) return false;
-    // GPT-5 family, Gemini, etc.: keep
-    return true;
-  }
-
   transformRequest(model, body, stream, credentials) {
     const transformed = { ...body };
     if (this.requiresMaxCompletionTokens(model) && transformed.max_tokens !== undefined) {
       transformed.max_completion_tokens = transformed.max_tokens;
       delete transformed.max_tokens;
     }
-    // Strip temperature for models that don't support it
-    if (!this.supportsTemperature(model) && transformed.temperature !== undefined) {
-      delete transformed.temperature;
-    }
-    // Always strip Claude-style thinking payload (Copilot doesn't understand it)
-    if (!this.supportsThinking(model)) {
-      delete transformed.thinking;
-    }
     // "none" means no thinking — strip it so models that don't support "none" don't 400
     if (transformed.reasoning_effort === "none") {
       delete transformed.reasoning_effort;
     }
-    // Strip reasoning_effort only for models that reject it
-    if (!this.supportsReasoningEffort(model) && transformed.reasoning_effort !== undefined) {
-      delete transformed.reasoning_effort;
-    }
+    // Config-driven strip of params unsupported by this provider/model
+    stripUnsupportedParams("github", model, transformed);
     return transformed;
   }
 
@@ -244,7 +210,7 @@ export class GithubExecutor extends BaseExecutor {
           if (!parsed) continue;
 
           if (parsed.done && stream === true) {
-            controller.enqueue(new TextEncoder().encode("data: [DONE]\n\n"));
+            controller.enqueue(new TextEncoder().encode(SSE_DONE));
             continue;
           }
 

package/app/open-sse/executors/grok-web.js

@@ -1,5 +1,7 @@
 import { BaseExecutor } from "./base.js";
 import { PROVIDERS } from "../config/providers.js";
+import { SSE_DONE, SSE_HEADERS_NO_BUFFER } from "../utils/sseConstants.js";
+import { sseChunk } from "../utils/sse.js";
 
 const GROK_CHAT_API = PROVIDERS["grok-web"].baseUrl;
 const GROK_USER_AGENT = "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/136.0.0.0 Safari/537.36";
@@ -130,10 +132,6 @@ async function* extractContent(eventStream, isThinkingModel, signal) {
   yield { done: true, fingerprint, responseId };
 }
 
-function sseChunk(data) {
-  return `data: ${JSON.stringify(data)}\n\n`;
-}
-
 function buildStreamingResponse(eventStream, model, cid, created, isThinkingModel, signal) {
   const encoder = new TextEncoder();
   return new ReadableStream({
@@ -175,13 +173,13 @@ function buildStreamingResponse(eventStream, model, cid, created, isThinkingMode
           id: cid, object: "chat.completion.chunk", created, model, system_fingerprint: fp || null,
           choices: [{ index: 0, delta: {}, finish_reason: "stop", logprobs: null }],
         })));
-        controller.enqueue(encoder.encode("data: [DONE]\n\n"));
+        controller.enqueue(encoder.encode(SSE_DONE));
       } 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();
       }
@@ -333,7 +331,7 @@ export class GrokWebExecutor extends BaseExecutor {
       const sseStream = buildStreamingResponse(response.body, model, cid, created, isThinking, 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, isThinking, signal);

package/app/open-sse/executors/index.js

@@ -5,6 +5,7 @@ import { GithubExecutor } from "./github.js";
 import { IFlowExecutor } from "./iflow.js";
 import { QoderExecutor } from "./qoder.js";
 import { KiroExecutor } from "./kiro.js";
+import { KimchiExecutor } from "./kimchi.js";
 import { CodexExecutor } from "./codex.js";
 import { CursorExecutor } from "./cursor.js";
 import { VertexExecutor } from "./vertex.js";
@@ -16,6 +17,8 @@ import { PerplexityWebExecutor } from "./perplexity-web.js";
 import { OllamaLocalExecutor } from "./ollama-local.js";
 import { CommandCodeExecutor } from "./commandcode.js";
 import { XiaomiTokenplanExecutor } from "./xiaomi-tokenplan.js";
+import { MimoFreeExecutor } from "./mimo-free.js";
+import { CodeBuddyExecutor } from "./codebuddy-cn.js";
 import { DefaultExecutor } from "./default.js";
 
 const executors = {
@@ -26,6 +29,7 @@ const executors = {
   iflow: new IFlowExecutor(),
   qoder: new QoderExecutor(),
   kiro: new KiroExecutor(),
+  kimchi: new KimchiExecutor(),
   codex: new CodexExecutor(),
   cursor: new CursorExecutor(),
   cu: new CursorExecutor(), // Alias for cursor
@@ -39,6 +43,9 @@ const executors = {
   "ollama-local": new OllamaLocalExecutor(),
   commandcode: new CommandCodeExecutor(),
   "xiaomi-tokenplan": new XiaomiTokenplanExecutor(),
+  "mimo-free": new MimoFreeExecutor(),
+  mmf: new MimoFreeExecutor(), // Alias for mimo-free
+  "codebuddy-cn": new CodeBuddyExecutor(),
 };
 
 const defaultCache = new Map();
@@ -61,6 +68,7 @@ export { GithubExecutor } from "./github.js";
 export { IFlowExecutor } from "./iflow.js";
 export { QoderExecutor } from "./qoder.js";
 export { KiroExecutor } from "./kiro.js";
+export { KimchiExecutor } from "./kimchi.js";
 export { CodexExecutor } from "./codex.js";
 export { CursorExecutor } from "./cursor.js";
 export { VertexExecutor } from "./vertex.js";
@@ -73,3 +81,5 @@ export { PerplexityWebExecutor } from "./perplexity-web.js";
 export { OllamaLocalExecutor } from "./ollama-local.js";
 export { CommandCodeExecutor } from "./commandcode.js";
 export { XiaomiTokenplanExecutor } from "./xiaomi-tokenplan.js";
+export { MimoFreeExecutor } from "./mimo-free.js";
+export { CodeBuddyExecutor } from "./codebuddy-cn.js";

package/app/open-sse/executors/kimchi.js

@@ -0,0 +1,123 @@
+import { DefaultExecutor } from "./default.js";
+import { getCachedKimchiModelMetadata } from "../services/kimchiModels.js";
+
+const TOP_LEVEL_OPENAI_GATEWAY_DROPS = [
+  "anthropic_version",
+  "anthropic_beta",
+  "client_metadata",
+  "mcp_servers",
+  "stop_sequences",
+  "thinking",
+  "top_k",
+];
+
+function systemToText(system) {
+  if (typeof system === "string") return system;
+  if (Array.isArray(system)) {
+    return system
+      .map((part) => {
+        if (typeof part === "string") return part;
+        if (typeof part?.text === "string") return part.text;
+        return "";
+      })
+      .filter(Boolean)
+      .join("\n");
+  }
+  return "";
+}
+
+function mergeTopLevelSystem(body) {
+  if (!body?.system || !Array.isArray(body.messages)) return;
+  const text = systemToText(body.system).trim();
+  if (!text) return;
+
+  const existing = body.messages.find((msg) => msg?.role === "system");
+  if (!existing) {
+    body.messages.unshift({ role: "system", content: text });
+    return;
+  }
+
+  if (typeof existing.content === "string") {
+    existing.content = `${text}\n\n${existing.content}`;
+  } else if (Array.isArray(existing.content)) {
+    existing.content.unshift({ type: "text", text });
+  }
+}
+
+function stripMessageArtifacts(body) {
+  if (!Array.isArray(body?.messages)) return;
+  for (const msg of body.messages) {
+    if (!msg || typeof msg !== "object") continue;
+    delete msg.cache_control;
+    if (!Array.isArray(msg.content)) continue;
+    msg.content = msg.content.map((part) => {
+      if (!part || typeof part !== "object") return part;
+      const { cache_control, signature, ...clean } = part;
+      return clean;
+    });
+  }
+}
+
+function stripToolArtifacts(body) {
+  if (!Array.isArray(body?.tools)) return;
+  body.tools = body.tools.map((tool) => {
+    if (!tool || typeof tool !== "object") return tool;
+    const { cache_control, ...clean } = tool;
+    return clean;
+  });
+}
+
+// Strip `reasoning_content` echoed by clients on assistant messages — but
+// only when it's a real thinking block. `DefaultExecutor.transformRequest`
+// runs `injectReasoningContent` first and may inject a 1-char placeholder
+// (" ") for upstream validation; the placeholder is small (no token cost
+// worth stripping) and stripping it would re-trigger upstream to complain
+// about missing reasoning on the next turn. Threshold matches the
+// placeholder length with a safety margin.
+const REASONING_PLACEHOLDER_MAX_LEN = 8;
+
+export function stripReasoningContent(body) {
+  if (!Array.isArray(body?.messages)) return;
+  for (const msg of body.messages) {
+    if (msg && msg.role === "assistant" && typeof msg.reasoning_content === "string"
+        && msg.reasoning_content.length > REASONING_PLACEHOLDER_MAX_LEN) {
+      delete msg.reasoning_content;
+    }
+  }
+}
+
+function isAnthropicBackedKimchiModel(model) {
+  const meta = getCachedKimchiModelMetadata(model);
+  if (meta?.provider === "anthropic" || meta?.upstreamProvider === "anthropic") return true;
+  return /(^|[-_/])(?:claude|anthropic)(?:[-_/]|$)/i.test(String(model || ""));
+}
+
+export class KimchiExecutor extends DefaultExecutor {
+  constructor() {
+    super("kimchi");
+  }
+
+  transformRequest(model, body, stream, credentials) {
+    const transformed = super.transformRequest(model, body, stream, credentials);
+    if (!transformed || typeof transformed !== "object") return transformed;
+
+    mergeTopLevelSystem(transformed);
+    for (const key of TOP_LEVEL_OPENAI_GATEWAY_DROPS) {
+      if (transformed[key] !== undefined) delete transformed[key];
+    }
+    delete transformed.system;
+
+    if (isAnthropicBackedKimchiModel(model)) {
+      delete transformed.reasoning_effort;
+      delete transformed.reasoning;
+      delete transformed.thinking;
+    }
+
+    stripMessageArtifacts(transformed);
+    stripToolArtifacts(transformed);
+    stripReasoningContent(transformed);
+    return transformed;
+  }
+}
+
+export default KimchiExecutor;