yingclaw 2.5.20 → 2.5.26

package/index.js

@@ -4,5 +4,7 @@ module.exports = {
   ...require('./lib/desktop'),
   ...require('./lib/gateway'),
   ...require('./lib/install'),
+  ...require('./lib/openai'),
   ...require('./lib/panel'),
+  ...require('./lib/vscode'),
 };

package/lib/config.js

@@ -2,6 +2,7 @@ const fs = require('fs');
 const path = require('path');
 const os = require('os');
 const { spawnSync } = require('child_process');
+const { normalizeOpenAiBaseUrl, openAiChatCompletionsUrl } = require('./openai');
 
 const CONFIG_FILE = path.join(os.homedir(), '.clawai.json');
 const WINDOWS_ENV_LABEL = 'Windows 用户环境变量';
@@ -15,10 +16,17 @@ const CLAUDE_ENV_KEYS = [
   'CLAUDE_CODE_SUBAGENT_MODEL',
   'CLAUDE_CODE_EFFORT_LEVEL',
 ];
+const VSCODE_CLAUDE_ENV_KEYS = [
+  'ANTHROPIC_CUSTOM_MODEL_OPTION',
+  'ANTHROPIC_CUSTOM_MODEL_OPTION_NAME',
+  'ANTHROPIC_CUSTOM_MODEL_OPTION_DESCRIPTION',
+  'ANTHROPIC_CUSTOM_MODEL_OPTION_SUPPORTED_CAPABILITIES',
+  'CLAUDE_CODE_ENABLE_GATEWAY_MODEL_DISCOVERY',
+];
 const LEGACY_CLAUDE_ENV_KEYS = [
   'ANTHROPIC_API_KEY',
 ];
-const CLEAR_CLAUDE_ENV_KEYS = [...new Set([...CLAUDE_ENV_KEYS, ...LEGACY_CLAUDE_ENV_KEYS])];
+const CLEAR_CLAUDE_ENV_KEYS = [...new Set([...CLAUDE_ENV_KEYS, ...VSCODE_CLAUDE_ENV_KEYS, ...LEGACY_CLAUDE_ENV_KEYS])];
 
 const PROVIDERS = {
   deepseek: {
@@ -33,13 +41,27 @@ const PROVIDERS = {
   },
   kimi: {
     name: 'Kimi / Moonshot',
-    baseUrl: 'https://api.moonshot.ai/anthropic',
-    modelsUrl: 'https://api.moonshot.ai/v1/models',
+    protocol: 'openai',
+    baseUrl: 'https://api.moonshot.cn/v1',
+    modelsUrl: 'https://api.moonshot.cn/v1/models',
     fastModel: 'kimi-k2.5',
     models: [
       { name: 'Kimi K2.5（代码）', value: 'kimi-k2.5' },
     ],
   },
+  volcengine: {
+    name: '火山方舟 Coding Plan',
+    baseUrl: 'https://ark.cn-beijing.volces.com/api/coding',
+    modelsUrl: 'https://ark.cn-beijing.volces.com/api/coding/v3/models',
+    fastModel: 'ark-code-latest',
+    models: [
+      { name: 'Ark Code Latest（控制台选择）', value: 'ark-code-latest' },
+      { name: 'Doubao Seed Code', value: 'doubao-seed-code' },
+      { name: 'GLM 4.7', value: 'glm-4.7' },
+      { name: 'DeepSeek V3.2', value: 'deepseek-v3.2' },
+      { name: 'Kimi K2.5', value: 'kimi-k2.5' },
+    ],
+  },
   qwen: {
     name: '阿里云百炼 (Qwen)',
     baseUrl: 'https://dashscope.aliyuncs.com/apps/anthropic',
@@ -87,9 +109,76 @@ const PROVIDERS = {
       { name: 'MiMo V2 Flash（快速）', value: 'mimo-v2-flash' },
     ],
   },
+  bai: {
+    name: 'B.AI',
+    baseUrl: 'https://api.b.ai',
+    modelsUrl: 'https://api.b.ai/v1/models',
+    fastModel: 'claude-haiku-4.5',
+    models: [
+      { name: 'Claude Sonnet 4.6（推荐）', value: 'claude-sonnet-4.6' },
+      { name: 'Claude Opus 4.7（强力）',   value: 'claude-opus-4.7' },
+      { name: 'Claude Haiku 4.5（快速）',  value: 'claude-haiku-4.5' },
+      { name: 'DeepSeek V4 Pro',           value: 'deepseek-v4-pro' },
+      { name: 'GLM-5.1',                   value: 'glm-5.1' },
+      { name: 'MiniMax M2.7',              value: 'minimax-m2.7' },
+    ],
+  },
+  opencode_zen: {
+    name: 'OpenCode Zen（按量）',
+    protocol: 'openai',
+    baseUrl: 'https://opencode.ai/zen',
+    modelsUrl: 'https://opencode.ai/zen/v1/models',
+    fastModel: 'deepseek-v4-flash-free',
+    models: [
+      { name: 'Claude Sonnet 4.6（推荐）',   value: 'claude-sonnet-4-6' },
+      { name: 'Claude Opus 4.7（强力）',     value: 'claude-opus-4-7' },
+      { name: 'Claude Haiku 4.5（快速）',    value: 'claude-haiku-4-5' },
+      { name: 'GLM 5.1',                     value: 'glm-5.1' },
+      { name: 'MiniMax M2.7',                value: 'minimax-m2.7' },
+      { name: 'Kimi K2.5',                   value: 'kimi-k2.5' },
+      { name: 'DeepSeek V4 Flash（免费）',   value: 'deepseek-v4-flash-free' },
+    ],
+  },
+  opencode_go: {
+    name: 'OpenCode Go（订阅制）',
+    protocol: 'openai',
+    baseUrl: 'https://opencode.ai/zen/go',
+    modelsUrl: 'https://opencode.ai/zen/go/v1/models',
+    fastModel: 'deepseek-v4-flash',
+    models: [
+      { name: 'GLM-5.1',                     value: 'glm-5.1' },
+      { name: 'Kimi K2.5',                   value: 'kimi-k2.5' },
+      { name: 'DeepSeek V4 Pro（强力）',     value: 'deepseek-v4-pro' },
+      { name: 'DeepSeek V4 Flash（快速）',   value: 'deepseek-v4-flash' },
+      { name: 'MiniMax M2.7',                value: 'minimax-m2.7' },
+      { name: 'MiniMax M2.5',                value: 'minimax-m2.5' },
+      { name: 'MiMo V2.5 Pro',               value: 'mimo-v2.5-pro' },
+      { name: 'Qwen3.6 Plus',                value: 'qwen3.6-plus' },
+    ],
+  },
+  openrouter: {
+    name: 'OpenRouter',
+    protocol: 'openai',
+    baseUrl: 'https://openrouter.ai/api/v1',
+    modelsUrl: 'https://openrouter.ai/api/v1/models',
+    fastModel: 'deepseek/deepseek-chat-v3-0324',
+    models: [
+      { name: 'DeepSeek R1 0528（推理）',    value: 'deepseek/deepseek-r1-0528' },
+      { name: 'DeepSeek Chat V3（快速）',    value: 'deepseek/deepseek-chat-v3-0324' },
+      { name: 'Gemini 2.5 Pro（Google）',   value: 'google/gemini-2.5-pro' },
+      { name: 'Claude Sonnet 4.5（Anthropic）', value: 'anthropic/claude-sonnet-4-5' },
+    ],
+  },
   custom: {
     name: '自定义 Anthropic 兼容接口',
     custom: true,
+    protocol: 'anthropic',
+    models: [],
+  },
+  custom_openai: {
+    name: '自定义 OpenAI 兼容接口',
+    custom: true,
+    protocol: 'openai',
     models: [],
   },
 };
@@ -99,6 +188,8 @@ const PREFERRED_MODEL_IDS = {
   minimax: ['MiniMax-M2.7', 'MiniMax-M2.7-Turbo', 'MiniMax-M2.5'],
   glm: ['GLM-4.7', 'GLM-5.1', 'GLM-5-Turbo', 'GLM-4.5-Air'],
   mimo: ['mimo-v2.5-pro', 'mimo-v2.5', 'mimo-v2-flash'],
+  opencode_zen: ['claude-sonnet-4-6', 'claude-opus-4-7', 'claude-haiku-4-5', 'deepseek-v4-flash-free'],
+  opencode_go: ['glm-5.1', 'deepseek-v4-pro', 'deepseek-v4-flash'],
 };
 
 function sortPreferredModelIds(providerKey, ids) {
@@ -110,11 +201,28 @@ function sortPreferredModelIds(providerKey, ids) {
   ];
 }
 
+function isChatModelId(model) {
+  const value = String(model || '');
+  return !/(^|[-_])(tts|voice|voiceclone|voicedesign|speech|audio|image|video|embedding|embed|rerank|moderation)([-_]|$)/i.test(value)
+    && !/(^|[-_])(i2v|t2v|t2i|i2i|v2v|video-generation|image-generation)([-_]|$)/i.test(value)
+    && !/(cogview|cogvideo|wanx|^wan\d|seedance|seedream|seededit|vision|hyper3d|hitem3d|seed3d|flux|sdxl|stable-diffusion|dall-e|whisper)/i.test(value);
+}
+
 function normalizeModelIds(providerKey, ids) {
   if (PREFERRED_MODEL_IDS[providerKey]) {
     return sortPreferredModelIds(providerKey, ids);
   }
 
+  if (providerKey === 'kimi') {
+    const preferred = PROVIDERS.kimi.models.map((item) => item.value);
+    const merged = [...new Set([...preferred, ...ids])];
+    return [
+      ...preferred.filter((id) => merged.includes(id)),
+      ...merged.filter((id) => !preferred.includes(id) && /^kimi-/i.test(id)),
+      ...merged.filter((id) => !preferred.includes(id) && !/^kimi-/i.test(id)),
+    ];
+  }
+
   if (providerKey !== 'deepseek') return ids;
 
   const mapped = ids.map((id) => {
@@ -132,7 +240,16 @@ function normalizeModelIds(providerKey, ids) {
 function parseModelIdsResponse(providerKey, data) {
   const parsed = typeof data === 'string' ? JSON.parse(data) : data;
   const list = parsed.data || parsed.models || [];
-  const ids = list.map(m => m.id || m.model || m.name).filter(Boolean);
+  const availableList = providerKey === 'volcengine'
+    ? list.filter((model) => !/^shutdown$/i.test(String(model.status || '')))
+    : list;
+  const ids = availableList.map(m => m.id || m.model || m.name).filter(Boolean);
+  if (providerKey === 'volcengine') {
+    return normalizeModelIds(providerKey, ids.filter(isChatModelId));
+  }
+  if (providerKey === 'bai') {
+    return normalizeModelIds(providerKey, ids.filter(id => !id.includes('/')));
+  }
   return normalizeModelIds(providerKey, ids);
 }
 
@@ -155,7 +272,7 @@ function normalizeAnthropicBaseUrl(baseUrl) {
 
 function buildModelUrlCandidates(baseUrl) {
   let url;
-  try { url = new URL(normalizeAnthropicBaseUrl(baseUrl)); } catch { return []; }
+  try { url = new URL(normalizeAnthropicBaseUrl(normalizeOpenAiBaseUrl(baseUrl))); } catch { return []; }
 
   const pathname = url.pathname.replace(/\/+$/, '');
   const candidates = [];
@@ -209,10 +326,7 @@ async function fetchModels(providerKey, apiKey, modelsUrlOverride) {
     const res = await fetch(modelsUrl, {
       method: 'GET',
       signal: controller.signal,
-      headers: {
-        authorization: `Bearer ${apiKey}`,
-        'api-key': apiKey, // MiMo 用这个 header
-      },
+      headers: buildProviderAuthHeaders(providerKey, apiKey),
     });
     if (!res.ok) return null;
 
@@ -225,9 +339,22 @@ async function fetchModels(providerKey, apiKey, modelsUrlOverride) {
   }
 }
 
-function loadConfig() {
+function migrateConfig(config) {
+  if (!config || typeof config !== 'object') return config;
+  if (config.provider === 'kimi') {
+    return {
+      ...config,
+      protocol: 'openai',
+      baseUrl: PROVIDERS.kimi.baseUrl,
+      modelsUrl: PROVIDERS.kimi.modelsUrl,
+    };
+  }
+  return config;
+}
+
+function loadConfig(options = {}) {
   try {
-    return JSON.parse(fs.readFileSync(CONFIG_FILE, 'utf8'));
+    return migrateConfig(JSON.parse(fs.readFileSync(options.configFile || CONFIG_FILE, 'utf8')));
   } catch {
     return null;
   }
@@ -259,16 +386,54 @@ function providerKeyFromBaseUrl(baseUrl) {
   return Object.entries(PROVIDERS).find(([, provider]) => provider.baseUrl === baseUrl)?.[0];
 }
 
+function getProviderProtocol(config = {}) {
+  return config.protocol || PROVIDERS[config.provider]?.protocol || 'anthropic';
+}
+
+function buildProviderAuthHeaders(providerKey, apiKey) {
+  const headers = { authorization: `Bearer ${apiKey}` };
+  if (getProviderProtocol({ provider: providerKey }) !== 'openai') {
+    headers['api-key'] = apiKey; // MiMo 用这个 header
+  }
+  return headers;
+}
+
 function resolveFastModel(provider, model) {
   if (/flash|turbo|haiku|air|lite/i.test(model)) return model;
   return provider?.fastModel || model;
 }
 
-function buildClaudeEnv({ provider, baseUrl, apiKey, model, fastModel }) {
+function getModelFamily(model) {
+  const value = String(model || '').trim().toLowerCase();
+  if (!value) return '';
+  const normalized = value
+    .replace(/^anthropic\//, '')
+    .replace(/^\w+\//, '');
+  return normalized.split(/[-_.]/).filter(Boolean)[0] || normalized;
+}
+
+function sortRelatedModelIds(ids, mainModel) {
+  const unique = [...new Set(ids.filter(Boolean))];
+  const family = getModelFamily(mainModel);
+  return [
+    ...unique.filter((id) => id === mainModel),
+    ...unique.filter((id) => id !== mainModel && getModelFamily(id) === family),
+    ...unique.filter((id) => id !== mainModel && getModelFamily(id) !== family),
+  ];
+}
+
+function buildGatewayBaseUrlForEnv(config) {
+  const port = Number.parseInt(config.desktopGatewayPort || 18080, 10);
+  return `http://127.0.0.1:${port}/yingclaw`;
+}
+
+function buildClaudeEnv(config) {
+  const { provider, baseUrl, apiKey, model, fastModel } = config;
   const resolvedFastModel = fastModel || resolveFastModel(PROVIDERS[provider], model);
+  const useLocalGateway = getProviderProtocol(config) === 'openai' && config.desktopGatewayKey;
   return {
-    ANTHROPIC_BASE_URL: baseUrl,
-    ANTHROPIC_AUTH_TOKEN: apiKey,
+    ANTHROPIC_BASE_URL: useLocalGateway ? buildGatewayBaseUrlForEnv(config) : baseUrl,
+    ANTHROPIC_AUTH_TOKEN: useLocalGateway ? config.desktopGatewayKey : apiKey,
     ANTHROPIC_MODEL: model,
     ANTHROPIC_DEFAULT_OPUS_MODEL: model,
     ANTHROPIC_DEFAULT_SONNET_MODEL: model,
@@ -303,15 +468,19 @@ function runWindowsEnvCommands(commands, runner = spawnSync, { ignoreErrors = fa
 
 function classifyValidationStatus(statusCode) {
   if (statusCode >= 200 && statusCode < 300) return true;
+  if (statusCode === 429) return true; // 限流 = Key 有效
   if (statusCode === 401 || statusCode === 403) return false;
   return null;
 }
 
 // 发一次最小的 /v1/messages 请求验证 Key（true=有效, false=无效, null=网络/服务异常）
 async function validateKey(config, options = {}) {
+  const protocol = getProviderProtocol(config);
   let url;
   try {
-    url = `${normalizeAnthropicBaseUrl(config.baseUrl)}/v1/messages`;
+    url = protocol === 'openai'
+      ? openAiChatCompletionsUrl(config.baseUrl)
+      : `${normalizeAnthropicBaseUrl(config.baseUrl)}/v1/messages`;
     new URL(url);
   } catch {
     return null;
@@ -325,14 +494,12 @@ async function validateKey(config, options = {}) {
       signal: controller.signal,
       headers: {
         'content-type': 'application/json',
-        authorization: `Bearer ${config.apiKey}`,
-        'x-api-key': config.apiKey,
-        'api-key': config.apiKey,
-        'anthropic-version': '2023-06-01',
+        ...buildProviderAuthHeaders(config.provider, config.apiKey),
+        ...(protocol === 'anthropic' ? { 'x-api-key': config.apiKey, 'anthropic-version': '2023-06-01' } : {}),
       },
       body: JSON.stringify({
         model: config.model,
-        max_tokens: 1,
+        max_tokens: 16,
         messages: [{ role: 'user', content: 'hi' }],
       }),
     });
@@ -465,6 +632,11 @@ module.exports = {
   buildModelUrlCandidates,
   fetchModelsFromBaseUrl,
   resolveFastModel,
+  getModelFamily,
+  sortRelatedModelIds,
+  isChatModelId,
+  buildProviderAuthHeaders,
+  getProviderProtocol,
   providerKeyFromBaseUrl,
   buildClaudeEnv,
   buildEnvBlock,
@@ -473,5 +645,6 @@ module.exports = {
   PROVIDERS,
   CONFIG_FILE,
   CLAUDE_ENV_KEYS,
+  VSCODE_CLAUDE_ENV_KEYS,
   CLEAR_CLAUDE_ENV_KEYS,
 };

package/lib/doctor.js

@@ -12,6 +12,7 @@ const {
   CLAUDE_ENV_KEYS,
 } = require('./config');
 const { isDesktopConfigured } = require('./desktop');
+const { checkClaudeCodeSettingsEnv } = require('./vscode');
 
 const STATUS_OK = 'ok';
 const STATUS_FAIL = 'fail';
@@ -104,7 +105,16 @@ async function runDoctorChecks(options = {}) {
       : (platform === 'win32' ? '重新打开 PowerShell / CMD' : '运行 source ~/.zshrc 或重开终端'),
   });
 
-  // 6. API Key（顺便确认网络可达）
+  // 6. VS Code / Claude Code 扩展共享设置
+  const vscodeSettings = checkClaudeCodeSettingsEnv(config, options);
+  checks.push({
+    name: 'VS Code Claude Code',
+    status: vscodeSettings.configured ? STATUS_OK : STATUS_WARN,
+    message: vscodeSettings.configured ? 'VS Code 扩展设置已配置' : `${vscodeSettings.missing.length} 项配置未写入 VS Code 扩展设置`,
+    fix: vscodeSettings.configured ? null : '运行 claw vscode，并重启 VS Code',
+  });
+
+  // 7. API Key（顺便确认网络可达）
   const valid = await validateKey(config, { timeoutMs: 6000 });
   if (valid === true) {
     checks.push({ name: 'API Key', status: STATUS_OK, message: '校验通过' });
@@ -124,7 +134,7 @@ async function runDoctorChecks(options = {}) {
     });
   }
 
-  // 7. Claude 桌面应用接入状态
+  // 8. Claude 桌面应用接入状态
   const desktopConfigured = isDesktopConfigured();
   checks.push({
     name: 'Claude 桌面应用',
@@ -132,7 +142,7 @@ async function runDoctorChecks(options = {}) {
     message: desktopConfigured ? '已通过 yingclaw 接入' : '未接入（如需运行 claw desktop）',
   });
 
-  // 8. DeepSeek 旧模型名提醒
+  // 9. DeepSeek 旧模型名提醒
   if (config.provider === 'deepseek' && (
     config.model === 'deepseek-v4-pro' ||
     config.model === 'deepseek-v4-flash' ||

package/lib/gateway.js

@@ -1,6 +1,18 @@
 const crypto = require('crypto');
 const http = require('http');
-const { loadConfig: defaultLoadConfig, normalizeAnthropicBaseUrl } = require('./config');
+const {
+  loadConfig: defaultLoadConfig,
+  normalizeAnthropicBaseUrl,
+  buildProviderAuthHeaders,
+  getProviderProtocol,
+  isChatModelId,
+} = require('./config');
+const {
+  anthropicToOpenAiChatRequest,
+  openAiChatCompletionsUrl,
+  openAiStreamChunkToAnthropicEvents,
+  openAiToAnthropicMessage,
+} = require('./openai');
 
 const DEFAULT_DESKTOP_GATEWAY_PORT = 18080;
 const YINGCLAW_GATEWAY_PREFIX = '/yingclaw';
@@ -59,9 +71,26 @@ function desktopRouteLabel(routeId) {
 }
 
 function isDesktopChatModel(model) {
-  const value = String(model || '');
-  return !/(^|[-_])(tts|voice|voiceclone|voicedesign|speech|audio|image|video|embedding|embed|rerank|moderation)([-_]|$)/i.test(value)
-    && !/(cogview|cogvideo|wanx|flux|sdxl|stable-diffusion)/i.test(value);
+  return isChatModelId(model);
+}
+
+function isNativeClaudeModel(modelId) {
+  return /^claude-/i.test(String(modelId || ''));
+}
+
+function stripThinkingFromBody(body) {
+  const cleaned = { ...body };
+  delete cleaned.thinking;
+  if (Array.isArray(cleaned.messages)) {
+    cleaned.messages = cleaned.messages.map((msg) => {
+      if (!Array.isArray(msg.content)) return msg;
+      const content = msg.content.filter(
+        (block) => block.type !== 'thinking' && block.type !== 'redacted_thinking',
+      );
+      return { ...msg, content: content.length > 0 ? content : [{ type: 'text', text: '' }] };
+    });
+  }
+  return cleaned;
 }
 
 function buildDesktopGatewayRoutes(config) {
@@ -93,6 +122,13 @@ function buildDesktopGatewayMappingRows(config) {
 
 function mapDesktopRouteToUpstream(config, routeId) {
   const requested = stripOneMContextSuffix(routeId);
+  const configuredModels = [
+    config.model,
+    config.fastModel || config.model,
+    ...(Array.isArray(config.availableModels) ? config.availableModels : []),
+  ].filter(Boolean);
+  if (configuredModels.includes(routeId)) return routeId;
+
   const route = buildDesktopGatewayRoutes(config).find((item) => stripOneMContextSuffix(item.id) === requested);
   if (!route) {
     throw new Error(`未配置的 Claude Desktop 模型路由: ${routeId}`);
@@ -147,6 +183,10 @@ function providerMessagesUrl(config) {
   return `${normalizeAnthropicBaseUrl(config.baseUrl)}/v1/messages`;
 }
 
+function providerOpenAiChatUrl(config) {
+  return openAiChatCompletionsUrl(config.baseUrl);
+}
+
 function buildDesktopGatewayUrl(config = {}) {
   const port = Number.parseInt(config.desktopGatewayPort || DEFAULT_DESKTOP_GATEWAY_PORT, 10);
   return {
@@ -203,14 +243,22 @@ async function proxyMessages(req, res, config) {
     return;
   }
 
+  if (!isNativeClaudeModel(body.model)) {
+    body = stripThinkingFromBody(body);
+  }
+
+  if (getProviderProtocol(config) === 'openai') {
+    await proxyOpenAiMessages(res, config, body);
+    return;
+  }
+
   const upstream = await fetch(providerMessagesUrl(config), {
     method: 'POST',
     headers: {
       'content-type': 'application/json',
       accept: body.stream ? 'text/event-stream' : 'application/json',
-      authorization: `Bearer ${config.apiKey}`,
+      ...buildProviderAuthHeaders(config.provider, config.apiKey),
       'x-api-key': config.apiKey,
-      'api-key': config.apiKey,
       'anthropic-version': '2023-06-01',
     },
     body: JSON.stringify(body),
@@ -231,6 +279,89 @@ async function proxyMessages(req, res, config) {
   res.end();
 }
 
+async function proxyOpenAiMessages(res, config, body) {
+  const openAiBody = anthropicToOpenAiChatRequest(body);
+  const upstream = await fetch(providerOpenAiChatUrl(config), {
+    method: 'POST',
+    headers: {
+      'content-type': 'application/json',
+      accept: body.stream ? 'text/event-stream' : 'application/json',
+      ...buildProviderAuthHeaders(config.provider, config.apiKey),
+    },
+    body: JSON.stringify(openAiBody),
+  });
+
+  if (!body.stream) {
+    const text = await upstream.text();
+    if (!upstream.ok) {
+      res.writeHead(upstream.status, {
+        'content-type': upstream.headers.get('content-type') || 'application/json',
+      });
+      res.end(text);
+      return;
+    }
+
+    let parsed;
+    try {
+      parsed = text ? JSON.parse(text) : {};
+    } catch {
+      sendJson(res, 502, { error: { message: 'OpenAI 兼容接口返回了无效 JSON' } });
+      return;
+    }
+    sendJson(res, upstream.status, openAiToAnthropicMessage(parsed, body.model));
+    return;
+  }
+
+  res.writeHead(upstream.status, {
+    'content-type': upstream.ok ? 'text/event-stream' : (upstream.headers.get('content-type') || 'application/json'),
+    'cache-control': 'no-cache',
+  });
+  if (!upstream.body) {
+    res.end();
+    return;
+  }
+  if (!upstream.ok) {
+    for await (const chunk of upstream.body) res.write(chunk);
+    res.end();
+    return;
+  }
+
+  const state = { model: body.model, started: false, finished: false };
+  let buffer = '';
+  const decoder = new TextDecoder();
+
+  function processFrames(frames) {
+    for (const frame of frames) {
+      const dataLine = frame.split(/\n/).find((line) => line.startsWith('data:'));
+      if (!dataLine) continue;
+      const payload = dataLine.slice('data:'.length).trim();
+      if (!payload || payload === '[DONE]') continue;
+      let parsed;
+      try {
+        parsed = JSON.parse(payload);
+      } catch {
+        continue;
+      }
+      res.write(openAiStreamChunkToAnthropicEvents(parsed, state));
+    }
+  }
+
+  for await (const chunk of upstream.body) {
+    buffer += decoder.decode(chunk, { stream: true });
+    const frames = buffer.split(/\n\n/);
+    buffer = frames.pop() || '';
+    processFrames(frames);
+  }
+  // flush any remaining buffer content not terminated by \n\n
+  if (buffer.trim()) {
+    processFrames([buffer]);
+  }
+  if (!state.finished) {
+    res.write(openAiStreamChunkToAnthropicEvents({ model: body.model, choices: [{ delta: {}, finish_reason: 'stop' }] }, state));
+  }
+  res.end();
+}
+
 function createGatewayServer(options = {}) {
   const loadConfig = options.loadConfig || defaultLoadConfig;
   return http.createServer(async (req, res) => {