claude-code-workflow 6.3.18 → 6.3.20

package/ccw/src/tools/claude-cli-tools.ts

@@ -1,8 +1,15 @@
 /**
  * Claude CLI Tools Configuration Manager
- * Manages .claude/cli-tools.json with fallback:
- * 1. Project workspace: {projectDir}/.claude/cli-tools.json (priority)
- * 2. Global: ~/.claude/cli-tools.json (fallback)
+ * Manages cli-tools.json (tools) and cli-settings.json (settings)
+ *
+ * Configuration Strategy (GLOBAL ONLY):
+ * - READ: Global → Default (no project-level configs)
+ * - CREATE/SAVE: Always in ~/.claude/ (global user-level config)
+ *
+ * Config location: ~/.claude/cli-tools.json
+ * Settings location: ~/.claude/cli-settings.json
+ *
+ * Note: Project-level configs are NOT used - all config is user-level.
  */
 import * as fs from 'fs';
 import * as path from 'path';
@@ -12,9 +19,38 @@ import * as os from 'os';
 
 export interface ClaudeCliTool {
   enabled: boolean;
-  isBuiltin: boolean;
-  command: string;
-  description: string;
+  primaryModel?: string;
+  secondaryModel?: string;
+  tags: string[];
+  /**
+   * Tool type determines routing:
+   * - 'builtin': Built-in CLI tools (gemini, qwen, codex, etc.)
+   * - 'cli-wrapper': Routes to `claude --settings` (CLI Settings endpoints)
+   * - 'api-endpoint': Routes to LiteLLM (LiteLLM endpoints)
+   */
+  type?: 'builtin' | 'cli-wrapper' | 'api-endpoint';
+  /**
+   * Endpoint ID for type: 'api-endpoint'
+   * Used to lookup endpoint configuration in litellm-api-config.json
+   */
+  id?: string;
+}
+
+export type CliToolName = 'gemini' | 'qwen' | 'codex' | 'claude' | 'opencode' | string;
+
+// @deprecated Use tools with type: 'api-endpoint' instead
+export interface ClaudeApiEndpoint {
+  id: string;
+  name: string;
+  enabled: boolean;
+}
+
+// @deprecated Use tools with type: 'cli-wrapper' or 'api-endpoint' instead
+export interface ClaudeCustomEndpoint {
+  id: string;
+  name: string;
+  enabled: boolean;
+  tags: string[];
 }
 
 export interface ClaudeCacheSettings {
@@ -23,76 +59,129 @@ export interface ClaudeCacheSettings {
   defaultSuffix: string;
 }
 
+// New: Tools-only config (cli-tools.json)
 export interface ClaudeCliToolsConfig {
   $schema?: string;
   version: string;
-  tools: Record<string, ClaudeCliTool>;
-  customEndpoints: Array<{
-    id: string;
-    name: string;
-    enabled: boolean;
-  }>;
+  models?: Record<string, string[]>;  // PREDEFINED_MODELS
+  tools: Record<string, ClaudeCliTool>;  // All tools: builtin, cli-wrapper, api-endpoint
+  apiEndpoints?: ClaudeApiEndpoint[];  // @deprecated Use tools with type: 'api-endpoint' instead
+  customEndpoints?: ClaudeCustomEndpoint[];  // @deprecated Use tools with type: 'cli-wrapper' or 'api-endpoint' instead
+}
+
+// New: Settings-only config (cli-settings.json)
+export interface ClaudeCliSettingsConfig {
+  $schema?: string;
+  version: string;
   defaultTool: string;
-  settings: {
-    promptFormat: 'plain' | 'yaml' | 'json';
-    smartContext: {
-      enabled: boolean;
-      maxFiles: number;
+  promptFormat: 'plain' | 'yaml' | 'json';
+  smartContext: {
+    enabled: boolean;
+    maxFiles: number;
+  };
+  nativeResume: boolean;
+  recursiveQuery: boolean;
+  cache: ClaudeCacheSettings;
+  codeIndexMcp: 'codexlens' | 'ace' | 'none';
+}
+
+// Legacy combined config (for backward compatibility)
+export interface ClaudeCliCombinedConfig extends ClaudeCliToolsConfig {
+  defaultTool?: string;
+  settings?: {
+    promptFormat?: 'plain' | 'yaml' | 'json';
+    smartContext?: {
+      enabled?: boolean;
+      maxFiles?: number;
     };
-    nativeResume: boolean;
-    recursiveQuery: boolean;
-    cache: ClaudeCacheSettings;
-    codeIndexMcp: 'codexlens' | 'ace' | 'none';  // Code Index MCP provider
+    nativeResume?: boolean;
+    recursiveQuery?: boolean;
+    cache?: Partial<ClaudeCacheSettings>;
+    codeIndexMcp?: 'codexlens' | 'ace' | 'none';
   };
 }
 
 // ========== Default Config ==========
 
-const DEFAULT_CONFIG: ClaudeCliToolsConfig = {
-  version: '1.0.0',
+// Predefined models for each tool
+const PREDEFINED_MODELS: Record<CliToolName, string[]> = {
+  gemini: ['gemini-2.5-pro', 'gemini-2.5-flash', 'gemini-2.0-flash', 'gemini-1.5-pro', 'gemini-1.5-flash'],
+  qwen: ['coder-model', 'vision-model', 'qwen2.5-coder-32b'],
+  codex: ['gpt-5.2', 'gpt-4.1', 'o4-mini', 'o3'],
+  claude: ['sonnet', 'opus', 'haiku', 'claude-sonnet-4-5-20250929', 'claude-opus-4-5-20251101'],
+  opencode: [
+    'opencode/glm-4.7-free',
+    'opencode/gpt-5-nano',
+    'opencode/grok-code',
+    'opencode/minimax-m2.1-free',
+    'anthropic/claude-sonnet-4-20250514',
+    'anthropic/claude-opus-4-20250514',
+    'openai/gpt-4.1',
+    'openai/o3',
+    'google/gemini-2.5-pro',
+    'google/gemini-2.5-flash'
+  ]
+};
+
+const DEFAULT_TOOLS_CONFIG: ClaudeCliToolsConfig = {
+  version: '3.2.0',
+  models: { ...PREDEFINED_MODELS },
   tools: {
     gemini: {
       enabled: true,
-      isBuiltin: true,
-      command: 'gemini',
-      description: 'Google AI for code analysis'
+      primaryModel: 'gemini-2.5-pro',
+      secondaryModel: 'gemini-2.5-flash',
+      tags: [],
+      type: 'builtin'
     },
     qwen: {
       enabled: true,
-      isBuiltin: true,
-      command: 'qwen',
-      description: 'Alibaba AI assistant'
+      primaryModel: 'coder-model',
+      secondaryModel: 'coder-model',
+      tags: [],
+      type: 'builtin'
     },
     codex: {
       enabled: true,
-      isBuiltin: true,
-      command: 'codex',
-      description: 'OpenAI code generation'
+      primaryModel: 'gpt-5.2',
+      secondaryModel: 'gpt-5.2',
+      tags: [],
+      type: 'builtin'
     },
     claude: {
       enabled: true,
-      isBuiltin: true,
-      command: 'claude',
-      description: 'Anthropic AI assistant'
-    }
-  },
-  customEndpoints: [],
-  defaultTool: 'gemini',
-  settings: {
-    promptFormat: 'plain',
-    smartContext: {
-      enabled: false,
-      maxFiles: 10
+      primaryModel: 'sonnet',
+      secondaryModel: 'haiku',
+      tags: [],
+      type: 'builtin'
     },
-    nativeResume: true,
-    recursiveQuery: true,
-    cache: {
-      injectionMode: 'auto',
-      defaultPrefix: '',
-      defaultSuffix: ''
-    },
-    codeIndexMcp: 'codexlens'  // Default to CodexLens
+    opencode: {
+      enabled: true,
+      primaryModel: 'opencode/glm-4.7-free',
+      secondaryModel: 'opencode/glm-4.7-free',
+      tags: [],
+      type: 'builtin'
+    }
   }
+  // Note: api-endpoint type tools are added dynamically via addClaudeApiEndpoint
+};
+
+const DEFAULT_SETTINGS_CONFIG: ClaudeCliSettingsConfig = {
+  version: '1.0.0',
+  defaultTool: 'gemini',
+  promptFormat: 'plain',
+  smartContext: {
+    enabled: false,
+    maxFiles: 10
+  },
+  nativeResume: true,
+  recursiveQuery: true,
+  cache: {
+    injectionMode: 'auto',
+    defaultPrefix: '',
+    defaultSuffix: ''
+  },
+  codeIndexMcp: 'ace'
 };
 
 // ========== Helper Functions ==========
@@ -101,105 +190,346 @@ function getProjectConfigPath(projectDir: string): string {
   return path.join(projectDir, '.claude', 'cli-tools.json');
 }
 
+function getProjectSettingsPath(projectDir: string): string {
+  return path.join(projectDir, '.claude', 'cli-settings.json');
+}
+
 function getGlobalConfigPath(): string {
   return path.join(os.homedir(), '.claude', 'cli-tools.json');
 }
 
+function getGlobalSettingsPath(): string {
+  return path.join(os.homedir(), '.claude', 'cli-settings.json');
+}
+
 /**
- * Resolve config path with fallback:
- * 1. Project: {projectDir}/.claude/cli-tools.json
- * 2. Global: ~/.claude/cli-tools.json
- * Returns { path, source } where source is 'project' | 'global' | 'default'
+ * Resolve config path - GLOBAL ONLY
+ * Config is user-level, stored only in ~/.claude/cli-tools.json
+ * Returns { path, source } where source is 'global' | 'default'
  */
 function resolveConfigPath(projectDir: string): { path: string; source: 'project' | 'global' | 'default' } {
-  const projectPath = getProjectConfigPath(projectDir);
-  if (fs.existsSync(projectPath)) {
-    return { path: projectPath, source: 'project' };
-  }
-
   const globalPath = getGlobalConfigPath();
   if (fs.existsSync(globalPath)) {
     return { path: globalPath, source: 'global' };
   }
 
-  return { path: projectPath, source: 'default' };
+  // Return global path for default (will be created there)
+  return { path: globalPath, source: 'default' };
 }
 
-function ensureClaudeDir(projectDir: string): void {
-  const claudeDir = path.join(projectDir, '.claude');
-  if (!fs.existsSync(claudeDir)) {
-    fs.mkdirSync(claudeDir, { recursive: true });
+/**
+ * Resolve settings path - GLOBAL ONLY
+ * Settings are user-level, stored only in ~/.claude/cli-settings.json
+ */
+function resolveSettingsPath(projectDir: string): { path: string; source: 'project' | 'global' | 'default' } {
+  const globalPath = getGlobalSettingsPath();
+  if (fs.existsSync(globalPath)) {
+    return { path: globalPath, source: 'global' };
   }
+
+  // Return global path for default (will be created there)
+  return { path: globalPath, source: 'default' };
 }
 
+// NOTE: ensureClaudeDir removed - config should only be in ~/.claude/, not project directory
+
 // ========== Main Functions ==========
 
 /**
- * Load CLI tools configuration with fallback:
- * 1. Project: {projectDir}/.claude/cli-tools.json
- * 2. Global: ~/.claude/cli-tools.json
- * 3. Default config
+ * Ensure tool has required fields (for backward compatibility)
+ */
+function ensureToolTags(tool: Partial<ClaudeCliTool>): ClaudeCliTool {
+  return {
+    enabled: tool.enabled ?? true,
+    primaryModel: tool.primaryModel,
+    secondaryModel: tool.secondaryModel,
+    tags: tool.tags ?? []
+  };
+}
+
+/**
+ * Migrate config from older versions to v3.2.0
+ * v3.2.0: All endpoints (cli-wrapper, api-endpoint) are in tools with type field
+ */
+function migrateConfig(config: any, projectDir: string): ClaudeCliToolsConfig {
+  const version = parseFloat(config.version || '1.0');
+
+  // Already v3.2+, no migration needed
+  if (version >= 3.2) {
+    return config as ClaudeCliToolsConfig;
+  }
+
+  console.log(`[claude-cli-tools] Migrating config from v${config.version || '1.0'} to v3.2.0`);
+
+  // Try to load legacy cli-config.json for model data
+  let legacyCliConfig: any = null;
+  try {
+    const { StoragePaths } = require('../config/storage-paths.js');
+    const legacyPath = StoragePaths.project(projectDir).cliConfig;
+    const fs = require('fs');
+    if (fs.existsSync(legacyPath)) {
+      legacyCliConfig = JSON.parse(fs.readFileSync(legacyPath, 'utf-8'));
+      console.log(`[claude-cli-tools] Found legacy cli-config.json, merging model data`);
+    }
+  } catch {
+    // Ignore errors loading legacy config
+  }
+
+  const migratedTools: Record<string, ClaudeCliTool> = {};
+
+  for (const [key, tool] of Object.entries(config.tools || {})) {
+    const t = tool as any;
+    const legacyTool = legacyCliConfig?.tools?.[key];
+
+    migratedTools[key] = {
+      enabled: t.enabled ?? legacyTool?.enabled ?? true,
+      primaryModel: t.primaryModel ?? legacyTool?.primaryModel ?? DEFAULT_TOOLS_CONFIG.tools[key]?.primaryModel,
+      secondaryModel: t.secondaryModel ?? legacyTool?.secondaryModel ?? DEFAULT_TOOLS_CONFIG.tools[key]?.secondaryModel,
+      tags: t.tags ?? legacyTool?.tags ?? [],
+      type: t.type ?? DEFAULT_TOOLS_CONFIG.tools[key]?.type ?? 'builtin',
+      id: t.id  // Preserve id for api-endpoint type
+    };
+  }
+
+  // Add any missing default tools
+  for (const [key, defaultTool] of Object.entries(DEFAULT_TOOLS_CONFIG.tools)) {
+    if (!migratedTools[key]) {
+      const legacyTool = legacyCliConfig?.tools?.[key];
+      migratedTools[key] = {
+        enabled: legacyTool?.enabled ?? defaultTool.enabled,
+        primaryModel: legacyTool?.primaryModel ?? defaultTool.primaryModel,
+        secondaryModel: legacyTool?.secondaryModel ?? defaultTool.secondaryModel,
+        tags: legacyTool?.tags ?? defaultTool.tags,
+        type: defaultTool.type ?? 'builtin'
+      };
+    }
+  }
+
+  // Migrate customEndpoints (v3.0 and below): cli-wrapper -> tools, others -> api-endpoint tools
+  const customEndpoints = config.customEndpoints || [];
+  for (const ep of customEndpoints) {
+    if (ep.tags?.includes('cli-wrapper')) {
+      // CLI wrapper becomes a tool with type: 'cli-wrapper'
+      if (!migratedTools[ep.name]) {
+        migratedTools[ep.name] = {
+          enabled: ep.enabled ?? true,
+          tags: ep.tags.filter((t: string) => t !== 'cli-wrapper'),
+          type: 'cli-wrapper'
+        };
+        console.log(`[claude-cli-tools] Migrated cli-wrapper "${ep.name}" to tools`);
+      }
+    } else {
+      // Pure API endpoint becomes a tool with type: 'api-endpoint'
+      if (!migratedTools[ep.name]) {
+        migratedTools[ep.name] = {
+          enabled: ep.enabled ?? true,
+          tags: [],
+          type: 'api-endpoint',
+          id: ep.id  // Store endpoint ID for settings lookup
+        };
+        console.log(`[claude-cli-tools] Migrated API endpoint "${ep.name}" to tools`);
+      }
+    }
+  }
+
+  // Migrate apiEndpoints (v3.1): convert to tools with type: 'api-endpoint'
+  const apiEndpoints = config.apiEndpoints || [];
+  for (const ep of apiEndpoints) {
+    if (!migratedTools[ep.name]) {
+      migratedTools[ep.name] = {
+        enabled: ep.enabled ?? true,
+        tags: [],
+        type: 'api-endpoint',
+        id: ep.id  // Store endpoint ID for settings lookup
+      };
+      console.log(`[claude-cli-tools] Migrated API endpoint "${ep.name}" to tools`);
+    }
+  }
+
+  return {
+    version: '3.2.0',
+    models: { ...PREDEFINED_MODELS },
+    tools: migratedTools,
+    $schema: config.$schema
+  };
+}
+
+/**
+ * Ensure CLI tools configuration file exists
+ * Creates default config in global ~/.claude directory (user-level config)
+ * @param projectDir - Project directory path (used for reading existing project config)
+ * @param createInProject - DEPRECATED: Always creates in global dir. Kept for backward compatibility.
+ * @returns The config that was created/exists
+ */
+export function ensureClaudeCliTools(projectDir: string, createInProject: boolean = false): ClaudeCliToolsConfig & { _source?: string } {
+  const resolved = resolveConfigPath(projectDir);
+
+  if (resolved.source !== 'default') {
+    // Config exists, load and return it
+    return loadClaudeCliTools(projectDir);
+  }
+
+  // Config doesn't exist - create in global directory only
+  console.log('[claude-cli-tools] Config not found, creating default cli-tools.json in ~/.claude');
+
+  const defaultConfig: ClaudeCliToolsConfig = { ...DEFAULT_TOOLS_CONFIG };
+
+  // Always create in global directory (user-level config)
+  const globalDir = path.join(os.homedir(), '.claude');
+  if (!fs.existsSync(globalDir)) {
+    fs.mkdirSync(globalDir, { recursive: true });
+  }
+  const globalPath = getGlobalConfigPath();
+  try {
+    fs.writeFileSync(globalPath, JSON.stringify(defaultConfig, null, 2), 'utf-8');
+    console.log(`[claude-cli-tools] Created default config at: ${globalPath}`);
+    return { ...defaultConfig, _source: 'global' };
+  } catch (err) {
+    console.error('[claude-cli-tools] Failed to create global config:', err);
+    return { ...defaultConfig, _source: 'default' };
+  }
+}
+
+/**
+ * Load CLI tools configuration from global ~/.claude/cli-tools.json
+ * Falls back to default config if not found.
+ *
+ * Automatically migrates older config versions to v3.2.0
  */
 export function loadClaudeCliTools(projectDir: string): ClaudeCliToolsConfig & { _source?: string } {
   const resolved = resolveConfigPath(projectDir);
 
   try {
     if (resolved.source === 'default') {
-      // No config file found, return defaults
-      return { ...DEFAULT_CONFIG, _source: 'default' };
+      return { ...DEFAULT_TOOLS_CONFIG, _source: 'default' };
     }
 
     const content = fs.readFileSync(resolved.path, 'utf-8');
-    const parsed = JSON.parse(content) as Partial<ClaudeCliToolsConfig>;
+    const parsed = JSON.parse(content) as Partial<ClaudeCliCombinedConfig>;
+
+    // Migrate older versions to v3.2.0
+    const migrated = migrateConfig(parsed, projectDir);
+    const needsSave = migrated.version !== parsed.version;
+
+    // Merge tools with defaults and ensure required fields exist
+    const mergedTools: Record<string, ClaudeCliTool> = {};
+    for (const [key, tool] of Object.entries({ ...DEFAULT_TOOLS_CONFIG.tools, ...(migrated.tools || {}) })) {
+      mergedTools[key] = {
+        ...ensureToolTags(tool),
+        type: tool.type ?? 'builtin',
+        id: tool.id  // Preserve id for api-endpoint type
+      };
+    }
 
-    // Merge with defaults
-    const config = {
-      ...DEFAULT_CONFIG,
-      ...parsed,
-      tools: { ...DEFAULT_CONFIG.tools, ...(parsed.tools || {}) },
-      settings: {
-        ...DEFAULT_CONFIG.settings,
-        ...(parsed.settings || {}),
-        smartContext: {
-          ...DEFAULT_CONFIG.settings.smartContext,
-          ...(parsed.settings?.smartContext || {})
-        },
-        cache: {
-          ...DEFAULT_CONFIG.settings.cache,
-          ...(parsed.settings?.cache || {})
-        }
-      },
+    const config: ClaudeCliToolsConfig & { _source?: string } = {
+      version: migrated.version || DEFAULT_TOOLS_CONFIG.version,
+      models: migrated.models || DEFAULT_TOOLS_CONFIG.models,
+      tools: mergedTools,
+      $schema: migrated.$schema,
       _source: resolved.source
     };
 
-    console.log(`[claude-cli-tools] Loaded config from ${resolved.source}: ${resolved.path}`);
+    // Save migrated config if version changed
+    if (needsSave) {
+      try {
+        saveClaudeCliTools(projectDir, config);
+        console.log(`[claude-cli-tools] Saved migrated config to: ${resolved.path}`);
+      } catch (err) {
+        console.warn('[claude-cli-tools] Failed to save migrated config:', err);
+      }
+    }
+
+    console.log(`[claude-cli-tools] Loaded tools config from ${resolved.source}: ${resolved.path}`);
     return config;
   } catch (err) {
-    console.error('[claude-cli-tools] Error loading config:', err);
-    return { ...DEFAULT_CONFIG, _source: 'default' };
+    console.error('[claude-cli-tools] Error loading tools config:', err);
+    return { ...DEFAULT_TOOLS_CONFIG, _source: 'default' };
   }
 }
 
 /**
- * Save CLI tools configuration to project .claude/cli-tools.json
- * Always saves to project directory (not global)
+ * Save CLI tools configuration to global ~/.claude/cli-tools.json
+ * Always saves to global directory (user-level config)
  */
 export function saveClaudeCliTools(projectDir: string, config: ClaudeCliToolsConfig & { _source?: string }): void {
-  ensureClaudeDir(projectDir);
-  const configPath = getProjectConfigPath(projectDir);
-
-  // Remove internal _source field before saving
   const { _source, ...configToSave } = config;
 
+  // Always save to global directory
+  const globalDir = path.join(os.homedir(), '.claude');
+  if (!fs.existsSync(globalDir)) {
+    fs.mkdirSync(globalDir, { recursive: true });
+  }
+  const configPath = getGlobalConfigPath();
+
   try {
     fs.writeFileSync(configPath, JSON.stringify(configToSave, null, 2), 'utf-8');
-    console.log(`[claude-cli-tools] Saved config to project: ${configPath}`);
+    console.log(`[claude-cli-tools] Saved tools config to: ${configPath}`);
   } catch (err) {
-    console.error('[claude-cli-tools] Error saving config:', err);
+    console.error('[claude-cli-tools] Error saving tools config:', err);
     throw new Error(`Failed to save CLI tools config: ${err}`);
   }
 }
 
+/**
+ * Load CLI settings configuration from global ~/.claude/cli-settings.json
+ * Falls back to default settings if not found.
+ */
+export function loadClaudeCliSettings(projectDir: string): ClaudeCliSettingsConfig & { _source?: string } {
+  const resolved = resolveSettingsPath(projectDir);
+
+  try {
+    if (resolved.source === 'default') {
+      return { ...DEFAULT_SETTINGS_CONFIG, _source: 'default' };
+    }
+
+    const content = fs.readFileSync(resolved.path, 'utf-8');
+    const parsed = JSON.parse(content) as Partial<ClaudeCliSettingsConfig>;
+
+    const config: ClaudeCliSettingsConfig & { _source?: string } = {
+      ...DEFAULT_SETTINGS_CONFIG,
+      ...parsed,
+      smartContext: {
+        ...DEFAULT_SETTINGS_CONFIG.smartContext,
+        ...(parsed.smartContext || {})
+      },
+      cache: {
+        ...DEFAULT_SETTINGS_CONFIG.cache,
+        ...(parsed.cache || {})
+      },
+      _source: resolved.source
+    };
+
+    console.log(`[claude-cli-tools] Loaded settings from ${resolved.source}: ${resolved.path}`);
+    return config;
+  } catch (err) {
+    console.error('[claude-cli-tools] Error loading settings:', err);
+    return { ...DEFAULT_SETTINGS_CONFIG, _source: 'default' };
+  }
+}
+
+/**
+ * Save CLI settings configuration to global ~/.claude/cli-settings.json
+ * Always saves to global directory (user-level config)
+ */
+export function saveClaudeCliSettings(projectDir: string, config: ClaudeCliSettingsConfig & { _source?: string }): void {
+  const { _source, ...configToSave } = config;
+
+  // Always save to global directory
+  const globalDir = path.join(os.homedir(), '.claude');
+  if (!fs.existsSync(globalDir)) {
+    fs.mkdirSync(globalDir, { recursive: true });
+  }
+  const settingsPath = getGlobalSettingsPath();
+
+  try {
+    fs.writeFileSync(settingsPath, JSON.stringify(configToSave, null, 2), 'utf-8');
+    console.log(`[claude-cli-tools] Saved settings to: ${settingsPath}`);
+  } catch (err) {
+    console.error('[claude-cli-tools] Error saving settings:', err);
+    throw new Error(`Failed to save CLI settings: ${err}`);
+  }
+}
+
 /**
  * Update enabled status for a specific tool
  */
@@ -224,16 +554,16 @@ export function updateClaudeToolEnabled(
 export function updateClaudeCacheSettings(
   projectDir: string,
   cacheSettings: Partial<ClaudeCacheSettings>
-): ClaudeCliToolsConfig {
-  const config = loadClaudeCliTools(projectDir);
+): ClaudeCliSettingsConfig {
+  const settings = loadClaudeCliSettings(projectDir);
 
-  config.settings.cache = {
-    ...config.settings.cache,
+  settings.cache = {
+    ...settings.cache,
     ...cacheSettings
   };
 
-  saveClaudeCliTools(projectDir, config);
-  return config;
+  saveClaudeCliSettings(projectDir, settings);
+  return settings;
 }
 
 /**
@@ -242,28 +572,84 @@ export function updateClaudeCacheSettings(
 export function updateClaudeDefaultTool(
   projectDir: string,
   defaultTool: string
+): ClaudeCliSettingsConfig {
+  const settings = loadClaudeCliSettings(projectDir);
+  settings.defaultTool = defaultTool;
+  saveClaudeCliSettings(projectDir, settings);
+  return settings;
+}
+
+/**
+ * Add API endpoint as a tool with type: 'api-endpoint'
+ * Usage: --tool <name> or --tool custom --model <id>
+ */
+export function addClaudeApiEndpoint(
+  projectDir: string,
+  endpoint: { id: string; name: string; enabled: boolean }
+): ClaudeCliToolsConfig {
+  const config = loadClaudeCliTools(projectDir);
+
+  // Add as a tool with type: 'api-endpoint'
+  config.tools[endpoint.name] = {
+    enabled: endpoint.enabled,
+    tags: [],
+    type: 'api-endpoint',
+    id: endpoint.id  // Store endpoint ID for settings lookup
+  };
+
+  saveClaudeCliTools(projectDir, config);
+  return config;
+}
+
+/**
+ * Remove API endpoint tool by id or name
+ */
+export function removeClaudeApiEndpoint(
+  projectDir: string,
+  endpointId: string
 ): ClaudeCliToolsConfig {
   const config = loadClaudeCliTools(projectDir);
-  config.defaultTool = defaultTool;
+
+  // Find the tool by id or name
+  const toolToRemove = Object.entries(config.tools).find(
+    ([name, t]) => t.type === 'api-endpoint' && (t.id === endpointId || name === endpointId || name.toLowerCase() === endpointId.toLowerCase())
+  );
+
+  if (toolToRemove) {
+    delete config.tools[toolToRemove[0]];
+  }
+
   saveClaudeCliTools(projectDir, config);
   return config;
 }
 
 /**
- * Add custom endpoint
+ * @deprecated Use addClaudeApiEndpoint instead
+ * Adds tool to config based on tags:
+ * - cli-wrapper tag -> type: 'cli-wrapper'
+ * - others -> type: 'api-endpoint'
  */
 export function addClaudeCustomEndpoint(
   projectDir: string,
-  endpoint: { id: string; name: string; enabled: boolean }
+  endpoint: { id: string; name: string; enabled: boolean; tags?: string[] }
 ): ClaudeCliToolsConfig {
   const config = loadClaudeCliTools(projectDir);
 
-  // Check if endpoint already exists
-  const existingIndex = config.customEndpoints.findIndex(e => e.id === endpoint.id);
-  if (existingIndex >= 0) {
-    config.customEndpoints[existingIndex] = endpoint;
+  if (endpoint.tags?.includes('cli-wrapper')) {
+    // CLI wrapper tool
+    config.tools[endpoint.name] = {
+      enabled: endpoint.enabled,
+      tags: endpoint.tags.filter(t => t !== 'cli-wrapper'),
+      type: 'cli-wrapper'
+    };
   } else {
-    config.customEndpoints.push(endpoint);
+    // API endpoint tool
+    config.tools[endpoint.name] = {
+      enabled: endpoint.enabled,
+      tags: [],
+      type: 'api-endpoint',
+      id: endpoint.id
+    };
   }
 
   saveClaudeCliTools(projectDir, config);
@@ -271,14 +657,24 @@ export function addClaudeCustomEndpoint(
 }
 
 /**
- * Remove custom endpoint
+ * Remove endpoint tool (cli-wrapper or api-endpoint)
  */
 export function removeClaudeCustomEndpoint(
   projectDir: string,
   endpointId: string
 ): ClaudeCliToolsConfig {
   const config = loadClaudeCliTools(projectDir);
-  config.customEndpoints = config.customEndpoints.filter(e => e.id !== endpointId);
+
+  // Find the tool by id or name (cli-wrapper or api-endpoint type)
+  const toolToRemove = Object.entries(config.tools).find(
+    ([name, t]) => (t.type === 'cli-wrapper' || t.type === 'api-endpoint') &&
+      (name === endpointId || name.toLowerCase() === endpointId.toLowerCase() || t.id === endpointId)
+  );
+
+  if (toolToRemove) {
+    delete config.tools[toolToRemove[0]];
+  }
+
   saveClaudeCliTools(projectDir, config);
   return config;
 }
@@ -309,12 +705,12 @@ export function getClaudeCliToolsInfo(projectDir: string): {
 export function updateCodeIndexMcp(
   projectDir: string,
   provider: 'codexlens' | 'ace' | 'none'
-): { success: boolean; error?: string; config?: ClaudeCliToolsConfig } {
+): { success: boolean; error?: string; settings?: ClaudeCliSettingsConfig } {
   try {
-    // Update config
-    const config = loadClaudeCliTools(projectDir);
-    config.settings.codeIndexMcp = provider;
-    saveClaudeCliTools(projectDir, config);
+    // Update settings config
+    const settings = loadClaudeCliSettings(projectDir);
+    settings.codeIndexMcp = provider;
+    saveClaudeCliSettings(projectDir, settings);
 
     // Only update global CLAUDE.md (consistent with Chinese response / Windows platform)
     const globalClaudeMdPath = path.join(os.homedir(), '.claude', 'CLAUDE.md');
@@ -358,7 +754,7 @@ export function updateCodeIndexMcp(
       console.log(`[claude-cli-tools] Updated global CLAUDE.md to use ${provider}`);
     }
 
-    return { success: true, config };
+    return { success: true, settings };
   } catch (err) {
     console.error('[claude-cli-tools] Error updating Code Index MCP:', err);
     return { success: false, error: (err as Error).message };
@@ -369,8 +765,8 @@ export function updateCodeIndexMcp(
  * Get current Code Index MCP provider
  */
 export function getCodeIndexMcp(projectDir: string): 'codexlens' | 'ace' | 'none' {
-  const config = loadClaudeCliTools(projectDir);
-  return config.settings.codeIndexMcp || 'codexlens';
+  const settings = loadClaudeCliSettings(projectDir);
+  return settings.codeIndexMcp || 'ace';
 }
 
 /**
@@ -386,3 +782,122 @@ export function getContextToolsPath(provider: 'codexlens' | 'ace' | 'none'): str
       return 'context-tools.md';
   }
 }
+
+// ========== Model Configuration Functions ==========
+
+/**
+ * Get predefined models for a specific tool
+ */
+export function getPredefinedModels(tool: string): string[] {
+  const toolName = tool as CliToolName;
+  return PREDEFINED_MODELS[toolName] ? [...PREDEFINED_MODELS[toolName]] : [];
+}
+
+/**
+ * Get all predefined models
+ */
+export function getAllPredefinedModels(): Record<string, string[]> {
+  return { ...PREDEFINED_MODELS };
+}
+
+/**
+ * Get tool configuration (compatible with cli-config-manager interface)
+ */
+export function getToolConfig(projectDir: string, tool: string): {
+  enabled: boolean;
+  primaryModel: string;
+  secondaryModel: string;
+  tags?: string[];
+} {
+  const config = loadClaudeCliTools(projectDir);
+  const toolConfig = config.tools[tool];
+
+  if (!toolConfig) {
+    const defaultTool = DEFAULT_TOOLS_CONFIG.tools[tool];
+    return {
+      enabled: defaultTool?.enabled ?? true,
+      primaryModel: defaultTool?.primaryModel ?? '',
+      secondaryModel: defaultTool?.secondaryModel ?? '',
+      tags: defaultTool?.tags ?? []
+    };
+  }
+
+  return {
+    enabled: toolConfig.enabled,
+    primaryModel: toolConfig.primaryModel ?? '',
+    secondaryModel: toolConfig.secondaryModel ?? '',
+    tags: toolConfig.tags
+  };
+}
+
+/**
+ * Update tool configuration
+ */
+export function updateToolConfig(
+  projectDir: string,
+  tool: string,
+  updates: Partial<{
+    enabled: boolean;
+    primaryModel: string;
+    secondaryModel: string;
+    tags: string[];
+  }>
+): ClaudeCliToolsConfig {
+  const config = loadClaudeCliTools(projectDir);
+
+  if (config.tools[tool]) {
+    if (updates.enabled !== undefined) {
+      config.tools[tool].enabled = updates.enabled;
+    }
+    if (updates.primaryModel !== undefined) {
+      config.tools[tool].primaryModel = updates.primaryModel;
+    }
+    if (updates.secondaryModel !== undefined) {
+      config.tools[tool].secondaryModel = updates.secondaryModel;
+    }
+    if (updates.tags !== undefined) {
+      config.tools[tool].tags = updates.tags;
+    }
+    saveClaudeCliTools(projectDir, config);
+  }
+
+  return config;
+}
+
+/**
+ * Get primary model for a tool
+ */
+export function getPrimaryModel(projectDir: string, tool: string): string {
+  const toolConfig = getToolConfig(projectDir, tool);
+  return toolConfig.primaryModel;
+}
+
+/**
+ * Get secondary model for a tool
+ */
+export function getSecondaryModel(projectDir: string, tool: string): string {
+  const toolConfig = getToolConfig(projectDir, tool);
+  return toolConfig.secondaryModel;
+}
+
+/**
+ * Check if a tool is enabled
+ */
+export function isToolEnabled(projectDir: string, tool: string): boolean {
+  const toolConfig = getToolConfig(projectDir, tool);
+  return toolConfig.enabled;
+}
+
+/**
+ * Get full config response for API (includes predefined models)
+ */
+export function getFullConfigResponse(projectDir: string): {
+  config: ClaudeCliToolsConfig;
+  predefinedModels: Record<string, string[]>;
+} {
+  const config = loadClaudeCliTools(projectDir);
+  return {
+    config,
+    predefinedModels: { ...PREDEFINED_MODELS }
+  };
+}