yingclaw 2.5.20 → 2.5.26

package/lib/openai.js

@@ -0,0 +1,294 @@
+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 anthropicToolUseToOpenAi(block) {
+  return {
+    id: block.id,
+    type: 'function',
+    function: {
+      name: block.name,
+      arguments: typeof block.input === 'string' ? block.input : JSON.stringify(block.input || {}),
+    },
+  };
+}
+
+function anthropicToolResultContentToText(content) {
+  if (typeof content === 'string') return content;
+  if (Array.isArray(content)) {
+    return content.filter(p => p?.type === 'text').map(p => p.text || '').join('\n');
+  }
+  return '';
+}
+
+function anthropicMessageToOpenAi(message) {
+  const content = message.content;
+  if (message.role === 'assistant') {
+    const textParts = Array.isArray(content)
+      ? content.filter(p => p?.type === 'text').map(p => p.text || '').join('')
+      : typeof content === 'string' ? content : '';
+    const toolUses = Array.isArray(content) ? content.filter(p => p?.type === 'tool_use') : [];
+    const msg = { role: 'assistant', content: textParts || null };
+    if (toolUses.length > 0) {
+      msg.tool_calls = toolUses.map(anthropicToolUseToOpenAi);
+    }
+    if (msg.content === null && !msg.tool_calls) msg.content = '';
+    return [msg];
+  }
+
+  // user role: split tool_result blocks into separate 'tool' messages
+  if (!Array.isArray(content)) {
+    return [{ role: 'user', content: anthropicTextFromContent(content) }];
+  }
+  const toolResults = content.filter(p => p?.type === 'tool_result');
+  const other = content.filter(p => p?.type !== 'tool_result');
+  const messages = toolResults.map(tr => ({
+    role: 'tool',
+    tool_call_id: tr.tool_use_id,
+    content: anthropicToolResultContentToText(tr.content),
+  }));
+  const text = anthropicTextFromContent(other);
+  if (text) messages.push({ role: 'user', content: text });
+  if (messages.length === 0) messages.push({ role: 'user', content: '' });
+  return messages;
+}
+
+function anthropicToolsToOpenAi(tools) {
+  if (!Array.isArray(tools)) return undefined;
+  const converted = tools.map(tool => ({
+    type: 'function',
+    function: {
+      name: tool.name,
+      description: tool.description || '',
+      parameters: tool.input_schema || { type: 'object', properties: {} },
+    },
+  }));
+  return converted.length > 0 ? converted : undefined;
+}
+
+function anthropicToOpenAiChatRequest(body) {
+  const messages = [
+    ...normalizeSystemMessages(body.system),
+    ...(Array.isArray(body.messages) ? body.messages : []).flatMap(anthropicMessageToOpenAi),
+  ];
+
+  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;
+  const tools = anthropicToolsToOpenAi(body.tools);
+  if (tools) request.tools = tools;
+  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 openAiToolCallToAnthropic(toolCall) {
+  let input = {};
+  try { input = JSON.parse(toolCall.function?.arguments || '{}'); } catch {}
+  return {
+    type: 'tool_use',
+    id: toolCall.id || `tool_${Date.now()}`,
+    name: toolCall.function?.name || '',
+    input,
+  };
+}
+
+function openAiToAnthropicMessage(body, fallbackModel) {
+  const choice = body?.choices?.[0] || {};
+  const message = choice.message || {};
+  const rawContent = message.content ?? choice.text ?? '';
+  const text = Array.isArray(rawContent)
+    ? rawContent.map((part) => part?.text || '').join('')
+    : String(rawContent || '');
+
+  const contentBlocks = [];
+  if (text) contentBlocks.push({ type: 'text', text });
+  if (Array.isArray(message.tool_calls)) {
+    for (const tc of message.tool_calls) contentBlocks.push(openAiToolCallToAnthropic(tc));
+  }
+  if (contentBlocks.length === 0) contentBlocks.push({ type: 'text', text: '' });
+
+  return {
+    id: body?.id || `msg_${Date.now()}`,
+    type: 'message',
+    role: 'assistant',
+    model: body?.model || fallbackModel,
+    content: contentBlocks,
+    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;
+    // index 0 is always the text block
+    state.textBlockOpen = false;
+    // map tool_call index → anthropic content block index
+    state.toolIndexMap = {};
+    state.nextBlockIndex = 0;
+    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: chunk?.usage?.prompt_tokens ?? 0, output_tokens: 0 },
+      },
+    }));
+  }
+
+  if (delta.content) {
+    if (!state.textBlockOpen) {
+      state.textBlockOpen = true;
+      state.textBlockIndex = state.nextBlockIndex++;
+      events.push(anthropicSse('content_block_start', {
+        type: 'content_block_start',
+        index: state.textBlockIndex,
+        content_block: { type: 'text', text: '' },
+      }));
+    }
+    events.push(anthropicSse('content_block_delta', {
+      type: 'content_block_delta',
+      index: state.textBlockIndex,
+      delta: { type: 'text_delta', text: delta.content },
+    }));
+  }
+
+  if (Array.isArray(delta.tool_calls)) {
+    for (const tc of delta.tool_calls) {
+      const tcIdx = tc.index ?? 0;
+      if (!(tcIdx in state.toolIndexMap)) {
+        // close text block first if open
+        if (state.textBlockOpen && !state.textBlockClosed) {
+          state.textBlockClosed = true;
+          events.push(anthropicSse('content_block_stop', { type: 'content_block_stop', index: state.textBlockIndex }));
+        }
+        const blockIndex = state.nextBlockIndex++;
+        state.toolIndexMap[tcIdx] = blockIndex;
+        let input = {};
+        try { if (tc.function?.arguments) input = JSON.parse(tc.function.arguments); } catch {}
+        events.push(anthropicSse('content_block_start', {
+          type: 'content_block_start',
+          index: blockIndex,
+          content_block: {
+            type: 'tool_use',
+            id: tc.id || `tool_${Date.now()}_${tcIdx}`,
+            name: tc.function?.name || '',
+            input,
+          },
+        }));
+      }
+      if (tc.function?.arguments) {
+        events.push(anthropicSse('content_block_delta', {
+          type: 'content_block_delta',
+          index: state.toolIndexMap[tcIdx],
+          delta: { type: 'input_json_delta', partial_json: tc.function.arguments },
+        }));
+      }
+    }
+  }
+
+  if (choice.finish_reason) {
+    state.finished = true;
+    // close any open blocks
+    if (state.textBlockOpen && !state.textBlockClosed) {
+      events.push(anthropicSse('content_block_stop', { type: 'content_block_stop', index: state.textBlockIndex }));
+    }
+    for (const blockIndex of Object.values(state.toolIndexMap)) {
+      events.push(anthropicSse('content_block_stop', { type: 'content_block_stop', index: blockIndex }));
+    }
+    // if nothing was opened at all, emit an empty text block
+    if (!state.textBlockOpen && Object.keys(state.toolIndexMap).length === 0) {
+      events.push(anthropicSse('content_block_start', { type: 'content_block_start', index: 0, content_block: { type: 'text', text: '' } }));
+      events.push(anthropicSse('content_block_stop', { type: 'content_block_stop', index: 0 }));
+    }
+    const outputTokens = chunk?.usage?.completion_tokens ?? chunk?.usage?.output_tokens ?? 0;
+    events.push(anthropicSse('message_delta', {
+      type: 'message_delta',
+      delta: { stop_reason: openAiFinishReasonToAnthropic(choice.finish_reason), stop_sequence: null },
+      usage: { output_tokens: outputTokens },
+    }));
+    events.push(anthropicSse('message_stop', { type: 'message_stop' }));
+  }
+
+  return events.join('');
+}
+
+module.exports = {
+  anthropicToOpenAiChatRequest,
+  normalizeOpenAiBaseUrl,
+  openAiChatCompletionsUrl,
+  openAiStreamChunkToAnthropicEvents,
+  openAiToAnthropicMessage,
+};

package/lib/panel.js

@@ -1,4 +1,4 @@
-const { buildClaudeEnv, PROVIDERS } = require('./config');
+const { buildClaudeEnv, getModelFamily, PROVIDERS } = require('./config');
 
 function apiStatusText(apiStatus) {
   if (apiStatus === true) return 'API 正常';
@@ -39,6 +39,9 @@ function buildStatusView(config, options = {}) {
   const desktopGatewayStatus = options.desktopGatewayStatus;
   const desktopGatewayAutostartStatus = options.desktopGatewayAutostartStatus;
   const desktopGatewayText = desktopGatewayStatusText(desktopGatewayStatus, desktopGatewayAutostartStatus);
+  const availableModelCount = Array.isArray(config.availableModels) ? config.availableModels.length : 0;
+  const mainFamily = getModelFamily(mainModel);
+  const fastFamily = getModelFamily(fastModel);
   const warnings = [];
 
   if (config.provider === 'deepseek' && (
@@ -48,11 +51,15 @@ function buildStatusView(config, options = {}) {
   )) {
     warnings.push('检测到旧 DeepSeek 模型名，建议运行 claw switch 更新到 [1m] 长上下文版本');
   }
+  if (config.provider === 'custom' && mainFamily && fastFamily && mainFamily !== fastFamily) {
+    warnings.push(`快速模型跨系列：${mainFamily} → ${fastFamily}`);
+  }
 
   const view = {
     providerName,
     mainModel,
     fastModel,
+    availableModelCount,
     envActive,
     warnings,
     lines: [
@@ -83,14 +90,17 @@ function buildMenuStatusLines(view, options = {}) {
   ];
 
   if (view.envActive) {
-    lines.push('环境变量已生效');
+    lines.push('终端已生效');
   } else if (options.platform === 'win32') {
-    lines.push('环境变量未生效：重新打开 PowerShell / CMD');
+    lines.push('终端未生效：重新打开 PowerShell / CMD');
   } else {
-    lines.push('环境变量未生效：运行 source ~/.zshrc 或重开终端');
+    const shell = options.shell || process.env.SHELL || '';
+    const rcFile = shell.includes('bash') ? '~/.bashrc' : '~/.zshrc';
+    lines.push(`终端未生效：source ${rcFile} 或重开终端`);
   }
 
-  lines.push(`主模型 ${view.mainModel} · 快速模型 ${view.fastModel}`);
+  const modelCountText = view.availableModelCount ? ` · 可用 ${view.availableModelCount}` : '';
+  lines.push(`模型 ${view.mainModel} · 快速 ${view.fastModel}${modelCountText}`);
 
   const desktopGatewayText = desktopGatewayStatusText(
     view.desktopGatewayStatus || options.desktopGatewayStatus,
@@ -103,6 +113,10 @@ function buildMenuStatusLines(view, options = {}) {
   if (view.warnings.some((warning) => warning.includes('旧 DeepSeek 模型名'))) {
     lines.push('旧模型名：选择下方"切换厂商或模型"更新到 [1m]');
   }
+  const crossFamilyWarning = view.warnings.find((warning) => warning.startsWith('快速模型跨系列'));
+  if (crossFamilyWarning) {
+    lines.push(crossFamilyWarning);
+  }
 
   return lines;
 }

package/lib/vscode.js

@@ -0,0 +1,280 @@
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { buildClaudeEnv, resolveFastModel, PROVIDERS, CLEAR_CLAUDE_ENV_KEYS } = require('./config');
+const { isDesktopChatModel, buildDesktopGatewayRoutes, buildDesktopGatewayUrl } = require('./gateway');
+
+const CLAUDE_CODE_SETTINGS_SCHEMA = 'https://json.schemastore.org/claude-code-settings.json';
+const VSCODE_CLAUDE_OPEN_URI = 'vscode://anthropic.claude-code/open';
+const VSCODE_MODEL_SETTINGS_KEYS = ['model', 'availableModels'];
+
+function readJsonFile(file) {
+  try {
+    return JSON.parse(fs.readFileSync(file, 'utf8'));
+  } catch {
+    return {};
+  }
+}
+
+function writeJsonFile(file, value) {
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  fs.writeFileSync(file, JSON.stringify(value, null, 2) + '\n');
+}
+
+function getClaudeCodeSettingsPath(options = {}) {
+  const homeDir = options.homeDir || os.homedir();
+  return options.settingsFile || path.join(homeDir, '.claude', 'settings.json');
+}
+
+function getVsCodeUserSettingsPath(options = {}) {
+  if (options.vsCodeSettingsFile) return options.vsCodeSettingsFile;
+
+  const platform = options.platform || process.platform;
+  const homeDir = options.homeDir || os.homedir();
+
+  if (platform === 'darwin') {
+    return path.join(homeDir, 'Library', 'Application Support', 'Code', 'User', 'settings.json');
+  }
+  if (platform === 'win32') {
+    const appData = options.appData || process.env.APPDATA || path.join(homeDir, 'AppData', 'Roaming');
+    return path.win32.join(appData, 'Code', 'User', 'settings.json');
+  }
+  return path.join(homeDir, '.config', 'Code', 'User', 'settings.json');
+}
+
+function buildClaudeCodeSettingsPatch(config) {
+  const availableModels = buildVsCodeAvailableModels(config);
+  return {
+    $schema: CLAUDE_CODE_SETTINGS_SCHEMA,
+    availableModels,
+  };
+}
+
+function buildVsCodeClaudeEnv(config) {
+  const { provider, model, fastModel, vscodeModel, vscodeFastModel } = config;
+  const selectedModel = vscodeModel || model;
+  const resolvedFastModel = vscodeFastModel || fastModel || resolveFastModel(PROVIDERS[provider], selectedModel);
+  const claudeEnv = buildClaudeEnv({ ...config, model: selectedModel, fastModel: resolvedFastModel });
+  const env = {
+    ANTHROPIC_BASE_URL: claudeEnv.ANTHROPIC_BASE_URL,
+    ANTHROPIC_AUTH_TOKEN: claudeEnv.ANTHROPIC_AUTH_TOKEN,
+    ANTHROPIC_MODEL: claudeEnv.ANTHROPIC_MODEL,
+    CLAUDE_CODE_SUBAGENT_MODEL: resolvedFastModel,
+    CLAUDE_CODE_EFFORT_LEVEL: 'max',
+  };
+  if (resolvedFastModel && resolvedFastModel !== selectedModel) {
+    env.ANTHROPIC_CUSTOM_MODEL_OPTION = resolvedFastModel;
+    env.ANTHROPIC_CUSTOM_MODEL_OPTION_NAME = resolvedFastModel;
+    env.ANTHROPIC_CUSTOM_MODEL_OPTION_DESCRIPTION = 'Custom fast model';
+  }
+  return env;
+}
+
+function buildVsCodeAvailableModels({ model, fastModel, availableModels, vscodeModel, vscodeFastModel }) {
+  const providerModels = Array.isArray(availableModels) && availableModels.length > 0
+    ? availableModels
+    : [];
+  const models = [vscodeModel || model, vscodeFastModel || fastModel, model, fastModel, ...providerModels].filter(Boolean);
+  const chatModels = models.filter(isDesktopChatModel);
+  return [...new Set(chatModels.length > 0 ? chatModels : [model, fastModel].filter(Boolean))];
+}
+
+function buildVsCodeModelSelectionIds(config) {
+  return buildVsCodeAvailableModels(config);
+}
+
+function writeClaudeCodeSettings(config, options = {}) {
+  const file = getClaudeCodeSettingsPath(options);
+  const current = readJsonFile(file);
+  const patch = buildClaudeCodeSettingsPatch(config);
+
+  // Clean up any yingclaw env vars previously written to settings.json
+  const nextEnv = { ...(current.env && typeof current.env === 'object' ? current.env : {}) };
+  for (const key of CLEAR_CLAUDE_ENV_KEYS) {
+    delete nextEnv[key];
+  }
+
+  const next = {
+    ...current,
+    $schema: current.$schema || patch.$schema,
+    availableModels: patch.availableModels,
+  };
+
+  // Remove model from settings.json — it would also affect the terminal
+  delete next.model;
+
+  if (Object.keys(nextEnv).length > 0) {
+    next.env = nextEnv;
+  } else {
+    delete next.env;
+  }
+
+  writeJsonFile(file, next);
+  try {
+    fs.chmodSync(file, 0o600);
+  } catch {}
+  return { result: 'updated', file };
+}
+
+function buildVsCodeExtensionEnvVars(config) {
+  const env = buildVsCodeClaudeEnv(config);
+  return Object.entries(env).map(([name, value]) => ({ name, value: String(value) }));
+}
+
+function writeVsCodeExtensionSettings(config, options = {}) {
+  const file = getVsCodeUserSettingsPath(options);
+  const current = readJsonFile(file);
+  const next = {
+    ...current,
+    'claudeCode.disableLoginPrompt': true,
+    'claudeCode.environmentVariables': buildVsCodeExtensionEnvVars(config),
+  };
+  if (options.useTerminal === true || options.useTerminal === false) {
+    next['claudeCode.useTerminal'] = options.useTerminal;
+  }
+  writeJsonFile(file, next);
+  return { result: 'updated', file };
+}
+
+function writeVsCodeIntegration(config, options = {}) {
+  const claudeSettings = writeClaudeCodeSettings(config, options);
+  const vscodeSettings = writeVsCodeExtensionSettings(config, options);
+  return {
+    result: 'updated',
+    files: [claudeSettings.file, vscodeSettings.file],
+    claudeSettings,
+    vscodeSettings,
+  };
+}
+
+function clearClaudeCodeSettingsEnv(options = {}) {
+  const file = getClaudeCodeSettingsPath(options);
+  if (!fs.existsSync(file)) return { result: 'missing', file };
+
+  const current = readJsonFile(file);
+  const nextEnv = { ...(current.env && typeof current.env === 'object' ? current.env : {}) };
+  let changed = false;
+
+  for (const key of CLEAR_CLAUDE_ENV_KEYS) {
+    if (Object.prototype.hasOwnProperty.call(nextEnv, key)) {
+      delete nextEnv[key];
+      changed = true;
+    }
+  }
+  for (const key of VSCODE_MODEL_SETTINGS_KEYS) {
+    if (Object.prototype.hasOwnProperty.call(current, key)) {
+      changed = true;
+    }
+  }
+
+  if (!changed) return { result: 'missing', file };
+
+  const next = { ...current };
+  for (const key of VSCODE_MODEL_SETTINGS_KEYS) {
+    delete next[key];
+  }
+  if (Object.keys(nextEnv).length > 0) {
+    next.env = nextEnv;
+  } else {
+    delete next.env;
+  }
+  writeJsonFile(file, next);
+  return { result: 'updated', file };
+}
+
+function clearVsCodeExtensionSettings(options = {}) {
+  const file = getVsCodeUserSettingsPath(options);
+  if (!fs.existsSync(file)) return { result: 'missing', file };
+
+  const current = readJsonFile(file);
+  const next = { ...current };
+  let changed = false;
+  for (const key of ['claudeCode.disableLoginPrompt', 'claudeCode.useTerminal', 'claudeCode.environmentVariables']) {
+    if (Object.prototype.hasOwnProperty.call(next, key)) {
+      delete next[key];
+      changed = true;
+    }
+  }
+  if (!changed) return { result: 'missing', file };
+
+  writeJsonFile(file, next);
+  return { result: 'updated', file };
+}
+
+function clearVsCodeIntegration(options = {}) {
+  const claudeSettings = clearClaudeCodeSettingsEnv(options);
+  const vscodeSettings = clearVsCodeExtensionSettings(options);
+  const files = [claudeSettings, vscodeSettings]
+    .filter(result => result.result === 'updated')
+    .map(result => result.file);
+
+  return {
+    result: files.length > 0 ? 'updated' : 'missing',
+    files,
+    claudeSettings,
+    vscodeSettings,
+  };
+}
+
+function checkClaudeCodeSettingsEnv(config, options = {}) {
+  const settingsFile = getClaudeCodeSettingsPath(options);
+  const vsCodeFile = getVsCodeUserSettingsPath(options);
+  const settings = readJsonFile(settingsFile);
+  const vsCodeSettings = readJsonFile(vsCodeFile);
+  const missing = [];
+
+  // Check availableModels in settings.json
+  const expectedModels = buildVsCodeAvailableModels(config);
+  if (!Array.isArray(settings.availableModels) || settings.availableModels.join(',') !== expectedModels.join(',')) {
+    missing.push('availableModels');
+  }
+
+  // Check claudeCode.environmentVariables in VS Code extension settings
+  const expectedEnv = buildVsCodeClaudeEnv(config);
+  const actualEnvArray = vsCodeSettings['claudeCode.environmentVariables'];
+  if (!Array.isArray(actualEnvArray)) {
+    missing.push('claudeCode.environmentVariables');
+  } else {
+    const actualEnvMap = {};
+    for (const { name, value } of actualEnvArray) actualEnvMap[name] = value;
+    for (const [key, value] of Object.entries(expectedEnv)) {
+      if (actualEnvMap[key] !== String(value)) missing.push(key);
+    }
+  }
+
+  return {
+    file: settingsFile,
+    configured: missing.length === 0,
+    missing,
+  };
+}
+
+function buildVsCodeOpenCommand(platform = process.platform) {
+  if (platform === 'darwin') {
+    return { command: 'open', args: [VSCODE_CLAUDE_OPEN_URI] };
+  }
+  if (platform === 'win32') {
+    return { command: 'cmd', args: ['/c', 'start', '', VSCODE_CLAUDE_OPEN_URI] };
+  }
+  return { command: 'xdg-open', args: [VSCODE_CLAUDE_OPEN_URI] };
+}
+
+module.exports = {
+  CLAUDE_CODE_SETTINGS_SCHEMA,
+  VSCODE_CLAUDE_OPEN_URI,
+  buildClaudeCodeSettingsPatch,
+  buildVsCodeAvailableModels,
+  buildVsCodeClaudeEnv,
+  buildVsCodeExtensionEnvVars,
+  buildVsCodeModelSelectionIds,
+  buildVsCodeOpenCommand,
+  checkClaudeCodeSettingsEnv,
+  clearClaudeCodeSettingsEnv,
+  clearVsCodeExtensionSettings,
+  clearVsCodeIntegration,
+  getClaudeCodeSettingsPath,
+  getVsCodeUserSettingsPath,
+  writeClaudeCodeSettings,
+  writeVsCodeExtensionSettings,
+  writeVsCodeIntegration,
+};

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "yingclaw",
-  "version": "2.5.20",
-  "description": "Claude Code × 国产大模型一键接入：DeepSeek、Kimi、Qwen、MiniMax、GLM、MiMo",
+  "version": "2.5.26",
+  "description": "Claude Code × 国产大模型一键接入：DeepSeek、Kimi、火山方舟、Qwen、MiniMax、GLM、MiMo、自定义接口",
   "main": "index.js",
   "bin": {
     "claw": "bin/cli.js"