yingclaw 2.5.19 → 2.5.25

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',
@@ -90,6 +112,13 @@ const PROVIDERS = {
   custom: {
     name: '自定义 Anthropic 兼容接口',
     custom: true,
+    protocol: 'anthropic',
+    models: [],
+  },
+  custom_openai: {
+    name: '自定义 OpenAI 兼容接口',
+    custom: true,
+    protocol: 'openai',
     models: [],
   },
 };
@@ -110,11 +139,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)/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 +178,13 @@ 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));
+  }
   return normalizeModelIds(providerKey, ids);
 }
 
@@ -155,7 +207,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 +261,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 +274,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 +321,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,
@@ -311,7 +411,9 @@ function classifyValidationStatus(statusCode) {
 async function validateKey(config, options = {}) {
   let url;
   try {
-    url = `${normalizeAnthropicBaseUrl(config.baseUrl)}/v1/messages`;
+    url = getProviderProtocol(config) === 'openai'
+      ? openAiChatCompletionsUrl(config.baseUrl)
+      : `${normalizeAnthropicBaseUrl(config.baseUrl)}/v1/messages`;
     new URL(url);
   } catch {
     return null;
@@ -325,16 +427,21 @@ 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),
+        ...(getProviderProtocol(config) === 'anthropic' ? { 'x-api-key': config.apiKey } : {}),
+        ...(getProviderProtocol(config) === 'anthropic' ? { 'anthropic-version': '2023-06-01' } : {}),
       },
-      body: JSON.stringify({
-        model: config.model,
-        max_tokens: 1,
-        messages: [{ role: 'user', content: 'hi' }],
-      }),
+      body: JSON.stringify(getProviderProtocol(config) === 'openai'
+        ? {
+            model: config.model,
+            max_tokens: 1,
+            messages: [{ role: 'user', content: 'hi' }],
+          }
+        : {
+            model: config.model,
+            max_tokens: 1,
+            messages: [{ role: 'user', content: 'hi' }],
+          }),
     });
     return classifyValidationStatus(res.status);
   } catch {
@@ -465,6 +572,11 @@ module.exports = {
   buildModelUrlCandidates,
   fetchModelsFromBaseUrl,
   resolveFastModel,
+  getModelFamily,
+  sortRelatedModelIds,
+  isChatModelId,
+  buildProviderAuthHeaders,
+  getProviderProtocol,
   providerKeyFromBaseUrl,
   buildClaudeEnv,
   buildEnvBlock,
@@ -473,5 +585,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 ? '共享 settings.json 已写入' : `${vscodeSettings.missing.length} 个变量未写入共享设置`,
+    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,7 @@ 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 buildDesktopGatewayRoutes(config) {
@@ -93,6 +103,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 +164,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 +224,18 @@ async function proxyMessages(req, res, config) {
     return;
   }
 
+  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 +256,80 @@ 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();
+  for await (const chunk of upstream.body) {
+    buffer += decoder.decode(chunk, { stream: true });
+    const frames = buffer.split(/\n\n/);
+    buffer = frames.pop() || '';
+    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));
+    }
+  }
+  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) => {

package/lib/install.js

@@ -8,6 +8,44 @@ function buildClaudeInstallCommand(network) {
   return { command: 'npm', args };
 }
 
+function buildYingclawUpgradeCommand(network) {
+  const args = ['install', '-g', 'yingclaw@latest'];
+  if (network === 'cn') {
+    args.push('--registry=https://registry.npmmirror.com');
+  }
+  return { command: 'npm', args };
+}
+
+function quoteWindowsBatchArg(value) {
+  return `"${String(value).replace(/"/g, '""')}"`;
+}
+
+function buildWindowsYingclawUpgradeScript(network) {
+  const { command, args } = buildYingclawUpgradeCommand(network);
+  const commandLine = [command, ...args].map(quoteWindowsBatchArg).join(' ');
+  return [
+    '@echo off',
+    'chcp 65001 >nul',
+    'echo yingclaw Windows updater',
+    'echo.',
+    'echo 当前 claw 进程退出后开始升级，避免 Windows 文件锁 EBUSY...',
+    'timeout /t 2 /nobreak >nul',
+    commandLine,
+    'set "code=%ERRORLEVEL%"',
+    'echo.',
+    'if "%code%"=="0" (',
+    '  echo yingclaw 更新完成，请重新运行 claw',
+    ') else (',
+    '  echo yingclaw 更新失败，错误码 %code%',
+    `  echo 请手动运行: ${commandLine}`,
+    ')',
+    'echo.',
+    'pause',
+    'del "%~f0" >nul 2>nul',
+    '',
+  ].join('\r\n');
+}
+
 function checkNodeEnv() {
   const nodeVersion = process.versions.node;
   const nodeMajor = parseInt(nodeVersion.split('.')[0], 10);
@@ -91,4 +129,11 @@ function getInstallFailureHints(result, chalk) {
   ];
 }
 
-module.exports = { buildClaudeInstallCommand, checkNodeEnv, getNodeInstallGuide, getInstallFailureHints };
+module.exports = {
+  buildClaudeInstallCommand,
+  buildYingclawUpgradeCommand,
+  buildWindowsYingclawUpgradeScript,
+  checkNodeEnv,
+  getNodeInstallGuide,
+  getInstallFailureHints,
+};

package/lib/openai.js

@@ -0,0 +1,152 @@
+function normalizeOpenAiBaseUrl(baseUrl) {
+  let url;
+  try { url = new URL(baseUrl); } catch { return baseUrl; }
+
+  const parts = url.pathname.split('/').filter(Boolean);
+  if (parts.at(-1) === 'completions' && parts.at(-2) === 'chat' && parts.at(-3) === 'v1') {
+    parts.splice(-3, 3);
+  } else if (parts.at(-1) === 'models' && parts.at(-2) === 'v1') {
+    parts.splice(-2, 2);
+  } else if (parts.at(-1) === 'v1') {
+    parts.pop();
+  }
+
+  url.pathname = parts.length > 0 ? `/${parts.join('/')}` : '/';
+  url.search = '';
+  url.hash = '';
+  return url.toString().replace(/\/+$/, '');
+}
+
+function openAiChatCompletionsUrl(baseUrl) {
+  return `${normalizeOpenAiBaseUrl(baseUrl)}/v1/chat/completions`;
+}
+
+function anthropicTextFromContent(content) {
+  if (typeof content === 'string') return content;
+  if (!Array.isArray(content)) return '';
+  return content
+    .map((part) => {
+      if (typeof part === 'string') return part;
+      if (part?.type === 'text') return part.text || '';
+      return '';
+    })
+    .filter(Boolean)
+    .join('\n');
+}
+
+function normalizeSystemMessages(system) {
+  if (!system) return [];
+  if (typeof system === 'string') return [{ role: 'system', content: system }];
+  if (Array.isArray(system)) {
+    const text = anthropicTextFromContent(system);
+    return text ? [{ role: 'system', content: text }] : [];
+  }
+  return [];
+}
+
+function anthropicToOpenAiChatRequest(body) {
+  const messages = [
+    ...normalizeSystemMessages(body.system),
+    ...(Array.isArray(body.messages) ? body.messages : []).map((message) => ({
+      role: message.role === 'assistant' ? 'assistant' : 'user',
+      content: anthropicTextFromContent(message.content),
+    })),
+  ];
+
+  const request = {
+    model: body.model,
+    messages,
+    stream: !!body.stream,
+  };
+
+  if (body.max_tokens !== undefined) request.max_tokens = body.max_tokens;
+  if (body.temperature !== undefined) request.temperature = body.temperature;
+  if (body.top_p !== undefined) request.top_p = body.top_p;
+  if (body.stop_sequences !== undefined) request.stop = body.stop_sequences;
+  return request;
+}
+
+function openAiFinishReasonToAnthropic(reason) {
+  if (reason === 'length') return 'max_tokens';
+  if (reason === 'tool_calls' || reason === 'function_call') return 'tool_use';
+  if (reason === 'stop') return 'end_turn';
+  return reason || 'end_turn';
+}
+
+function openAiToAnthropicMessage(body, fallbackModel) {
+  const choice = body?.choices?.[0] || {};
+  const content = choice.message?.content ?? choice.text ?? '';
+  const text = Array.isArray(content)
+    ? content.map((part) => part?.text || '').join('')
+    : String(content || '');
+  return {
+    id: body?.id || `msg_${Date.now()}`,
+    type: 'message',
+    role: 'assistant',
+    model: body?.model || fallbackModel,
+    content: [{ type: 'text', text }],
+    stop_reason: openAiFinishReasonToAnthropic(choice.finish_reason),
+    stop_sequence: null,
+    usage: {
+      input_tokens: body?.usage?.prompt_tokens ?? body?.usage?.input_tokens ?? 0,
+      output_tokens: body?.usage?.completion_tokens ?? body?.usage?.output_tokens ?? 0,
+    },
+  };
+}
+
+function anthropicSse(event, data) {
+  return `event: ${event}\ndata: ${JSON.stringify(data)}\n\n`;
+}
+
+function openAiStreamChunkToAnthropicEvents(chunk, state) {
+  const choice = chunk?.choices?.[0] || {};
+  const delta = choice.delta || {};
+  const events = [];
+  if (!state.started) {
+    state.started = true;
+    events.push(anthropicSse('message_start', {
+      type: 'message_start',
+      message: {
+        id: chunk?.id || `msg_${Date.now()}`,
+        type: 'message',
+        role: 'assistant',
+        model: chunk?.model || state.model,
+        content: [],
+        stop_reason: null,
+        stop_sequence: null,
+        usage: { input_tokens: 0, output_tokens: 0 },
+      },
+    }));
+    events.push(anthropicSse('content_block_start', {
+      type: 'content_block_start',
+      index: 0,
+      content_block: { type: 'text', text: '' },
+    }));
+  }
+  if (delta.content) {
+    events.push(anthropicSse('content_block_delta', {
+      type: 'content_block_delta',
+      index: 0,
+      delta: { type: 'text_delta', text: delta.content },
+    }));
+  }
+  if (choice.finish_reason) {
+    state.finished = true;
+    events.push(anthropicSse('content_block_stop', { type: 'content_block_stop', index: 0 }));
+    events.push(anthropicSse('message_delta', {
+      type: 'message_delta',
+      delta: { stop_reason: openAiFinishReasonToAnthropic(choice.finish_reason), stop_sequence: null },
+      usage: { output_tokens: 0 },
+    }));
+    events.push(anthropicSse('message_stop', { type: 'message_stop' }));
+  }
+  return events.join('');
+}
+
+module.exports = {
+  anthropicToOpenAiChatRequest,
+  normalizeOpenAiBaseUrl,
+  openAiChatCompletionsUrl,
+  openAiStreamChunkToAnthropicEvents,
+  openAiToAnthropicMessage,
+};