chorus-cli 0.4.1 → 0.4.4

package/index.js

@@ -7,8 +7,9 @@ const _localEnv = _path.join(__dirname, '.env');
 // Prefer user config dir (works when installed globally), fall back to local .env for dev
 require('dotenv').config({ path: require('fs').existsSync(_configEnv) ? _configEnv : _localEnv });
 const { Octokit } = require('@octokit/rest');
-const Anthropic = require('@anthropic-ai/sdk');
+
 const { createProvider } = require('./providers');
+const OpenAI = require('openai');
 const { exec, execFile, spawn } = require('child_process');
 const util = require('util');
 const path = require('path');
@@ -17,13 +18,53 @@ const execPromise = util.promisify(exec);
 const execFilePromise = util.promisify(execFile);
 const fs = require('fs').promises;
 
+// Returns a stable hardware UUID for this machine, with a persistent fallback
+async function getMachineId() {
+  try {
+    if (process.platform === 'darwin') {
+      const { stdout } = await execPromise(
+        "ioreg -rd1 -c IOPlatformExpertDevice | awk -F'\"' '/IOPlatformUUID/{print $4}'"
+      );
+      if (stdout.trim()) return stdout.trim();
+    } else if (process.platform === 'linux') {
+      const fsp = require('fs').promises;
+      const id = (await fsp.readFile('/etc/machine-id', 'utf8')).trim();
+      if (id) return id;
+    } else if (process.platform === 'win32') {
+      const { stdout } = await execPromise('wmic csproduct get UUID');
+      const lines = stdout.trim().split('\n');
+      if (lines.length > 1) {
+        const uuid = lines[1].trim();
+        if (uuid && uuid !== 'FFFFFFFF-FFFF-FFFF-FFFF-FFFFFFFFFFFF') return uuid;
+      }
+    }
+  } catch { /* fall through to persistent fallback */ }
+
+  // Persistent fallback: generate and cache a random UUID
+  const configDir = path.join(os.homedir(), '.config', 'chorus');
+  const idPath = path.join(configDir, 'machine-id');
+  try {
+    const existing = await fs.readFile(idPath, 'utf8');
+    if (existing.trim()) return existing.trim();
+  } catch { /* no file yet */ }
+
+  const { randomUUID } = require('crypto');
+  const newId = randomUUID();
+  await fs.mkdir(configDir, { recursive: true });
+  await fs.writeFile(idPath, newId + '\n');
+  return newId;
+}
+
 // Run coder.py with real-time stderr streaming so progress is visible
 function runCoder(prompt) {
   return new Promise((resolve, reject) => {
     const env = { ...process.env };
-    if (CONFIG.ai.proxyUrl) {
-      env.CODER_PROXY_URL = CONFIG.ai.proxyUrl;
-      env.ANTHROPIC_API_KEY = CONFIG.ai.anthropicApiKey;
+    if (CONFIG.ai.chorusApiKey) {
+      env.CHORUS_API_KEY = CONFIG.ai.chorusApiKey;
+      env.CHORUS_API_URL = CONFIG.ai.chorusApiUrl;
+    }
+    if (CONFIG.ai.machineId) {
+      env.CHORUS_MACHINE_ID = CONFIG.ai.machineId;
     }
     const proc = spawn(CONFIG.ai.venvPython, [CONFIG.ai.coderPath, '--prompt', prompt], {
       cwd: process.cwd(),
@@ -72,9 +113,12 @@ function runQAChat(issue, enrichedDetails, qaName, useSuper = false) {
     if (useSuper) args.push('--super');
 
     const env = { ...process.env };
-    if (CONFIG.ai.proxyUrl) {
-      env.CODER_PROXY_URL = CONFIG.ai.proxyUrl;
-      env.ANTHROPIC_API_KEY = CONFIG.ai.anthropicApiKey;
+    if (CONFIG.ai.chorusApiKey) {
+      env.CHORUS_API_KEY = CONFIG.ai.chorusApiKey;
+      env.CHORUS_API_URL = CONFIG.ai.chorusApiUrl;
+    }
+    if (CONFIG.ai.machineId) {
+      env.CHORUS_MACHINE_ID = CONFIG.ai.machineId;
     }
     if (CONFIG.messenger === 'slack' && CONFIG.slack.botToken) {
       env.SLACK_BOT_TOKEN = CONFIG.slack.botToken;
@@ -142,8 +186,8 @@ const CONFIG = {
     venvPython: process.platform === 'win32'
       ? path.join(os.homedir(), '.config', 'chorus', '.venv', 'Scripts', 'python.exe')
       : path.join(os.homedir(), '.config', 'chorus', '.venv', 'bin', 'python'),
-    anthropicApiKey: process.env.PROXY_API_KEY || process.env.ANTHROPIC_API_KEY,
-    proxyUrl: process.env.PROXY_URL,
+    chorusApiKey: process.env.CHORUS_API_KEY,
+    chorusApiUrl: process.env.CHORUS_API_URL || 'https://chorus-bad0f.web.app/v1',
   }
 };
 
@@ -189,20 +233,21 @@ IMPORTANT: Output ONLY the message above. Do not include any preamble, thinking
   const tool = CONFIG.ai.enrichmentTool;
   
   if (tool === 'claude') {
-    // Use Anthropic API
-    if (!CONFIG.ai.anthropicApiKey) {
-      throw new Error('PROXY_API_KEY or ANTHROPIC_API_KEY environment variable is required');
+    // Use Chorus proxy API
+    if (!CONFIG.ai.chorusApiKey) {
+      throw new Error('CHORUS_API_KEY environment variable is required. Run "chorus setup" to configure.');
     }
-    const clientOpts = { apiKey: CONFIG.ai.anthropicApiKey };
-    if (CONFIG.ai.proxyUrl) {
-      clientOpts.baseURL = CONFIG.ai.proxyUrl.replace(/\/+$/, '');
+    const openaiOpts = {
+      apiKey: CONFIG.ai.chorusApiKey,
+      baseURL: CONFIG.ai.chorusApiUrl,
+    };
+    if (CONFIG.ai.machineId) {
+      openaiOpts.defaultHeaders = { 'X-Machine-Id': CONFIG.ai.machineId };
     }
-    const anthropic = new Anthropic(clientOpts);
+    const openai = new OpenAI(openaiOpts);
     
-    const message = await anthropic.messages.create({
-
-      //when --super flag is added use claude-opus-4-6, else default to claude-sonnet-4-20250514
-      model: 'claude-opus-4-6',
+    const response = await openai.chat.completions.create({
+      model: 'anthropic/claude-opus-4',
       max_tokens: 2000,
       messages: [
         {
@@ -212,11 +257,11 @@ IMPORTANT: Output ONLY the message above. Do not include any preamble, thinking
       ]
     });
 
-    if (message.usage) {
-      console.log(`   Enrichment tokens: ${message.usage.input_tokens} in / ${message.usage.output_tokens} out`);
+    if (response.usage) {
+      console.log(`   Enrichment tokens: ${response.usage.prompt_tokens} in / ${response.usage.completion_tokens} out`);
     }
 
-    return message.content[0].text.trim();
+    return response.choices[0].message.content.trim();
   } else {
     // Use Kimi CLI
     const escapedPrompt = prompt.replace(/"/g, '\\"').replace(/\$/g, '\\$');
@@ -488,16 +533,7 @@ function isTokenLimitError(err) {
 }
 
 async function fetchAccountEmail() {
-  if (!CONFIG.ai.proxyUrl || !CONFIG.ai.anthropicApiKey) return null;
-  try {
-    const res = await fetch(`${CONFIG.ai.proxyUrl.replace(/\/+$/, '')}/auth/me`, {
-      headers: { 'Authorization': `Bearer ${CONFIG.ai.anthropicApiKey}` },
-    });
-    if (res.ok) {
-      const data = await res.json();
-      return data.email || null;
-    }
-  } catch {}
+  // TODO: fetch email from Chorus proxy /auth/me endpoint
   return null;
 }
 
@@ -517,6 +553,9 @@ async function processTicket(issueArg, { useSuper = false, skipQA = false, qaNam
   try {
     console.log('🚀 Starting ticket processing...\n');
 
+    // Resolve machine fingerprint for per-machine usage tracking
+    CONFIG.ai.machineId = await getMachineId();
+
     // 0. Ensure Python venv exists and has required dependencies
     const reqFile = path.join(__dirname, 'tools', 'requirements.txt');
     const { execFileSync: efs } = require('child_process');
@@ -528,7 +567,7 @@ async function processTicket(issueArg, { useSuper = false, skipQA = false, qaNam
     }
 
     try {
-      efs(CONFIG.ai.venvPython, ['-c', 'import anthropic'], { stdio: 'ignore' });
+      efs(CONFIG.ai.venvPython, ['-c', 'import openai'], { stdio: 'ignore' });
     } catch {
       console.log('📦 Installing Python dependencies (first run)...');
       efs(CONFIG.ai.venvPython, ['-m', 'pip', 'install', '-r', reqFile], { stdio: 'inherit' });
@@ -864,26 +903,6 @@ async function setupGitHub() {
 }
 
 async function setupProxyAuth() {
-  const DEFAULT_PROXY_URL = 'https://chorus-bad0f.web.app';
-
-  if (!CONFIG.ai.proxyUrl) {
-    CONFIG.ai.proxyUrl = DEFAULT_PROXY_URL;
-
-    // Persist PROXY_URL to .env
-    const configDir = path.join(os.homedir(), '.config', 'chorus');
-    await fs.mkdir(configDir, { recursive: true });
-    const envPath = path.join(configDir, '.env');
-    let envContent = '';
-    try { envContent = await fs.readFile(envPath, 'utf8'); } catch { /* no .env yet */ }
-    if (envContent.includes('PROXY_URL=')) {
-      envContent = envContent.replace(/PROXY_URL=.*/, `PROXY_URL=${CONFIG.ai.proxyUrl}`);
-    } else {
-      envContent = envContent.trimEnd() + `\nPROXY_URL=${CONFIG.ai.proxyUrl}`;
-    }
-    await fs.writeFile(envPath, envContent.trimEnd() + '\n');
-    process.env.PROXY_URL = CONFIG.ai.proxyUrl;
-  }
-
   console.log('Setting up Chorus authentication...\n');
 
   const readline = require('readline');
@@ -893,35 +912,62 @@ async function setupProxyAuth() {
   const password = await prompt(rl, 'Password: ', true);
   rl.close();
 
-  // Try register first, fall back to login
+  if (!email || !password) {
+    console.error('\n❌ Email and password are required.');
+    return;
+  }
+
+  const baseUrl = CONFIG.ai.chorusApiUrl.replace(/\/v1\/?$/, '');
+
+  // Resolve machine fingerprint so the server can track per-machine usage
+  const machineId = await getMachineId();
+
+  // Try register first, fall back to login if already registered
   let apiKey;
-  for (const endpoint of ['/auth/register', '/auth/login']) {
-    const res = await fetch(`${CONFIG.ai.proxyUrl}${endpoint}`, {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({ email, password }),
+  try {
+    const https = require('https');
+    const http = require('http');
+
+    const doPost = (url, body) => new Promise((resolve, reject) => {
+      const parsed = new URL(url);
+      const mod = parsed.protocol === 'https:' ? https : http;
+      const req = mod.request(parsed, { method: 'POST', headers: { 'Content-Type': 'application/json' } }, (res) => {
+        let data = '';
+        res.on('data', (chunk) => data += chunk);
+        res.on('end', () => {
+          try {
+            resolve({ status: res.statusCode, body: JSON.parse(data) });
+          } catch {
+            resolve({ status: res.statusCode, body: data });
+          }
+        });
+      });
+      req.on('error', reject);
+      req.write(JSON.stringify(body));
+      req.end();
     });
 
-    const data = await res.json();
+    console.log('   Registering...');
+    let res = await doPost(`${baseUrl}/auth/register`, { email, password, machineId });
 
-    if (res.ok && data.apiKey) {
-      apiKey = data.apiKey;
-      console.log(`\n✅ ${endpoint === '/auth/register' ? 'Registered' : 'Logged in'} successfully`);
-      break;
+    if (res.status === 409 || (res.body && res.body.error && res.body.error.includes('already'))) {
+      console.log('   Account exists, logging in...');
+      res = await doPost(`${baseUrl}/auth/login`, { email, password, machineId });
     }
 
-    // If register fails with 409 (already exists), try login next
-    if (res.status === 409) continue;
-
-    // Any other error on login means bad credentials
-    if (endpoint === '/auth/login' && !res.ok) {
-      console.error(`\n❌ Login failed: ${data.error?.message || 'Unknown error'}`);
+    if (res.status >= 400) {
+      const errMsg = (res.body && res.body.error) || JSON.stringify(res.body);
+      console.error(`\n❌ Authentication failed: ${errMsg}`);
       return;
     }
-  }
 
-  if (!apiKey) {
-    console.error('\n❌ Failed to authenticate');
+    apiKey = res.body.apiKey || res.body.api_key || res.body.key;
+    if (!apiKey) {
+      console.error('\n❌ No API key returned from server. Response:', JSON.stringify(res.body));
+      return;
+    }
+  } catch (err) {
+    console.error(`\n❌ Failed to connect to Chorus: ${err.message}`);
     return;
   }
 
@@ -934,18 +980,22 @@ async function setupProxyAuth() {
     envContent = await fs.readFile(envPath, 'utf8');
   } catch { /* no .env yet */ }
 
-  if (envContent.includes('PROXY_API_KEY=')) {
-    envContent = envContent.replace(/PROXY_API_KEY=.*/, `PROXY_API_KEY=${apiKey}`);
-  } else {
-    envContent = envContent.trimEnd() + `\nPROXY_API_KEY=${apiKey}\n`;
+  const updates = { CHORUS_API_KEY: apiKey, CHORUS_API_URL: CONFIG.ai.chorusApiUrl };
+  for (const [key, value] of Object.entries(updates)) {
+    const regex = new RegExp(`^${key}=.*$`, 'm');
+    if (regex.test(envContent)) {
+      envContent = envContent.replace(regex, `${key}=${value}`);
+    } else {
+      envContent = envContent.trimEnd() + `\n${key}=${value}`;
+    }
   }
-  await fs.writeFile(envPath, envContent);
+  await fs.writeFile(envPath, envContent.trimEnd() + '\n');
 
   // Update in-memory config
-  CONFIG.ai.anthropicApiKey = apiKey;
-  process.env.PROXY_API_KEY = apiKey;
+  CONFIG.ai.chorusApiKey = apiKey;
+  process.env.CHORUS_API_KEY = apiKey;
 
-  console.log(`   API key saved to .env\n`);
+  console.log(`\n✅ Chorus API key saved to ${envPath}\n`);
 }
 
 async function setupTeamsAuth() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "chorus-cli",
-  "version": "0.4.1",
+  "version": "0.4.4",
   "description": "Automated ticket resolution with AI, Teams, and Slack integration",
   "main": "index.js",
   "bin": {
@@ -18,9 +18,9 @@
     "start": "node index.js run"
   },
   "dependencies": {
-    "@anthropic-ai/sdk": "^0.73.0",
     "@octokit/rest": "^20.0.2",
     "dotenv": "^17.2.4",
+    "openai": "^4.0.0",
     "playwright": "^1.40.0"
   },
   "engines": {

package/scripts/postinstall.js

@@ -93,11 +93,11 @@ run(venvPython, ['-m', 'pip', 'install', '-r', REQUIREMENTS]);
 
 // 3. Verify critical dependency installed
 try {
-  execFileSync(venvPython, ['-c', 'import anthropic'], { stdio: 'ignore' });
+  execFileSync(venvPython, ['-c', 'import openai'], { stdio: 'ignore' });
   console.log('   Dependencies installed ✓');
 } catch {
   console.error(
-    '⚠  "anthropic" module is missing after pip install.\n' +
+    '⚠  "openai" module is missing after pip install.\n' +
     '   Run manually: ' + venvPython + ' -m pip install -r ' + REQUIREMENTS
   );
   process.exit(0);

package/tools/coder.py

@@ -1,20 +1,20 @@
 #!/usr/bin/env python3
 """
-Coder — A terminal coding agent powered by Claude.
+Coder — A terminal coding agent powered by Claude via the Chorus proxy.
 
 Usage:
     coder.py                          Interactive REPL
     coder.py --prompt "do something"  Headless mode — outputs JSON to stdout
 
 Environment variables:
-    ANTHROPIC_API_KEY    — Required. Your Anthropic API key (or Chorus pk- key).
-    CODER_PROXY_URL      — Optional. Chorus base URL (e.g. http://localhost:8081)
-    CODER_MODEL          — Model to use (default: claude-sonnet-4-5-20250929)
+    CHORUS_API_KEY       — Required. Your Chorus API key.
+    CHORUS_API_URL       — Optional. Chorus proxy base URL (default: https://chorus-bad0f.web.app/v1)
+    CODER_MODEL          — Model to use (default: anthropic/claude-sonnet-4)
     CODER_MAX_TOKENS     — Max response tokens (default: 16384)
     CODER_SAFE_MODE      — Set to 1 to require approval for writes/edits/bash
 """
 
-import anthropic
+from openai import OpenAI
 import argparse
 import json
 import os
@@ -41,7 +41,7 @@ class C:
 
 # ── Config ──────────────────────────────────────────────────────────────────
 
-MODEL = os.environ.get("CODER_MODEL", "claude-sonnet-4-5-20250929")
+MODEL = os.environ.get("CODER_MODEL", "anthropic/claude-sonnet-4")
 MAX_TOKENS = int(os.environ.get("CODER_MAX_TOKENS", "16384"))
 SAFE_MODE = os.environ.get("CODER_SAFE_MODE", "").lower() in ("1", "true", "yes")
 
@@ -50,23 +50,29 @@ def is_token_limit_error(err):
     return "token limit exceeded" in msg or "rate_limit_error" in msg
 
 SYSTEM_PROMPT = """\
-You are a coding agent running in the terminal.
+You are a coding agent running inside a CLI tool called Chorus.
+Your output goes straight to a terminal. There is no browser, no rich renderer.
 Working directory: {cwd}
 
 You help with software engineering tasks: writing code, debugging, refactoring, \
 explaining code, running commands, and managing files.
 
 Formatting:
-- Your output is displayed raw in a terminal. Never use markdown.
-- No ## headers, **bold**, *italic*, [links](url), or bullet symbols like -.
+- Plain text only. Never use markdown.
+- No ## headers, **bold**, *italic*, `backticks`, [links](url), or bullet symbols like -.
 - Use blank lines, indentation, and CAPS for emphasis or section labels.
 - Use plain numbered lists (1. 2. 3.) when listing things.
-- For inline code references, just use the name directly (e.g. myFunction, not `myFunction`).
-- Keep responses short and scannable.
+- Refer to code identifiers by name directly (e.g. myFunction, not `myFunction`).
+
+Communication style:
+- Be terse. Say what you are doing and why in one or two lines, then do it.
+- No greetings, preambles, encouragement, or sign-offs.
+- No "Great question!", "Let me", "Sure!", "I'll now", or similar filler.
+- When explaining your plan, use short declarative sentences. Skip obvious reasoning.
+- After completing work, state what changed and nothing else.
 
 {approach}Guidelines:
-- Be direct and concise. No filler.
-- Always use your tools. If a question can be answered by running a command (git, ls, etc.), use the bash tool — never guess.
+- Always use your tools. If a question can be answered by running a command (git, ls, etc.), use the bash tool. Never guess.
 - Always read a file before editing it.
 - If edit_file fails with "old_string not found", re-read the file to get the actual current content before retrying. Never guess at file contents.
 - Use edit_file for targeted changes. Use write_file for new files or complete rewrites.
@@ -90,83 +96,101 @@ Approach:
 
 TOOLS = [
     {
-        "name": "read_file",
-        "description": "Read a file's contents. Returns lines with line numbers.",
-        "input_schema": {
-            "type": "object",
-            "properties": {
-                "path": {"type": "string", "description": "File path (relative to cwd or absolute)"},
-                "offset": {"type": "integer", "description": "Start line (1-indexed)"},
-                "limit": {"type": "integer", "description": "Max lines to read"},
+        "type": "function",
+        "function": {
+            "name": "read_file",
+            "description": "Read a file's contents. Returns lines with line numbers.",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "path": {"type": "string", "description": "File path (relative to cwd or absolute)"},
+                    "offset": {"type": "integer", "description": "Start line (1-indexed)"},
+                    "limit": {"type": "integer", "description": "Max lines to read"},
+                },
+                "required": ["path"],
             },
-            "required": ["path"],
         },
     },
     {
-        "name": "write_file",
-        "description": "Create or overwrite a file with the given content.",
-        "input_schema": {
-            "type": "object",
-            "properties": {
-                "path": {"type": "string", "description": "File path to write"},
-                "content": {"type": "string", "description": "Full file content"},
+        "type": "function",
+        "function": {
+            "name": "write_file",
+            "description": "Create or overwrite a file with the given content.",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "path": {"type": "string", "description": "File path to write"},
+                    "content": {"type": "string", "description": "Full file content"},
+                },
+                "required": ["path", "content"],
             },
-            "required": ["path", "content"],
         },
     },
     {
-        "name": "edit_file",
-        "description": (
-            "Replace an exact string in a file with new content. "
-            "old_string must match exactly including whitespace/indentation. "
-            "Fails if old_string is not found or is ambiguous (found multiple times without replace_all)."
-        ),
-        "input_schema": {
-            "type": "object",
-            "properties": {
-                "path": {"type": "string", "description": "File path to edit"},
-                "old_string": {"type": "string", "description": "Exact string to find"},
-                "new_string": {"type": "string", "description": "Replacement string"},
-                "replace_all": {"type": "boolean", "description": "Replace all occurrences (default: false)"},
+        "type": "function",
+        "function": {
+            "name": "edit_file",
+            "description": (
+                "Replace an exact string in a file with new content. "
+                "old_string must match exactly including whitespace/indentation. "
+                "Fails if old_string is not found or is ambiguous (found multiple times without replace_all)."
+            ),
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "path": {"type": "string", "description": "File path to edit"},
+                    "old_string": {"type": "string", "description": "Exact string to find"},
+                    "new_string": {"type": "string", "description": "Replacement string"},
+                    "replace_all": {"type": "boolean", "description": "Replace all occurrences (default: false)"},
+                },
+                "required": ["path", "old_string", "new_string"],
             },
-            "required": ["path", "old_string", "new_string"],
         },
     },
     {
-        "name": "list_files",
-        "description": "List files matching a glob pattern. Use '**/*.ext' for recursive search.",
-        "input_schema": {
-            "type": "object",
-            "properties": {
-                "pattern": {"type": "string", "description": "Glob pattern (e.g. '**/*.py', 'src/**/*.ts')"},
-                "path": {"type": "string", "description": "Base directory (default: cwd)"},
+        "type": "function",
+        "function": {
+            "name": "list_files",
+            "description": "List files matching a glob pattern. Use '**/*.ext' for recursive search.",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "pattern": {"type": "string", "description": "Glob pattern (e.g. '**/*.py', 'src/**/*.ts')"},
+                    "path": {"type": "string", "description": "Base directory (default: cwd)"},
+                },
+                "required": ["pattern"],
             },
-            "required": ["pattern"],
         },
     },
     {
-        "name": "search_files",
-        "description": "Search file contents with regex. Returns matching lines with file:line: prefix.",
-        "input_schema": {
-            "type": "object",
-            "properties": {
-                "pattern": {"type": "string", "description": "Regex pattern to search for"},
-                "path": {"type": "string", "description": "Directory or file to search (default: cwd)"},
-                "include": {"type": "string", "description": "Glob to filter files (e.g. '*.py')"},
+        "type": "function",
+        "function": {
+            "name": "search_files",
+            "description": "Search file contents with regex. Returns matching lines with file:line: prefix.",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "pattern": {"type": "string", "description": "Regex pattern to search for"},
+                    "path": {"type": "string", "description": "Directory or file to search (default: cwd)"},
+                    "include": {"type": "string", "description": "Glob to filter files (e.g. '*.py')"},
+                },
+                "required": ["pattern"],
             },
-            "required": ["pattern"],
         },
     },
     {
-        "name": "bash",
-        "description": "Execute a shell command. Returns stdout, stderr, and exit code.",
-        "input_schema": {
-            "type": "object",
-            "properties": {
-                "command": {"type": "string", "description": "Shell command to run"},
-                "timeout": {"type": "integer", "description": "Timeout in seconds (default: 120)"},
+        "type": "function",
+        "function": {
+            "name": "bash",
+            "description": "Execute a shell command. Returns stdout, stderr, and exit code.",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "command": {"type": "string", "description": "Shell command to run"},
+                    "timeout": {"type": "integer", "description": "Timeout in seconds (default: 120)"},
+                },
+                "required": ["command"],
             },
-            "required": ["command"],
         },
     },
 ]
@@ -502,7 +526,9 @@ def _estimate_tokens(messages):
     """Rough token estimate: 1 token ≈ 4 chars."""
     total = 0
     for msg in messages:
-        content = msg.get("content", "")
+        content = _get_msg_content(msg) if isinstance(msg, dict) else getattr(msg, "content", "")
+        if content is None:
+            content = ""
         if isinstance(content, str):
             total += len(content)
         elif isinstance(content, list):
@@ -547,6 +573,13 @@ def _summarize_tool_use_input(block):
         block.input["content"] = f"[file content: {line_count} lines, truncated]"
 
 
+def _get_msg_content(msg):
+    """Get content from either dict or OpenAI message object."""
+    if isinstance(msg, dict):
+        return msg.get("content")
+    return getattr(msg, "content", None)
+
+
 def prune_context(messages, token_budget=None):
     """
     Trim old tool results when conversation exceeds the token budget.
@@ -567,7 +600,7 @@ def prune_context(messages, token_budget=None):
 
     for i in range(1, prune_end):
         msg = messages[i]
-        content = msg.get("content")
+        content = _get_msg_content(msg)
 
         if isinstance(content, list):
             for item in content:
@@ -586,66 +619,71 @@ def prune_context(messages, token_budget=None):
 # ── Streaming Response Handler ──────────────────────────────────────────────
 
 def stream_response(client, messages, system):
-    """Stream Claude's response, handling tool-use loops until done."""
+    """Stream LLM response via Chorus proxy, handling tool-use loops until done."""
+    openai_messages = [{"role": "system", "content": system}]
+    # Convert existing messages to OpenAI format
+    for msg in messages:
+        openai_messages.append(msg)
+    
     while True:
         printed_text = False
-
-        with client.messages.stream(
+        
+        response = client.chat.completions.create(
             model=MODEL,
             max_tokens=MAX_TOKENS,
-            system=system,
+            messages=openai_messages,
             tools=TOOLS,
-            messages=messages,
-        ) as stream:
-            for event in stream:
-                if event.type == "content_block_delta":
-                    if hasattr(event.delta, "text"):
-                        sys.stdout.write(event.delta.text)
-                        sys.stdout.flush()
-                        printed_text = True
-
-            response = stream.get_final_message()
-
-        if printed_text:
-            print()  # newline after streamed text
-
-        # Add the full assistant message to conversation
-        messages.append({"role": "assistant", "content": response.content})
+        )
 
-        # If stop reason is tool_use, execute tools and loop
-        if response.stop_reason == "tool_use":
+        message = response.choices[0].message
+        
+        # Add assistant message to conversation history
+        openai_messages.append(message)
+        if message.content:
+            messages.append({"role": "assistant", "content": message.content})
+            print(message.content)
+            printed_text = True
+
+        # Check for tool calls
+        if message.tool_calls:
             tool_results = []
-            for block in response.content:
-                if block.type == "tool_use":
-                    if SAFE_MODE and block.name in NEEDS_PERMISSION:
-                        # Safe mode: show preview and ask
-                        if request_permission(block.name, block.input):
-                            result = execute_tool(block.name, block.input)
-                        else:
-                            result = f"Permission denied: user rejected {block.name} call."
-                    else:
-                        # Default: just run it
-                        print_tool_call(block.name, block.input)
-                        result = execute_tool(block.name, block.input)
-                    # Truncate huge results
-                    if len(result) > 15000:
-                        result = result[:15000] + "\n... (output truncated)"
-                    if _should_nudge(block.name, block.input, result):
-                        result += REFLECT_NUDGE
-                    print_tool_result_summary(block.name, result)
-                    tool_results.append({
-                        "type": "tool_result",
-                        "tool_use_id": block.id,
-                        "content": result,
-                    })
-            messages.append({"role": "user", "content": tool_results})
-            prune_context(messages)
+            for tool_call in message.tool_calls:
+                function_name = tool_call.function.name
+                import json
+                try:
+                    arguments = json.loads(tool_call.function.arguments)
+                except json.JSONDecodeError:
+                    arguments = {}
+                
+                # Track what's happening
+                if function_name == "write_file":
+                    path = arguments.get("path", "")
+                    if resolve_path(path).exists():
+                        pass  # Will track in result
+                    
+                # Execute the tool
+                result = execute_tool(function_name, arguments)
+                
+                # Truncate huge results
+                if len(result) > 15000:
+                    result = result[:15000] + "\n... (output truncated)"
+                if _should_nudge(function_name, arguments, result):
+                    result += REFLECT_NUDGE
+                
+                tool_results.append({
+                    "role": "tool",
+                    "tool_call_id": tool_call.id,
+                    "content": result,
+                })
+            
+            openai_messages.extend(tool_results)
+            prune_context(openai_messages)
             print()  # breathing room before next response
         else:
             # Print token usage
             if hasattr(response, "usage") and response.usage:
-                inp = response.usage.input_tokens
-                out = response.usage.output_tokens
+                inp = response.usage.prompt_tokens
+                out = response.usage.completion_tokens
                 print(f"{C.DIM}[{inp} in / {out} out tokens]{C.RESET}")
             break
 
@@ -653,7 +691,41 @@ def stream_response(client, messages, system):
 
 def run_prompt(client, prompt, system):
     """Run a single prompt non-interactively. Returns a JSON-serializable dict."""
-    messages = [{"role": "user", "content": prompt}]
+    
+    # PHASE 1: Planning - ask the model to explain its approach first
+    print(f"\n{C.BOLD}{C.BLUE}📝 PLANNING PHASE{C.RESET}", file=sys.stderr, flush=True)
+    print(f"{C.DIM}Understanding the issue and creating a plan...{C.RESET}\n", file=sys.stderr, flush=True)
+    
+    plan_messages = [
+        {"role": "system", "content": system},
+        {"role": "user", "content": f"{prompt}\n\nBefore making any code changes, briefly state:\n1. The goal\n2. Files to examine\n3. Files to modify and how\n\nKeep it short. Do NOT write any code yet."}
+    ]
+    
+    try:
+        plan_response = client.chat.completions.create(
+            model=MODEL,
+            max_tokens=MAX_TOKENS,
+            messages=plan_messages,
+        )
+        plan_text = plan_response.choices[0].message.content.strip()
+        
+        # Print the plan with formatting
+        print(f"{C.CYAN}{'─' * 60}{C.RESET}", file=sys.stderr, flush=True)
+        for line in plan_text.split('\n'):
+            print(f"{C.CYAN}  {line}{C.RESET}", file=sys.stderr, flush=True)
+        print(f"{C.CYAN}{'─' * 60}{C.RESET}\n", file=sys.stderr, flush=True)
+        
+    except Exception as e:
+        print(f"{C.YELLOW}Could not generate plan: {e}{C.RESET}", file=sys.stderr, flush=True)
+        plan_text = ""
+    
+    # PHASE 2: Execution - proceed with the actual coding
+    print(f"{C.BOLD}{C.GREEN}🔨 EXECUTING PLAN{C.RESET}\n", file=sys.stderr, flush=True)
+    
+    messages = [
+        {"role": "system", "content": system},
+        {"role": "user", "content": prompt}
+    ]
     files_modified = set()
     files_created = set()
     commands_run = []
@@ -670,14 +742,13 @@ def run_prompt(client, prompt, system):
         turn += 1
 
         try:
-            response = client.messages.create(
+            response = client.chat.completions.create(
                 model=MODEL,
                 max_tokens=MAX_TOKENS,
-                system=system,
-                tools=TOOLS,
                 messages=messages,
+                tools=TOOLS,
             )
-        except anthropic.APIError as e:
+        except Exception as e:
             if is_token_limit_error(e):
                 print(f"\n{C.YELLOW}Token limit reached — stopping.{C.RESET}", file=sys.stderr, flush=True)
                 errors.append(str(e))
@@ -687,66 +758,88 @@ def run_prompt(client, prompt, system):
         # Per-turn token tracking
         turn_in = turn_out = 0
         if hasattr(response, "usage") and response.usage:
-            turn_in = response.usage.input_tokens
-            turn_out = response.usage.output_tokens
+            turn_in = response.usage.prompt_tokens
+            turn_out = response.usage.completion_tokens
             total_input_tokens += turn_in
             total_output_tokens += turn_out
 
-        messages.append({"role": "assistant", "content": response.content})
+        message = response.choices[0].message
+        messages.append(message)
+
+        # Show reasoning/thinking if present
+        if message.content:
+            print(f"\n{C.YELLOW}💭 {message.content}{C.RESET}\n", file=sys.stderr, flush=True)
 
-        if response.stop_reason == "tool_use":
+        # Check for tool calls
+        if message.tool_calls:
             tool_results = []
-            for block in response.content:
-                if block.type == "tool_use":
-                    # Track what's happening
-                    if block.name == "write_file":
-                        path = block.input.get("path", "")
-                        if resolve_path(path).exists():
-                            files_modified.add(path)
-                        else:
-                            files_created.add(path)
-                    elif block.name == "edit_file":
-                        pass  # tracked after execution below
-                    elif block.name == "bash":
-                        commands_run.append(block.input.get("command", ""))
-
-                    # Colored tool log to stderr
-                    _, color = TOOL_LABELS.get(block.name, (block.name, C.DIM))
-                    header = format_tool_header(block.name, block.input)
-                    print(f"  {color}{header}{C.RESET}", file=sys.stderr, flush=True)
-
-                    result = execute_tool(block.name, block.input)
-
-                    # Track successful edits
-                    if block.name == "edit_file" and not result.startswith("Error"):
-                        files_modified.add(block.input.get("path", ""))
-
-                    if result.startswith("Error"):
-                        err_msg = f"{block.name}: {result}"
-                        # Recoverable: file not found on read (exploring), edit match failures (retries)
-                        if (block.name == "read_file" and "not found" in result) or \
-                           (block.name == "edit_file" and "not found" in result):
-                            warnings.append(err_msg)
-                            print(f"  {C.YELLOW}{result.splitlines()[0]}{C.RESET}", file=sys.stderr, flush=True)
-                        else:
-                            errors.append(err_msg)
-                            print(f"  {C.RED}{result.splitlines()[0]}{C.RESET}", file=sys.stderr, flush=True)
-
-                    if len(result) > 15000:
-                        result = result[:15000] + "\n... (output truncated)"
-                    if _should_nudge(block.name, block.input, result):
-                        result += REFLECT_NUDGE
-
-                    tool_results.append({
-                        "type": "tool_result",
-                        "tool_use_id": block.id,
-                        "content": result,
-                    })
-
-            # Token usage for this turn
-            print(f"  {C.DIM}[{turn_in} in / {turn_out} out]{C.RESET}", file=sys.stderr, flush=True)
-
-            messages.append({"role": "user", "content": tool_results})
+            for tool_call in message.tool_calls:
+                function_name = tool_call.function.name
+                import json
+                try:
+                    arguments = json.loads(tool_call.function.arguments)
+                except json.JSONDecodeError:
+                    arguments = {}
+                
+                # Track what's happening
+                if function_name == "write_file":
+                    path = arguments.get("path", "")
+                    if resolve_path(path).exists():
+                        files_modified.add(path)
+                    else:
+                        files_created.add(path)
+                elif function_name == "edit_file":
+                    pass  # tracked after execution below
+                elif function_name == "bash":
+                    commands_run.append(arguments.get("command", ""))
+
+                # Colored tool log to stderr with reasoning
+                _, color = TOOL_LABELS.get(function_name, (function_name, C.DIM))
+                header = format_tool_header(function_name, arguments)
+                print(f"  {color}{header}{C.RESET}", file=sys.stderr, flush=True)
+
+                result = execute_tool(function_name, arguments)
+
+                # Track successful edits
+                if function_name == "edit_file" and not result.startswith("Error"):
+                    files_modified.add(arguments.get("path", ""))
+
+                if result.startswith("Error"):
+                    err_msg = f"{function_name}: {result}"
+                    # Recoverable: file not found on read (exploring), edit match failures (retries)
+                    if (function_name == "read_file" and "not found" in result) or \
+                       (function_name == "edit_file" and "not found" in result):
+                        warnings.append(err_msg)
+                        print(f"  {C.YELLOW}{result.splitlines()[0]}{C.RESET}", file=sys.stderr, flush=True)
+                    else:
+                        errors.append(err_msg)
+                        print(f"  {C.RED}{result.splitlines()[0]}{C.RESET}", file=sys.stderr, flush=True)
+
+                if len(result) > 15000:
+                    result = result[:15000] + "\n... (output truncated)"
+                if _should_nudge(function_name, arguments, result):
+                    result += REFLECT_NUDGE
+
+                tool_results.append({
+                    "role": "tool",
+                    "tool_call_id": tool_call.id,
+                    "content": result,
+                })
+
+            # Show progress instead of just tokens
+            action_summary = []
+            if files_created:
+                action_summary.append(f"+{len(files_created)} files")
+            if files_modified:
+                action_summary.append(f"~{len(files_modified)} files")
+            if commands_run:
+                action_summary.append(f"{len(commands_run)} commands")
+            
+            if action_summary:
+                progress = " | ".join(action_summary)
+                print(f"  {C.DIM}[Progress: {progress}]{C.RESET}", file=sys.stderr, flush=True)
+
+            messages.extend(tool_results)
 
             # Prune old tool results to prevent quadratic token growth
             prune_context(messages)
@@ -757,44 +850,50 @@ def run_prompt(client, prompt, system):
         errors.append(f"Hit max turns limit ({max_turns})")
         print(f"{C.RED}Max turns reached ({max_turns}), stopping{C.RESET}", file=sys.stderr, flush=True)
 
-    # Final totals
-    print(f"{C.DIM}Coder finished: {turn} turns, {total_input_tokens} in / {total_output_tokens} out tokens{C.RESET}", file=sys.stderr, flush=True)
-
-    # Extract Claude's final text response
-    final_text = "".join(
-        block.text for block in response.content if block.type == "text"
-    ) if response else ""
+    # Final summary
+    print(f"\n{C.BOLD}{C.GREEN}✓ Done{C.RESET}", file=sys.stderr, flush=True)
+    if files_created:
+        print(f"  {C.GREEN}Created: {', '.join(sorted(files_created))}{C.RESET}", file=sys.stderr, flush=True)
+    if files_modified:
+        print(f"  {C.YELLOW}Modified: {', '.join(sorted(files_modified))}{C.RESET}", file=sys.stderr, flush=True)
+
+    # Extract LLM's final text response from the last assistant message
+    final_text = ""
+    for msg in reversed(messages):
+        if isinstance(msg, dict) and msg.get("role") == "assistant" and msg.get("content"):
+            final_text = msg["content"]
+            break
+        elif hasattr(msg, "role") and msg.role == "assistant" and msg.content:
+            final_text = msg.content
+            break
 
-    # Ask Claude for a CodeRabbit-oriented summary (skip if we hit token limit)
-    # Uses a standalone minimal prompt — no conversation history, system prompt, or tools.
+    # Ask LLM for a CodeRabbit-oriented summary (skip if we hit token limit)
     summary = final_text.strip()
     if not any(is_token_limit_error(e) for e in errors):
-        summary_messages = [{
-            "role": "user",
-            "content": (
+        summary_messages = [
+            {"role": "system", "content": "You are a helpful assistant that summarizes code changes."},
+            {"role": "user", "content": (
                 f"Summarize these code changes in 2-3 sentences for a code review tool.\n\n"
                 f"Files modified: {', '.join(sorted(files_modified)) or 'none'}\n"
                 f"Files created: {', '.join(sorted(files_created)) or 'none'}\n\n"
                 f"Agent's final notes:\n{final_text[:2000]}\n\n"
                 f"Focus on what changed, what was added/fixed, and why. Be specific. No preamble."
-            ),
-        }]
+            )},
+        ]
 
         try:
-            summary_response = client.messages.create(
+            summary_response = client.chat.completions.create(
                 model=MODEL,
                 max_tokens=1024,
                 messages=summary_messages,
             )
 
             if hasattr(summary_response, "usage") and summary_response.usage:
-                total_input_tokens += summary_response.usage.input_tokens
-                total_output_tokens += summary_response.usage.output_tokens
+                total_input_tokens += summary_response.usage.prompt_tokens
+                total_output_tokens += summary_response.usage.completion_tokens
 
-            summary = "".join(
-                block.text for block in summary_response.content if block.type == "text"
-            ).strip()
-        except anthropic.APIError as e:
+            summary = summary_response.choices[0].message.content.strip()
+        except Exception as e:
             if is_token_limit_error(e):
                 errors.append(str(e))
             else:
@@ -821,20 +920,21 @@ def run_prompt(client, prompt, system):
 # ── Main ────────────────────────────────────────────────────────────────────
 
 def main():
-    parser = argparse.ArgumentParser(description="Coder — AI coding agent powered by Claude")
+    parser = argparse.ArgumentParser(description="Coder — AI coding agent powered by Claude via Chorus")
     parser.add_argument("-p", "--prompt", help="Run a single prompt headlessly and output JSON")
     args = parser.parse_args()
 
-    # if not os.environ.get("ANTHROPIC_API_KEY"):
-    #     print(f"{C.RED}Error: ANTHROPIC_API_KEY not set.{C.RESET}", file=sys.stderr)
-    #     print("  export ANTHROPIC_API_KEY=sk-ant-... (or pk-... for proxy)", file=sys.stderr)
-    #     sys.exit(1)
-
-    proxy_url = os.environ.get("CODER_PROXY_URL")
-    if proxy_url:
-        client = anthropic.Anthropic(base_url=proxy_url.rstrip('/'))
-    else:
-        client = anthropic.Anthropic()
+    api_key = os.environ.get("CHORUS_API_KEY")
+    if not api_key:
+        print(f"{C.RED}Error: CHORUS_API_KEY not set. Run 'chorus setup' to configure.{C.RESET}", file=sys.stderr)
+        sys.exit(1)
+
+    base_url = os.environ.get("CHORUS_API_URL", "https://chorus-bad0f.web.app/v1")
+    machine_id = os.environ.get("CHORUS_MACHINE_ID")
+    client_kwargs = {"api_key": api_key, "base_url": base_url}
+    if machine_id:
+        client_kwargs["default_headers"] = {"X-Machine-Id": machine_id}
+    client = OpenAI(**client_kwargs)
     system = SYSTEM_PROMPT.format(cwd=os.getcwd(), approach=APPROACH_BLOCK)
 
     # Load codebase map if available
@@ -855,7 +955,7 @@ def main():
             result = run_prompt(client, args.prompt, system)
             print(json.dumps(result, indent=2))
             sys.exit(0 if result["completed"] else 1)
-        except anthropic.APIError as e:
+        except Exception as e:
             print(json.dumps({
                 "completed": False,
                 "summary": f"API error: {e}",
@@ -953,7 +1053,7 @@ def main():
             except KeyboardInterrupt:
                 del messages[snapshot:]
                 print(f"\n{C.DIM}(interrupted){C.RESET}\n")
-            except anthropic.APIError as e:
+            except Exception as e:
                 del messages[snapshot:]
                 print(f"\n{C.RED}API error: {e}{C.RESET}\n")
 

package/tools/qa.py

@@ -1,6 +1,6 @@
 #!/usr/bin/env python3
 """
-QA Chat — Multi-turn QA conversation tool powered by Claude + pluggable messengers.
+QA Chat — Multi-turn QA conversation tool powered by Claude via the Chorus proxy + pluggable messengers.
 
 Supports Teams (Playwright browser automation) and Slack (API-based).
 
@@ -17,7 +17,7 @@ Output (JSON on stdout):
 Progress is logged to stderr.
 """
 
-import anthropic
+from openai import OpenAI
 import argparse
 import json
 import os
@@ -27,7 +27,7 @@ from abc import ABC, abstractmethod
 
 # ── Config ──────────────────────────────────────────────────────────────────
 
-MODEL = os.environ.get("QA_MODEL", "claude-sonnet-4-5-20250929")
+MODEL = os.environ.get("QA_MODEL", "anthropic/claude-sonnet-4")
 MAX_ROUNDS = int(os.environ.get("QA_MAX_ROUNDS", "5"))
 POLL_INTERVAL = int(os.environ.get("QA_POLL_INTERVAL", "60"))  # seconds
 POLL_TIMEOUT = int(os.environ.get("QA_POLL_TIMEOUT", "1800"))  # 30 min
@@ -316,33 +316,45 @@ If NO: set sufficient=false and write a short, friendly follow-up message asking
         }
     ]
 
-    response = client.messages.create(
-        model=MODEL,
-        max_tokens=1024,
-        system=(
+    # Chorus proxy uses OpenAI-compatible API — no native tool use
+    # We'll simulate by asking the model to respond in a structured way
+    messages.append({
+        "role": "system",
+        "content": (
             "You are evaluating a QA conversation about a software bug/feature. "
             "Your job is to decide if there is enough concrete information to write "
             "exact developer requirements. Vague answers like 'it should work properly' "
             "are NOT sufficient — you need specifics: exact behavior, exact UI elements, "
             "exact data flows, exact error messages, etc. "
-            "Use the evaluation tool to return your assessment. "
+            "Respond with a JSON object containing: sufficient (boolean), reasoning (string), "
+            "and follow_up (string, required if sufficient is false). "
             "IMPORTANT: follow_up messages are sent via chat. Use plain text only — "
             "no markdown, no **bold**, no *italic*, no bullet points. "
             "Use numbered lines (1. 2. 3.) for multiple questions. Keep it conversational."
-        ),
-        tools=EVALUATE_TOOLS,
-        tool_choice={"type": "tool", "name": "evaluation"},
+        )
+    })
+    
+    response = client.chat.completions.create(
+        model=MODEL,
+        max_tokens=1024,
         messages=messages,
+        response_format={"type": "json_object"},
     )
 
     if hasattr(response, "usage") and response.usage:
-        log(f"  Evaluate tokens: {response.usage.input_tokens} in / {response.usage.output_tokens} out")
-
-    for block in response.content:
-        if block.type == "tool_use" and block.name == "evaluation":
-            return block.input
+        log(f"  Evaluate tokens: {response.usage.prompt_tokens} in / {response.usage.completion_tokens} out")
 
-    raise RuntimeError("Claude did not return evaluation tool call")
+    import json
+    try:
+        result = json.loads(response.choices[0].message.content)
+        return result
+    except json.JSONDecodeError:
+        # Fallback if not valid JSON
+        return {
+            "sufficient": False,
+            "reasoning": "Could not parse evaluation",
+            "follow_up": "Could you please provide more details?"
+        }
 
 
 def synthesize(client, conversation, issue_context):
@@ -367,29 +379,35 @@ Write a clear numbered list of requirements. Each requirement should be specific
         }
     ]
 
-    response = client.messages.create(
-        model=MODEL,
-        max_tokens=2048,
-        system=(
+    messages.insert(0, {
+        "role": "system",
+        "content": (
             "You synthesize QA conversations into exact, actionable developer requirements. "
             "Be specific and concrete. No vague language. Every requirement should be testable."
-        ),
+        )
+    })
+    
+    response = client.chat.completions.create(
+        model=MODEL,
+        max_tokens=2048,
         messages=messages,
     )
 
     if hasattr(response, "usage") and response.usage:
-        log(f"  Synthesize tokens: {response.usage.input_tokens} in / {response.usage.output_tokens} out")
+        log(f"  Synthesize tokens: {response.usage.prompt_tokens} in / {response.usage.completion_tokens} out")
 
-    return "".join(block.text for block in response.content if block.type == "text").strip()
+    return response.choices[0].message.content.strip()
 
 # ── Main Loop ───────────────────────────────────────────────────────────────
 
 def run_qa_chat(issue_context, messenger, qa_name):
-    proxy_url = os.environ.get("CODER_PROXY_URL")
-    if proxy_url:
-        client = anthropic.Anthropic(base_url=proxy_url.rstrip('/'))
-    else:
-        client = anthropic.Anthropic()
+    api_key = os.environ.get("CHORUS_API_KEY")
+    base_url = os.environ.get("CHORUS_API_URL", "https://chorus-bad0f.web.app/v1")
+    machine_id = os.environ.get("CHORUS_MACHINE_ID")
+    client_kwargs = {"api_key": api_key, "base_url": base_url}
+    if machine_id:
+        client_kwargs["default_headers"] = {"X-Machine-Id": machine_id}
+    client = OpenAI(**client_kwargs)
     conversation = []
     raw_responses = []
 
@@ -465,11 +483,11 @@ def main():
 
     if args.super:
         global MODEL
-        MODEL = "claude-opus-4-6"
+        MODEL = "anthropic/claude-opus-4"
         log(f"Super mode: using {MODEL}")
 
-    if not os.environ.get("ANTHROPIC_API_KEY"):
-        log("Error: ANTHROPIC_API_KEY not set")
+    if not os.environ.get("CHORUS_API_KEY"):
+        log("Error: CHORUS_API_KEY not set. Run 'chorus setup' to configure.")
         sys.exit(1)
 
     # Build the appropriate messenger

package/tools/requirements.txt

@@ -1,3 +1,3 @@
-anthropic>=0.40.0
+openai>=1.0.0
 playwright
 slack_sdk>=3.27.0