feat: add configurable Claude model selection

- Add support for multiple Claude models (3.5/3.7 Sonnet, 4 Sonnet/Opus)
- Implement smart planner model selection based on main model
- Add conditional thinking capabilities (disabled for 3.5 Sonnet)
- Enhance cost tracking with model-specific pricing
- Add new settings commands: --set-model and --list-models
- Include cost warnings for expensive models (4 Opus)
- Update documentation with model configuration guide

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>

Author: PrashamTrivedi

CHANGELOG.md

@@ -10,6 +10,13 @@
 
 ### Latest Changes (since v1.2)
 
+- **Configurable Models**: Added support for user-selectable Claude models
+  - Support for Claude 3.5 Sonnet, 3.7 Sonnet, 4 Sonnet, and 4 Opus
+  - Smart planner model selection based on main model choice
+  - Conditional thinking capabilities (disabled for 3.5 Sonnet)
+  - Multi-model cost tracking with model-specific pricing
+  - New settings commands: `--set-model` and `--list-models`
+  - Cost warnings for expensive models (4 Opus)
 - Added new export functionality with prompt ID-based system
 - Enhanced session logging capabilities
 - Refactored user settings management for improved efficiency

README.md

@@ -11,6 +11,11 @@ bash command execution capabilities using Claude 3 API.
   - Editor mode for AI-assisted text file manipulation
   - Bash mode for intelligent command execution
   - Hybrid mode for combined capabilities
+- **Configurable AI Models**:
+  - Support for multiple Claude models (3.5 Sonnet, 3.7 Sonnet, 4 Sonnet, 4 Opus)
+  - Smart planner model selection based on main model choice
+  - Model-specific cost tracking and pricing
+  - Easy model switching via settings commands
 - **Enhanced Export System**:
   - Prompt ID-based export functionality
   - Dedicated export paths
@@ -24,8 +29,11 @@ bash command execution capabilities using Claude 3 API.
 - **Comprehensive Logging**
   - Text response content tracking
   - Debug logging for history entries
-  - Token usage tracking
-- **Cost Calculation**
+  - Multi-model token usage tracking
+- **Advanced Cost Calculation**
+  - Model-specific pricing
+  - Per-model cost breakdown
+  - Cost warnings for expensive models
 - **History Management** with database integration
 - **Clipboard Management** with cross-platform support
 - **Tool Configuration Management**
@@ -90,6 +98,32 @@ deno run -A src/main.ts --mode=bash --no-agi "your command"
 ./build/ComputerUseAgent --export "prompt-id" # Export session data
 ```
 
+### Model Configuration
+
+Configure which Claude model to use for AI operations:
+
+```sh
+# Set model to Claude 4 Sonnet
+deno run -A src/main.ts settings --set-model "4-sonnet"
+
+# List available models
+deno run -A src/main.ts settings --list-models
+
+# View current settings including selected model
+deno run -A src/main.ts settings --list
+```
+
+**Available Models:**
+- `3.5-sonnet` - Claude 3.5 Sonnet (Default, most cost-effective)
+- `3.7-sonnet` - Claude 3.7 Sonnet (Enhanced reasoning capabilities)
+- `4-sonnet` - Claude 4 Sonnet (Latest generation)
+- `4-opus` - Claude 4 Opus (Most capable, higher cost)
+
+**Smart Features:**
+- Automatic planner model selection based on your chosen model
+- Model-specific cost tracking and warnings
+- Thinking capabilities automatically enabled for supported models
+
 ## Project Structure
 
 - `src/`: Source code directory

plans/configurableModels.md

@@ -0,0 +1,135 @@
+# Configurable Models Implementation Plan
+
+## Overview
+Add user-configurable model selection to ComputerUseAgent, allowing users to choose between different Claude models via settings.
+
+## Supported Models
+- `claude-3-5-sonnet-20241022` (3.5 Sonnet) - Default
+- `claude-3-7-sonnet-20250219` (3.7 Sonnet) 
+- `claude-sonnet-4-20250514` (4 Sonnet)
+- `claude-opus-4-20250514` (4 Opus)
+
+## Implementation Steps
+
+### 1. Update UserSettings Interface
+- Add `model?: string` field to `UserSettings` interface in `src/types/interfaces.ts`
+- Set default model to current model (`claude-3-5-sonnet-20241022`)
+
+### 2. Update Settings Configuration
+- Modify `DEFAULT_SETTINGS` in `src/config/settings.ts` to include default model
+- Add helper function `getSelectedModel()` to retrieve user's model preference
+- Add model validation function to ensure only supported models are allowed
+
+### 3. Update Constants Configuration
+- Modify `API_CONFIG` in `src/config/constants.ts` to use configurable model
+- Replace hardcoded `MODEL` with dynamic model selection
+- **Smart Planner Model Selection**: Configure `REASONING_MODEL` based on main model:
+  - If main model is 3.5 Sonnet → Use 3.7 Sonnet for planning BUT exclude thinking budget
+  - If main model is 3.7 Sonnet → Use 3.7 Sonnet for planning with thinking capabilities
+  - If main model is 4 Sonnet/Opus → Use same model for planning with full thinking capabilities
+- Keep `INTENT_MODEL` (Haiku) separate as it serves specific purposes
+
+### 4. Update Settings Command
+- Add `--set-model` flag to settings command in `src/commands/settings.ts`
+- Add `--list-models` flag to show available models
+- Include model validation when setting new model
+- Update help text to include model configuration options
+
+### 5. Update Session Classes
+- Modify classes that use `API_CONFIG.MODEL` to dynamically get model from settings
+- Ensure all Claude API calls use the configured model
+- **Implement Thinking Budget Control**: Modify planner to conditionally include thinking based on model
+- **Update cost tracking calls**: Add model name parameter to updateTokenUsage() calls
+- Key files to update:
+  - `src/modules/hybrid/hybrid_session.ts` - Update token tracking with model names
+  - `src/modules/planner/planner.ts` - Add logic to exclude thinking budget for 3.5 Sonnet, track planning model costs
+  - Any other files that directly reference `API_CONFIG.MODEL`
+
+### 6. Update Cost Tracking Infrastructure
+- **SessionLogger class**: Add model-specific token tracking
+- **Database schema**: Keep existing cost field for backward compatibility
+- **Cost calculation**: Create model pricing lookup function
+- **API call sites**: Pass model name to updateTokenUsage() throughout codebase
+
+## Model Mapping
+Create a mapping between user-friendly names and actual model identifiers:
+```typescript
+const MODEL_MAP = {
+  "3.5-sonnet": "claude-3-5-sonnet-20241022",
+  "3.7-sonnet": "claude-3-7-sonnet-20250219", 
+  "4-sonnet": "claude-sonnet-4-20250514",
+  "4-opus": "claude-opus-4-20250514"
+}
+```
+
+## Usage Examples
+```bash
+# Set model to 4 Sonnet
+deno run -A src/main.ts settings --set-model "4-sonnet"
+
+# List available models
+deno run -A src/main.ts settings --list-models
+
+# View current settings including model
+deno run -A src/main.ts settings --list
+```
+
+## Cost Tracking and Reporting
+
+### Model Pricing (as of May 2025)
+Based on current Anthropic pricing:
+
+| Model | Input Price (per 1M tokens) | Output Price (per 1M tokens) | With Caching Input (90% off) | With Caching Output (90% off) |
+|-------|----------------------------|------------------------------|------------------------------|-------------------------------|
+| 3.5 Sonnet | $3.00 | $15.00 | $0.30 | $1.50 |
+| 3.7 Sonnet | $3.00 | $15.00 | $0.30 | $1.50 |
+| **4 Sonnet** | **$3.00** | **$15.00** | **$0.30** | **$1.50** |
+| **4 Opus** | **$15.00** | **$75.00** | **$1.50** | **$7.50** |
+
+### Current Cost Implementation Analysis
+**Existing Cost Tracking (SessionLogger in src/utils/session.ts):**
+1. **Hard-coded pricing**: Uses fixed $3/$15 per million tokens (3.5/3.7 Sonnet pricing)
+2. **Single model tracking**: Only tracks one set of tokens per session 
+3. **Simple aggregation**: Combines all token usage regardless of which model was used
+4. **Database storage**: Saves total cost per session to SQLite database
+
+**Current Limitations:**
+1. **No model-specific costs**: All API calls treated as same model pricing
+2. **Planning model invisible**: REASONING_MODEL usage not tracked separately
+3. **Fixed pricing**: Doesn't account for different model costs (4 Opus is 5x more expensive)
+4. **No per-model breakdown**: Can't see which model consumed which tokens
+
+### Enhanced Cost Tracking Implementation
+**Update SessionLogger class (src/utils/session.ts):**
+1. **Dynamic pricing**: Replace hard-coded costs with model-specific pricing lookup
+2. **Multi-model tracking**: Track tokens per model type (main vs planning)
+3. **Cost breakdown**: Maintain separate cost calculations for each model
+4. **Backward compatibility**: Keep existing getTotalCost() for database storage
+
+**Changes needed in SessionLogger:**
+```typescript
+class SessionLogger {
+  private modelTokenUsage = new Map<string, {input: number, output: number}>()
+  
+  updateTokenUsage(inputTokens: number, outputTokens: number, modelName: string): void
+  getModelCosts(): Map<string, number>
+  getTotalCost(): number // Updated to sum all model costs
+}
+```
+
+**Update cost calculation methods:**
+- Replace hard-coded $3/$15 with dynamic pricing based on model
+- Add model parameter to updateTokenUsage() calls
+- Modify getTotalCost() to sum costs across all models used
+
+## Validation Rules
+- Only allow predefined model names
+- Provide clear error messages for invalid models
+- Fall back to default model if configured model becomes invalid
+- Warn users about cost implications when selecting expensive models
+
+## Backward Compatibility
+- Existing users without model setting will use default (3.5 Sonnet)
+- No breaking changes to existing functionality
+- Settings file will be automatically updated with default model on first access
+- Cost tracking will start from implementation date forward

src/commands/settings.ts

@@ -1,11 +1,11 @@
 import {parseArgs} from "jsr:@std/cli/parse-args"
-import {loadUserSettings, saveUserSettings} from "../config/settings.ts"
+import {loadUserSettings, saveUserSettings, validateModel, getAvailableModels} from "../config/settings.ts"
 import {parseFlagForHelp} from "../utils/functions.ts"
 
 export async function handleSettings(args: string[]): Promise<void> {
     const settingsFlags = {
-        string: ["set-name", "set-jina-key", "set-config", "set-editor"],
-        boolean: ["list"],
+        string: ["set-name", "set-jina-key", "set-config", "set-editor", "set-model"],
+        boolean: ["list", "list-models"],
     }
     const flags = parseArgs(args, settingsFlags)
 
@@ -26,6 +26,30 @@ export async function handleSettings(args: string[]): Promise<void> {
         settings.jinaApiKey = flags["set-jina-key"]
         console.log("Jina API key has been set")
     }
+    else if (flags["list-models"]) {
+        const models = getAvailableModels()
+        console.log("Available models:")
+        models.forEach(model => {
+            const current = settings.model === model ? " (current)" : ""
+            console.log(`  ${model}${current}`)
+        })
+        return
+    }
+    else if (flags["set-model"]) {
+        const model = flags["set-model"]
+        if (!validateModel(model)) {
+            console.error(`Invalid model: ${model}`)
+            console.log("Available models:", getAvailableModels().join(", "))
+            return
+        }
+        settings.model = model
+        console.log(`Model set to: ${model}`)
+        
+        // Warn about cost implications for expensive models
+        if (model === "4-opus") {
+            console.log("⚠️  Warning: 4 Opus is significantly more expensive than other models")
+        }
+    }
     else if (flags.list) {
         console.log(JSON.stringify(settings, null, 2))
         return

src/config/constants.ts

@@ -1,7 +1,7 @@
 import {join} from "jsr:@std/path"
 import Anthropic from "anthropic"
 import {homedir} from "node:os"
-import {isJinaAvailable, loadUserSettings} from "./settings.ts"
+import {isJinaAvailable, loadUserSettings, getSelectedModel, getModelMap} from "./settings.ts"
 
 export const EDITOR_DIR = join(homedir(), ".ComputerUseAgent", "editor_dir")
 export const SESSIONS_DIR = join(homedir(), ".ComputerUseAgent", "sessions")
@@ -143,16 +143,41 @@ Note: When chaining operations, use separate BASH_TOOL commands and store result
 
 `
 
-export const API_CONFIG = {
-    MODEL: "claude-3-5-sonnet-20241022",
-    REASONING_MODEL: "claude-3-7-sonnet-20250219",
-    INTENT_MODEL: "claude-3-5-haiku-20241022",
-    MAX_TOKENS: 8192,
-    MIN_THINKING_TOKENS: 1024,
-    MAX_TOKENS_WHEN_THINKING: 20000,
-    MAX_INTENT_TOKENS: 20,
+function getReasoningModel(mainModel: string): string {
+    const modelMap = getModelMap()
+
+    if (mainModel === modelMap["3.5-sonnet"]) {
+        return modelMap["3.7-sonnet"]
+    } else {
+        return mainModel
+    }
+
+}
+
+function shouldUseThinking(mainModel: string): boolean {
+    const modelMap = getModelMap()
+    return mainModel !== modelMap["3.5-sonnet"]
 }
 
+export function getAPIConfig() {
+    const selectedModel = getSelectedModel()
+    const reasoningModel = getReasoningModel(selectedModel)
+    const useThinking = shouldUseThinking(selectedModel)
+
+    return {
+        MODEL: selectedModel,
+        REASONING_MODEL: reasoningModel,
+        INTENT_MODEL: "claude-3-5-haiku-20241022",
+        USE_THINKING: useThinking,
+        MAX_TOKENS: 8192,
+        MIN_THINKING_TOKENS: useThinking ? 1024 : 0,
+        MAX_TOKENS_WHEN_THINKING: useThinking ? 20000 : 8192,
+        MAX_INTENT_TOKENS: 20,
+    }
+}
+
+export const API_CONFIG = getAPIConfig()
+
 export const MEMORY_TOOLS: Anthropic.Beta.BetaTool[] = [
     {
         name: "add_memory",

src/config/settings.ts

@@ -2,11 +2,19 @@ import {join} from "jsr:@std/path"
 import {homedir} from "node:os"
 import {UserSettings} from "../types/interfaces.ts"
 
+const MODEL_MAP = {
+  "3.5-sonnet": "claude-3-5-sonnet-20241022",
+  "3.7-sonnet": "claude-3-7-sonnet-20250219", 
+  "4-sonnet": "claude-sonnet-4-20250514",
+  "4-opus": "claude-opus-4-20250514"
+} as const
+
 const DEFAULT_SETTINGS: UserSettings = {
     userName: "User",
     jinaApiKey: undefined,
     toolConfigPath: join(homedir(), ".ComputerUseAgent", "tools.json"),
-    editorCommand: "nano"
+    editorCommand: "nano",
+    model: "3.5-sonnet"
 }
 
 const SETTINGS_PATH = join(homedir(), ".ComputerUseAgent", "settings.json")
@@ -38,3 +46,21 @@ export function getConfigFileLocation(): string {
     const settings = loadUserSettings()
     return settings.toolConfigPath
 }
+
+export function getSelectedModel(): string {
+    const settings = loadUserSettings()
+    const modelKey = settings.model || "3.5-sonnet"
+    return MODEL_MAP[modelKey as keyof typeof MODEL_MAP] || MODEL_MAP["3.5-sonnet"]
+}
+
+export function validateModel(model: string): boolean {
+    return model in MODEL_MAP
+}
+
+export function getAvailableModels(): string[] {
+    return Object.keys(MODEL_MAP)
+}
+
+export function getModelMap(): typeof MODEL_MAP {
+    return MODEL_MAP
+}

src/modules/hybrid/hybrid_session.ts

@@ -1,5 +1,5 @@
 import {BaseSession} from "../../utils/session.ts"
-import {API_CONFIG} from "../../config/constants.ts"
+import {getAPIConfig} from "../../config/constants.ts"
 import {log} from "../../config/logging.ts"
 import {ToolHandler} from "../../utils/tool_handler.ts"
 import {getConfigFileLocation} from "../../config/settings.ts"
@@ -54,9 +54,10 @@ export class HybridSession extends BaseSession {
 
                 try {
                     while (true) {
+                        const apiConfig = getAPIConfig()
                         const response = await this.client.beta.messages.create({
-                            model: API_CONFIG.MODEL,
-                            max_tokens: API_CONFIG.MAX_TOKENS,
+                            model: apiConfig.MODEL,
+                            max_tokens: apiConfig.MAX_TOKENS,
                             messages: this.messages,
                             tools: [
                                 {type: "bash_20241022", name: "bash"},
@@ -69,7 +70,7 @@ export class HybridSession extends BaseSession {
 
                         const inputTokens = response.usage?.input_tokens ?? 0
                         const outputTokens = response.usage?.output_tokens ?? 0
-                        this.logger.updateTokenUsage(inputTokens, outputTokens)
+                        this.logger.updateTokenUsage(inputTokens, outputTokens, apiConfig.MODEL)
 
                         const responseContent = response.content.map((block) =>
                             block.type === "text" ? {type: "text", text: block.text} : block