otherwise-cli 0.1.0

package/src/index.js

@@ -0,0 +1,557 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import open from 'open';
+import ora from 'ora';
+import { startServer, enableSilentMode } from './server.js';
+import { config } from './config.js';
+import { logSink } from './logBridge.js';
+
+const program = new Command();
+
+program
+  .name('otherwise')
+  .description('Otherwise AI - Your personal AI that lives on your computer')
+  .version('0.1.0');
+
+/**
+ * Set the terminal window title
+ * @param {string} title - The title to display
+ */
+function setTerminalTitle(title) {
+  process.stdout.write(`\x1b]0;${title}\x07\x1b]2;${title}\x07`);
+}
+
+// Default command - start server AND Ink UI (CLI opens automatically)
+program
+  .option('-p, -port <port>', 'Port to run on', '3000')
+  .option('-cli', 'Open web interface in browser')
+  .option('-server-only', 'Only start server (no CLI chat)')
+  .option('-v, --verbose', 'No Ink UI — raw backend logs in terminal, chat in browser')
+  .action(async (options) => {
+    const port = parseInt(options.port ?? options.Port ?? '3000', 10);
+    const serverUrl = `http://localhost:${port}`;
+    const verbose = (options.verbose ?? options.Verbose ?? options.v) === true;
+    const cli = options.cli ?? options.Cli ?? false;
+    const serverOnly = options.serverOnly ?? options.ServerOnly ?? false;
+
+    // Set terminal window title
+    setTerminalTitle('Otherwise');
+
+    // --verbose: server only, backend logs in terminal, no Ink (fewer WS clients = no duplication)
+    if (verbose) {
+      try {
+        console.log(chalk.cyan.bold('\n  Otherwise') + chalk.dim(' (verbose mode)\n'));
+        console.log(chalk.dim('  Web UI: ') + chalk.green.underline(serverUrl));
+        console.log(chalk.dim('  Ink UI disabled — all server logs printed below.'));
+        console.log(chalk.dim('  Press Ctrl+C to stop.\n'));
+        await startServer(port);
+        // Always open browser in verbose mode since there's no Ink terminal to chat in
+        await open(serverUrl);
+      } catch (err) {
+        console.error(chalk.red('Failed to start server:'), err.message);
+        process.exit(1);
+      }
+      return;
+    }
+
+    if (serverOnly) {
+      // Server-only mode - show banner and keep running
+      console.log(chalk.cyan(`
+ ██████╗ ████████╗██╗  ██╗███████╗██████╗ ██╗    ██╗██╗███████╗███████╗
+██╔═══██╗╚══██╔══╝██║  ██║██╔════╝██╔══██╗██║    ██║██║██╔════╝██╔════╝
+██║   ██║   ██║   ███████║█████╗  ██████╔╝██║ █╗ ██║██║███████╗█████╗  
+██║   ██║   ██║   ██╔══██║██╔══╝  ██╔══██╗██║███╗██║██║╚════██║██╔══╝  
+╚██████╔╝   ██║   ██║  ██║███████╗██║  ██║╚███╔███╔╝██║███████║███████╗
+ ╚═════╝    ╚═╝   ╚═╝  ╚═╝╚══════╝╚═╝  ╚═╝ ╚══╝╚══╝ ╚═╝╚══════╝╚══════╝
+`));
+      console.log(chalk.dim('        Your AI that lives on your computer\n'));
+      
+      const spinner = ora('Starting server...').start();
+      
+      try {
+        await startServer(port);
+        spinner.succeed(`Server running at ${chalk.green(serverUrl)}`);
+        
+        console.log();
+        console.log(chalk.cyan('  ┌────────────────────────────────────────┐'));
+        console.log(chalk.cyan('  │') + chalk.bold('  Web Interface: ') + chalk.green.underline(serverUrl) + chalk.cyan('  │'));
+        console.log(chalk.cyan('  └────────────────────────────────────────┘'));
+        console.log();
+        
+        if (cli) {
+          console.log(chalk.dim('  Opening browser...'));
+          await open(serverUrl);
+        }
+        
+        console.log(chalk.dim('  Press Ctrl+C to stop\n'));
+      } catch (err) {
+        spinner.fail('Failed to start server');
+        console.error(chalk.red(err.message));
+        process.exit(1);
+      }
+      
+      return;
+    }
+    
+    // Standard mode - Ink UI (CLI opens automatically), no console logs in terminal (stream to web UI only)
+    process.env.SILENT_MODE = 'true';
+    enableSilentMode();
+
+    const originalConsoleLog = console.log;
+    const originalConsoleWarn = console.warn;
+    const originalConsoleInfo = console.info;
+    const originalConsoleDebug = console.debug;
+
+    const forward = (level, fn) => (...args) => {
+      try {
+        logSink.write(level, args);
+      } catch (e) {}
+    };
+    console.log = forward('info', originalConsoleLog);
+    console.warn = forward('warn', originalConsoleWarn);
+    console.info = forward('info', originalConsoleInfo);
+    console.debug = forward('debug', originalConsoleDebug);
+
+    try {
+      await startServer(port);
+      
+      // Open browser to localhost so the app loads with local CLI connected and active
+      await open(serverUrl);
+      
+      // Clear screen for clean Ink start
+      process.stdout.write('\x1b[2J\x1b[H');
+      
+      // Spawn tsx process for Ink UI
+      const { spawn } = await import('child_process');
+      const { fileURLToPath } = await import('url');
+      const { dirname, join } = await import('path');
+      
+      const __filename = fileURLToPath(import.meta.url);
+      const __dirname = dirname(__filename);
+      const inkEntryPath = join(__dirname, 'ui', 'ink-runner.js');
+      
+      const child = spawn('npx', ['tsx', inkEntryPath, serverUrl, 'true'], {
+        stdio: 'inherit',
+        cwd: process.cwd(),
+      });
+      
+      child.on('error', () => {
+        console.error = originalConsoleLog;
+        console.error(chalk.red('Failed to start UI'));
+        process.exit(1);
+      });
+      
+      child.on('exit', (code) => {
+        process.exit(code || 0);
+      });
+    } catch (err) {
+      console.error = originalConsoleLog;
+      console.error(chalk.red('Failed to start server:'), err.message);
+      process.exit(1);
+    }
+  });
+
+// Config command with subcommands
+const configCmd = program
+  .command('config')
+  .description('Configure API keys and settings');
+
+// Config show subcommand (default action)
+configCmd
+  .command('show', { isDefault: true })
+  .description('Show current configuration')
+  .action(async () => {
+    const allConfig = config.store;
+    // Redact API keys
+    const display = { ...allConfig };
+    if (display.apiKeys) {
+      display.apiKeys = Object.fromEntries(
+        Object.entries(display.apiKeys).map(([k, v]) => [k, v ? '••••••••' : '(not set)'])
+      );
+    }
+    console.log(chalk.cyan('\nCurrent configuration:\n'));
+    console.log(JSON.stringify(display, null, 2));
+    console.log(chalk.dim(`\nConfig file: ${config.path}\n`));
+    
+    console.log('To set API keys, use:');
+    console.log(chalk.green('  otherwise config set anthropic <key>'));
+    console.log(chalk.green('  otherwise config set openai <key>'));
+    console.log(chalk.green('  otherwise config set google <key>'));
+    console.log(chalk.green('  otherwise config set xai <key>'));
+    console.log(chalk.green('  otherwise config set openrouter <key>'));
+    console.log(chalk.green('  otherwise config set ollama <url>'));
+    console.log('');
+  });
+
+// Config set subcommand
+configCmd
+  .command('set <key> <value>')
+  .description('Set a configuration value')
+  .action((key, value) => {
+    const keyMap = {
+      'anthropic': 'apiKeys.anthropic',
+      'openai': 'apiKeys.openai',
+      'google': 'apiKeys.google',
+      'xai': 'apiKeys.xai',
+      'openrouter': 'apiKeys.openrouter',
+      'ollama': 'ollamaUrl',
+      'model': 'model',
+    };
+    
+    const configKey = keyMap[key] || key;
+    // Trim API keys to prevent whitespace issues causing auth failures
+    const finalValue = configKey.startsWith('apiKeys.') ? value.trim() : value;
+    config.set(configKey, finalValue);
+    console.log(chalk.green(`✓ Set ${key}`));
+  });
+
+// Connect command - link this CLI to otherwise.ai (device code at otherwise.ai/connect only)
+// Uses saved pairing token when available so you don't have to enter the code again.
+program
+  .command('connect')
+  .description('Connect to otherwise.ai: get a code, enter it at otherwise.ai/connect')
+  .option('-p, -port <port>', 'Port to run on', '3000')
+  .option('-v, --verbose', 'No Ink UI — raw backend logs in terminal')
+  .action(async (options) => {
+    const port = parseInt(options.port ?? options.Port ?? '3000', 10);
+    const serverUrl = `http://localhost:${port}`;
+    const verbose = (options.verbose ?? options.Verbose ?? options.v) === true;
+    setTerminalTitle('Otherwise (remote)');
+
+    const { getBackendBaseUrl } = await import('./remote/client.js');
+    const baseUrl = config.get('remote.backendUrl')
+      ? config.get('remote.backendUrl').replace(/^wss?:\/\//, 'https://').replace(/\/ws.*$/, '')
+      : getBackendBaseUrl();
+
+    const connectUrl = 'https://otherwise.ai/connect';
+    let pairingToken = config.get('remote.pairingToken');
+
+    // If we have a saved token, validate it first; if invalid/expired, clear and get a new code
+    if (pairingToken) {
+      let valid = false;
+      try {
+        const validatePath = '/api/pairing-token/validate';
+        let res = await fetch(`${baseUrl}${validatePath}?token=${encodeURIComponent(pairingToken)}`);
+        if (res.status === 404) {
+          const altPath = '/pairing-token/validate';
+          res = await fetch(`${baseUrl}${altPath}?token=${encodeURIComponent(pairingToken)}`);
+        }
+        valid = res.ok && (await res.json().catch(() => ({}))).valid === true;
+      } catch (_) {
+        valid = false;
+      }
+      if (!valid) {
+        config.set('remote.pairingToken', null);
+        pairingToken = null;
+      }
+    }
+
+    if (!pairingToken) {
+      console.log(chalk.cyan('\n  Connect to otherwise.ai\n'));
+      console.log(chalk.dim('  Backend: ') + chalk.dim(baseUrl));
+      console.log(chalk.white('  Open: ') + chalk.underline(connectUrl) + chalk.white('\n'));
+
+      const spinner = ora('Getting device code...').start();
+      let codeDisplay;
+      let codeKey;
+      let deviceCodePath = '/api/device-code';
+      const maxAttempts = 5;
+      const retryDelays = [0, 3000, 6000, 10000, 15000];
+      let lastError;
+      for (let attempt = 0; attempt < maxAttempts; attempt++) {
+        if (attempt > 0) {
+          spinner.text = `Backend may be waking up, retrying (${attempt + 1}/${maxAttempts})...`;
+          await new Promise((r) => setTimeout(r, retryDelays[attempt]));
+        }
+        try {
+          const controller = new AbortController();
+          const timeoutId = setTimeout(() => controller.abort(), 30000);
+          let url = `${baseUrl}${deviceCodePath}`;
+          let res = await fetch(url, {
+            method: 'POST',
+            signal: controller.signal,
+            headers: { 'Content-Type': 'application/json' },
+          });
+          if (res.status === 404 && deviceCodePath === '/api/device-code') {
+            deviceCodePath = '/device-code';
+            url = `${baseUrl}${deviceCodePath}`;
+            res = await fetch(url, {
+              method: 'POST',
+              signal: controller.signal,
+              headers: { 'Content-Type': 'application/json' },
+            });
+          }
+          clearTimeout(timeoutId);
+          const data = await res.json().catch(() => ({}));
+          if (res.ok && data.code) {
+            codeDisplay = data.code;
+            codeKey = codeDisplay.replace(/-/g, '');
+            spinner.succeed('Got device code');
+            break;
+          }
+          lastError = data.error || `Backend returned ${res.status}`;
+        } catch (err) {
+          lastError = err.message || String(err);
+          if (err.name === 'AbortError') lastError = 'Request timed out (backend may be starting)';
+        }
+        if (attempt === maxAttempts - 1) {
+          spinner.fail('Could not get device code');
+          console.error(chalk.red(lastError));
+          console.error(chalk.dim('Run otherwise connect again once your backend is available.'));
+          process.exit(1);
+        }
+      }
+
+      console.log(chalk.white('  Enter this code at ') + chalk.underline(connectUrl) + chalk.white(':\n'));
+      console.log(chalk.bold.cyan(`    ${codeDisplay}\n`));
+      console.log(chalk.dim('  Waiting for you to authorize... (code expires in 15 min)\n'));
+
+      const statusPath = deviceCodePath + '/status';
+      const pollInterval = 2500;
+      pairingToken = await new Promise((resolve, reject) => {
+        const timer = setInterval(async () => {
+          try {
+            const statusRes = await fetch(`${baseUrl}${statusPath}?code=${encodeURIComponent(codeKey)}`);
+            const statusData = await statusRes.json().catch(() => ({}));
+            if (statusData.status === 'authorized' && statusData.token) {
+              clearInterval(timer);
+              resolve(statusData.token);
+            } else if (statusData.status === 'expired') {
+              clearInterval(timer);
+              reject(new Error('Code expired. Run otherwise connect again to get a new code.'));
+            }
+          } catch (e) {
+            // keep polling on network errors
+          }
+        }, pollInterval);
+      }).catch((err) => {
+        console.error(chalk.red(err.message));
+        process.exit(1);
+      });
+
+      config.set('remote.pairingToken', pairingToken);
+      config.set('remote.backendUrl', baseUrl);
+    } else {
+      console.log(chalk.cyan('\n  Connect to otherwise.ai\n'));
+      console.log(chalk.dim('  Using saved connection (no code needed).\n'));
+    }
+
+    const spinner2 = ora('Starting server and connecting to backend...').start();
+    try {
+      await startServer(port, { remotePairingToken: pairingToken });
+      spinner2.succeed('Connected!');
+      console.log(chalk.green(`  Server: ${serverUrl}`));
+      console.log(chalk.green('  Remote: otherwise.ai will route to this CLI.\n'));
+
+      if (verbose) {
+        console.log(chalk.dim('  Verbose mode — raw logs below. Chat in browser.'));
+        console.log(chalk.dim('  Press Ctrl+C to stop.\n'));
+        await open(serverUrl);
+        return;
+      }
+
+      console.log(chalk.dim('  Opening CLI — chat state will sync with otherwise.ai.'));
+      console.log(chalk.dim('  Press Ctrl+C to stop.\n'));
+      await new Promise((r) => setTimeout(r, 1500));
+      process.stdout.write('\x1b[2J\x1b[H');
+      const { spawn } = await import('child_process');
+      const { fileURLToPath } = await import('url');
+      const { dirname, join } = await import('path');
+      const __filename = fileURLToPath(import.meta.url);
+      const __dirname = dirname(__filename);
+      const inkEntryPath = join(__dirname, 'ui', 'ink-runner.js');
+      const child = spawn('npx', ['tsx', inkEntryPath, serverUrl, 'true', 'remote'], {
+        stdio: 'inherit',
+        cwd: process.cwd(),
+      });
+      await new Promise((resolve, reject) => {
+        child.on('error', reject);
+        child.on('exit', (code) => resolve(code));
+      });
+    } catch (err) {
+      spinner2.fail('Failed to start');
+      console.error(chalk.red(err.message));
+      process.exit(1);
+    }
+  });
+
+// Deploy command
+program
+  .command('deploy')
+  .description('Deploy to a public domain via Cloudflare Tunnel')
+  .option('-quick', 'Use quick tunnel (temporary URL)')
+  .option('-p, -port <port>', 'Port to tunnel', '3000')
+  .action(async (options) => {
+    const { isCloudflaredInstalled, startQuickTunnel, startNamedTunnel, getSetupInstructions } = await import('./tunnel/cloudflare.js');
+    
+    console.log(chalk.cyan('\nDeploy to Public Domain\n'));
+    
+    if (!isCloudflaredInstalled()) {
+      console.log(chalk.yellow('cloudflared is not installed.\n'));
+      console.log(getSetupInstructions());
+      return;
+    }
+
+    const port = parseInt(options.port ?? options.Port ?? '3000', 10);
+
+    // Start the server first
+    const spinner = ora('Starting server...').start();
+    await startServer(port);
+    spinner.succeed(`Server running on port ${port}`);
+
+    if (options.quick ?? options.Quick) {
+      // Quick tunnel mode
+      const spinner2 = ora('Starting quick tunnel...').start();
+      try {
+        const url = await startQuickTunnel(port);
+        spinner2.succeed(`Tunnel active!`);
+        console.log(chalk.green(`\n  Public URL: ${url}\n`));
+        console.log(chalk.dim('  This URL is temporary and will change on restart.'));
+        console.log(chalk.dim('  For a permanent domain, use: otherwise deploy (without -quick)\n'));
+      } catch (err) {
+        spinner2.fail('Failed to start tunnel');
+        console.error(chalk.red(err.message));
+      }
+    } else {
+      // Named tunnel mode
+      const tunnelName = config.get('tunnel.name');
+      const domain = config.get('tunnel.domain');
+      
+      if (!tunnelName || !domain) {
+        console.log(chalk.yellow('Tunnel not configured.\n'));
+        console.log(getSetupInstructions());
+        return;
+      }
+      
+      const spinner2 = ora(`Starting tunnel for ${domain}...`).start();
+      try {
+        const url = await startNamedTunnel(tunnelName, port, domain);
+        spinner2.succeed(`Tunnel active!`);
+        console.log(chalk.green(`\n  Public URL: ${url}\n`));
+      } catch (err) {
+        spinner2.fail('Failed to start tunnel');
+        console.error(chalk.red(err.message));
+      }
+    }
+    
+    console.log(chalk.dim('Press Ctrl+C to stop\n'));
+  });
+
+// Login command - start server and open login page in browser
+program
+  .command('login')
+  .description('Open the login page to sign in with your account (GitHub, Google, or email)')
+  .option('-p, -port <port>', 'Port to run on', '3000')
+  .action(async (options) => {
+    const port = parseInt(options.port ?? options.Port ?? '3000', 10);
+    const serverUrl = `http://localhost:${port}`;
+    const loginUrl = `${serverUrl}/login`;
+
+    console.log(chalk.cyan('\n  Sign in to Otherwise\n'));
+
+    const spinner = ora('Starting server...').start();
+    try {
+      await startServer(port);
+      spinner.succeed(`Server running at ${chalk.green(serverUrl)}`);
+    } catch (err) {
+      spinner.fail('Failed to start server');
+      console.error(chalk.red(err.message));
+      process.exit(1);
+    }
+
+    console.log();
+    console.log(chalk.cyan('  ┌────────────────────────────────────────┐'));
+    console.log(chalk.cyan('  │') + chalk.bold('  Login: ') + chalk.green.underline(loginUrl) + chalk.cyan('  │'));
+    console.log(chalk.cyan('  └────────────────────────────────────────┘'));
+    console.log();
+    console.log(chalk.dim('  Opening login page in your browser...'));
+    await open(loginUrl);
+    console.log(chalk.dim('  Sign in with GitHub, Google, or email to sync your chats.'));
+    console.log(chalk.dim(`  If OAuth fails, add ${chalk.underline(serverUrl)} to Supabase Auth → URL Configuration → Redirect URLs.`));
+    console.log(chalk.dim('  Press Ctrl+C to stop the server.\n'));
+  });
+
+// Chat command - connects to existing server
+program
+  .command('chat')
+  .description('Connect to running server for CLI chat')
+  .option('-p, -port <port>', 'Server port to connect to', '3000')
+  .action(async (options) => {
+    setTerminalTitle('Otherwise');
+    
+    const port = parseInt(options.port ?? options.Port ?? '3000', 10);
+    const serverUrl = `http://localhost:${port}`;
+    
+    // Check if server is running first
+    try {
+      const healthCheck = await fetch(`${serverUrl}/api/health`);
+      if (!healthCheck.ok) throw new Error('Server not healthy');
+    } catch (err) {
+      console.log(chalk.red('\n  Server is not running.'));
+      console.log(chalk.yellow('\n  TIP: Just run `otherwise` to start both server and CLI!\n'));
+      console.log(chalk.dim('  Or start server separately with: otherwise -server-only\n'));
+      process.exit(1);
+    }
+    
+    // Spawn Ink UI connected to existing server
+    try {
+      const { spawn } = await import('child_process');
+      const { fileURLToPath } = await import('url');
+      const { dirname, join } = await import('path');
+      
+      const __filename = fileURLToPath(import.meta.url);
+      const __dirname = dirname(__filename);
+      const inkEntryPath = join(__dirname, 'ui', 'ink-runner.js');
+      
+      const child = spawn('npx', ['tsx', inkEntryPath, serverUrl, 'true'], {
+        stdio: 'inherit',
+        cwd: process.cwd(),
+      });
+      
+      await new Promise((resolve, reject) => {
+        child.on('error', reject);
+        child.on('exit', resolve);
+      });
+    } catch (err) {
+      console.error(chalk.red('Failed to start UI:'), err.message);
+      process.exit(1);
+    }
+  });
+
+// Voice command - start server and open voice mode in browser
+program
+  .command('voice')
+  .description('Start voice mode - talk to your AI using speech')
+  .option('-p, -port <port>', 'Port to run on', '3000')
+  .action(async (options) => {
+    const port = parseInt(options.port ?? options.Port ?? '3000', 10);
+    const serverUrl = `http://localhost:${port}`;
+
+    console.log(chalk.cyan('\n  Starting Voice Mode...\n'));
+
+    const spinner = ora('Starting server...').start();
+
+    try {
+      await startServer(port);
+      spinner.succeed(`Server running at ${chalk.green(serverUrl)}`);
+    } catch (err) {
+      spinner.fail('Failed to start server');
+      console.error(chalk.red(err.message));
+      process.exit(1);
+    }
+
+    const voiceUrl = `${serverUrl}?voice=true`;
+    console.log();
+    console.log(chalk.cyan('  ┌─────────────────────────────────────────────┐'));
+    console.log(chalk.cyan('  │') + chalk.bold('  Voice Mode: ') + chalk.green.underline(voiceUrl) + chalk.cyan('  │'));
+    console.log(chalk.cyan('  └─────────────────────────────────────────────┘'));
+    console.log();
+    console.log(chalk.dim('  Opening voice mode in your browser...'));
+    await open(voiceUrl);
+    console.log(chalk.dim('  Speak naturally — your voice will be transcribed and sent to your AI.'));
+    console.log(chalk.dim('  Press Ctrl+C to stop the server.\n'));
+  });
+
+export function run() {
+  program.parse();
+}

package/src/inference/anthropic.js

@@ -0,0 +1,113 @@
+import Anthropic from '@anthropic-ai/sdk';
+
+/**
+ * Get max output tokens for a Claude model
+ * @param {string} model - Model identifier
+ * @returns {number} - Max output tokens allowed
+ */
+function getClaudeMaxOutputTokens(model) {
+  // Claude model max output token limits (as of 2025)
+  // See: https://docs.anthropic.com/en/docs/about-claude/models
+  if (model.includes('opus')) {
+    return 32768; // Claude 3 Opus: 32K output
+  }
+  if (model.includes('sonnet-4') || model.includes('claude-4')) {
+    return 64000; // Claude 4/Sonnet 4: 64K output
+  }
+  if (model.includes('sonnet')) {
+    return 8192; // Claude 3/3.5 Sonnet: 8K output
+  }
+  if (model.includes('haiku')) {
+    return 8192; // Claude 3 Haiku: 8K output
+  }
+  // Default conservative limit
+  return 8192;
+}
+
+/**
+ * Stream chat completion from Anthropic Claude
+ * @param {string} model - Model identifier (e.g., 'claude-sonnet-4-20250514')
+ * @param {Array} messages - Array of message objects with role and content
+ * @param {string} systemPrompt - System prompt
+ * @param {object} config - Configuration with API keys and settings
+ * @yields {object} - Chunks with type and content
+ */
+export async function* streamClaude(model, messages, systemPrompt, config) {
+  const apiKey = config.apiKeys?.anthropic;
+  if (!apiKey) {
+    throw new Error('Anthropic API key not configured. Run: otherwise config set anthropic <key>');
+  }
+
+  const client = new Anthropic({ apiKey });
+
+  // Helper: parse data URL to base64 + media_type for Claude
+  const parseDataUrl = (dataUrl) => {
+    if (!dataUrl || !dataUrl.startsWith('data:')) return null;
+    const match = dataUrl.match(/^data:(image\/[^;]+);base64,(.+)$/);
+    if (!match) return null;
+    return { mediaType: match[1], data: match[2] };
+  };
+
+  // Convert messages to Anthropic format (vision: user messages can have images)
+  const anthropicMessages = messages.map(m => {
+    const role = m.role === 'user' ? 'user' : 'assistant';
+    if (m.images && m.images.length > 0 && m.role === 'user') {
+      const content = [];
+      for (const imgDataUrl of m.images) {
+        const parsed = parseDataUrl(imgDataUrl);
+        if (parsed) {
+          content.push({
+            type: 'image',
+            source: {
+              type: 'base64',
+              media_type: parsed.mediaType,
+              data: parsed.data,
+            },
+          });
+        }
+      }
+      content.push({ type: 'text', text: m.content || '' });
+      return { role, content };
+    }
+    return { role, content: m.content };
+  });
+
+  // Cap max_tokens to the model's limit to prevent API errors
+  const modelMaxTokens = getClaudeMaxOutputTokens(model);
+  const requestedMaxTokens = config.maxTokens || 8192;
+  const effectiveMaxTokens = Math.min(requestedMaxTokens, modelMaxTokens);
+
+  const stream = await client.messages.create({
+    model,
+    system: systemPrompt,
+    messages: anthropicMessages,
+    max_tokens: effectiveMaxTokens,
+    temperature: Math.min(config.temperature || 0.7, 1), // Anthropic max is 1
+    stream: true,
+  });
+
+  let outputTokens = 0;
+  let inputTokens = 0;
+
+  for await (const event of stream) {
+    if (event.type === 'content_block_delta' && event.delta?.text) {
+      yield { type: 'text', content: event.delta.text };
+    } else if (event.type === 'message_delta' && event.usage) {
+      // Capture usage stats from message_delta event
+      outputTokens = event.usage.output_tokens || 0;
+    } else if (event.type === 'message_start' && event.message?.usage) {
+      // Capture input tokens from message_start event
+      inputTokens = event.message.usage.input_tokens || 0;
+    } else if (event.type === 'message_stop') {
+      // Stream ended - yield usage stats
+      yield { 
+        type: 'usage', 
+        inputTokens, 
+        outputTokens,
+        totalTokens: inputTokens + outputTokens,
+      };
+    }
+  }
+}
+
+export default { streamClaude };