@geminilight/mindos 0.6.29 → 0.6.30

package/app/lib/acp/subprocess.ts

@@ -8,8 +8,17 @@ import type {
   AcpJsonRpcRequest,
   AcpJsonRpcResponse,
   AcpRegistryEntry,
-  AcpTransportType,
 } from './types';
+import { resolveAgentCommand } from './agent-descriptors';
+import { readSettings } from '../settings';
+
+/** Incoming JSON-RPC request from agent (bidirectional — agent asks US for permission). */
+export interface AcpIncomingRequest {
+  jsonrpc: '2.0';
+  id: string | number;
+  method: string;
+  params?: Record<string, unknown>;
+}
 
 /* ── Types ─────────────────────────────────────────────────────────────── */
 
@@ -21,11 +30,13 @@ export interface AcpProcess {
 }
 
 type MessageCallback = (msg: AcpJsonRpcResponse) => void;
+type RequestCallback = (req: AcpIncomingRequest) => void;
 
 /* ── State ─────────────────────────────────────────────────────────────── */
 
 const processes = new Map<string, AcpProcess>();
 const messageListeners = new Map<string, Set<MessageCallback>>();
+const requestListeners = new Map<string, Set<RequestCallback>>();
 let rpcIdCounter = 1;
 
 /* ── Public API ────────────────────────────────────────────────────────── */
@@ -35,13 +46,17 @@ let rpcIdCounter = 1;
  */
 export function spawnAcpAgent(
   entry: AcpRegistryEntry,
-  options?: { env?: Record<string, string> },
+  options?: { env?: Record<string, string>; cwd?: string },
 ): AcpProcess {
-  const { cmd, args } = buildCommand(entry);
+  const settings = readSettings();
+  const userOverride = settings.acpAgents?.[entry.id];
+  const resolved = resolveAgentCommand(entry.id, entry, userOverride);
+  const { cmd, args } = { cmd: resolved.cmd, args: resolved.args };
 
   const mergedEnv = {
     ...process.env,
     ...(entry.env ?? {}),
+    ...(resolved.env ?? {}),
     ...(options?.env ?? {}),
   };
 
@@ -49,6 +64,7 @@ export function spawnAcpAgent(
     stdio: ['pipe', 'pipe', 'pipe'],
     env: mergedEnv,
     shell: false,
+    ...(options?.cwd ? { cwd: options.cwd } : {}),
   });
 
   const id = `acp-${entry.id}-${Date.now()}`;
@@ -56,6 +72,7 @@ export function spawnAcpAgent(
 
   processes.set(id, acpProc);
   messageListeners.set(id, new Set());
+  requestListeners.set(id, new Set());
 
   // Parse newline-delimited JSON from stdout
   let buffer = '';
@@ -68,10 +85,23 @@ export function spawnAcpAgent(
       const trimmed = line.trim();
       if (!trimmed) continue;
       try {
-        const msg = JSON.parse(trimmed) as AcpJsonRpcResponse;
-        const listeners = messageListeners.get(id);
-        if (listeners) {
-          for (const cb of listeners) cb(msg);
+        const msg = JSON.parse(trimmed);
+
+        // Distinguish incoming requests (agent → client) from responses (to our requests).
+        // Requests have `method` and `id` but no `result`/`error`.
+        const isRequest = msg.method && msg.id !== undefined
+          && !('result' in msg) && !('error' in msg);
+
+        if (isRequest) {
+          const reqListeners = requestListeners.get(id);
+          if (reqListeners) {
+            for (const cb of reqListeners) cb(msg as AcpIncomingRequest);
+          }
+        } else {
+          const listeners = messageListeners.get(id);
+          if (listeners) {
+            for (const cb of listeners) cb(msg as AcpJsonRpcResponse);
+          }
         }
       } catch {
         // Not valid JSON — skip (could be agent debug output)
@@ -79,13 +109,26 @@ export function spawnAcpAgent(
     }
   });
 
-  proc.on('close', () => {
+  // Capture stderr for debugging (agents may log startup errors there)
+  let stderrBuf = '';
+  proc.stderr?.on('data', (chunk: Buffer) => {
+    stderrBuf += chunk.toString();
+    // Keep only last 4KB to avoid unbounded memory
+    if (stderrBuf.length > 4096) stderrBuf = stderrBuf.slice(-4096);
+  });
+
+  proc.on('close', (code) => {
     acpProc.alive = false;
+    if (code && code !== 0 && stderrBuf.trim()) {
+      console.error(`[ACP] ${entry.id} exited with code ${code}: ${stderrBuf.trim().slice(0, 500)}`);
+    }
     messageListeners.delete(id);
+    requestListeners.delete(id);
   });
 
-  proc.on('error', () => {
+  proc.on('error', (err) => {
     acpProc.alive = false;
+    console.error(`[ACP] ${entry.id} spawn error:`, err.message);
   });
 
   return acpProc;
@@ -166,6 +209,15 @@ export function killAgent(acpProc: AcpProcess): void {
   acpProc.alive = false;
   processes.delete(acpProc.id);
   messageListeners.delete(acpProc.id);
+  requestListeners.delete(acpProc.id);
+  // Clean up any terminals spawned by this process
+  const terms = terminalMaps.get(acpProc.id);
+  if (terms) {
+    for (const entry of terms.values()) {
+      if (entry.child.exitCode === null) entry.child.kill('SIGTERM');
+    }
+    terminalMaps.delete(acpProc.id);
+  }
 }
 
 /**
@@ -191,19 +243,253 @@ export function killAllAgents(): void {
   }
 }
 
-/* ── Internal ──────────────────────────────────────────────────────────── */
+/**
+ * Register a callback for incoming JSON-RPC REQUESTS from the agent
+ * (bidirectional: agent asks client for permission / capability).
+ * Returns an unsubscribe function.
+ */
+export function onRequest(acpProc: AcpProcess, callback: RequestCallback): () => void {
+  const listeners = requestListeners.get(acpProc.id);
+  if (!listeners) throw new Error(`ACP process ${acpProc.id} not found`);
+
+  listeners.add(callback);
+  return () => { listeners.delete(callback); };
+}
+
+/**
+ * Send a raw JSON-RPC response back to the agent's stdin.
+ * Used for replying to incoming requests (e.g. permission approvals).
+ */
+export function sendResponse(
+  acpProc: AcpProcess,
+  id: string | number,
+  result: unknown,
+): void {
+  if (!acpProc.alive || !acpProc.proc.stdin?.writable) {
+    throw new Error(`ACP process ${acpProc.id} is not alive`);
+  }
+
+  const response: AcpJsonRpcResponse = {
+    jsonrpc: '2.0',
+    id,
+    result,
+  };
+  acpProc.proc.stdin.write(JSON.stringify(response) + '\n');
+}
+
+/**
+ * Install auto-approval for all incoming permission/capability requests.
+ * Agents in ACP mode send requests like fs/read, fs/write, terminal/execute etc.
+ * Without approval, the agent hangs waiting for TTY input that never comes.
+ * Returns an unsubscribe function.
+ */
+export function installAutoApproval(acpProc: AcpProcess): () => void {
+  return onRequest(acpProc, (req) => {
+    const method = req.method;
+    const params = (req.params ?? {}) as Record<string, unknown>;
+
+    switch (method) {
+      // ── File system: read ──
+      case 'fs/read_text_file': {
+        const filePath = String(params.path ?? '');
+        if (!filePath) {
+          sendResponse(acpProc, req.id, { error: { code: -32602, message: 'path is required' } });
+          return;
+        }
+        try {
+          const fs = require('fs');
+          const line = typeof params.line === 'number' ? params.line : undefined;
+          const limit = typeof params.limit === 'number' ? params.limit : undefined;
+          let content = fs.readFileSync(filePath, 'utf-8') as string;
+          if (line !== undefined || limit !== undefined) {
+            const lines = content.split('\n');
+            const start = (line ?? 1) - 1; // 1-based to 0-based
+            const end = limit !== undefined ? start + limit : lines.length;
+            content = lines.slice(Math.max(0, start), end).join('\n');
+          }
+          sendResponse(acpProc, req.id, { content });
+        } catch (err) {
+          sendResponse(acpProc, req.id, { error: { code: -32002, message: (err as Error).message } });
+        }
+        return;
+      }
+
+      // ── File system: write ──
+      case 'fs/write_text_file': {
+        const filePath = String(params.path ?? '');
+        const content = String(params.content ?? '');
+        if (!filePath) {
+          sendResponse(acpProc, req.id, { error: { code: -32602, message: 'path is required' } });
+          return;
+        }
+        try {
+          const fs = require('fs');
+          const path = require('path');
+          const dir = path.dirname(filePath);
+          if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+          fs.writeFileSync(filePath, content, 'utf-8');
+          sendResponse(acpProc, req.id, {});
+        } catch (err) {
+          sendResponse(acpProc, req.id, { error: { code: -32603, message: (err as Error).message } });
+        }
+        return;
+      }
+
+      // ── Terminal: create ──
+      case 'terminal/create': {
+        const command = String(params.command ?? '');
+        const args = Array.isArray(params.args) ? params.args.map(String) : [];
+        const cwd = typeof params.cwd === 'string' ? params.cwd : undefined;
+        const env = (params.env && typeof params.env === 'object') ? params.env as Record<string, string> : undefined;
+        const outputByteLimit = typeof params.outputByteLimit === 'number' ? params.outputByteLimit : 1_000_000;
+
+        if (!command) {
+          sendResponse(acpProc, req.id, { error: { code: -32602, message: 'command is required' } });
+          return;
+        }
+
+        const terminalId = `term-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`;
+        try {
+          const { spawn: spawnChild } = require('child_process');
+          const child = spawnChild(command, args, {
+            cwd,
+            env: { ...process.env, ...(env ?? {}) },
+            shell: true,
+            stdio: ['pipe', 'pipe', 'pipe'],
+          });
+
+          let output = '';
+          let truncated = false;
+
+          child.stdout?.on('data', (chunk: Buffer) => {
+            if (output.length < outputByteLimit) {
+              output += chunk.toString();
+              if (output.length > outputByteLimit) {
+                output = output.slice(0, outputByteLimit);
+                truncated = true;
+              }
+            }
+          });
+          child.stderr?.on('data', (chunk: Buffer) => {
+            if (output.length < outputByteLimit) {
+              output += chunk.toString();
+              if (output.length > outputByteLimit) {
+                output = output.slice(0, outputByteLimit);
+                truncated = true;
+              }
+            }
+          });
+
+          // Store terminal in process-scoped map
+          const terminalMap = getOrCreateTerminalMap(acpProc.id);
+          terminalMap.set(terminalId, { child, output: () => output, truncated: () => truncated });
+
+          sendResponse(acpProc, req.id, { terminalId });
+        } catch (err) {
+          sendResponse(acpProc, req.id, { error: { code: -32603, message: (err as Error).message } });
+        }
+        return;
+      }
+
+      // ── Terminal: output ──
+      case 'terminal/output': {
+        const terminalId = String(params.terminalId ?? '');
+        const terminal = getTerminal(acpProc.id, terminalId);
+        if (!terminal) {
+          sendResponse(acpProc, req.id, { error: { code: -32002, message: `Terminal not found: ${terminalId}` } });
+          return;
+        }
+        const exitStatus = terminal.child.exitCode !== null ? { exitCode: terminal.child.exitCode } : undefined;
+        sendResponse(acpProc, req.id, { output: terminal.output(), truncated: terminal.truncated(), exitStatus });
+        return;
+      }
+
+      // ── Terminal: kill ──
+      case 'terminal/kill': {
+        const terminalId = String(params.terminalId ?? '');
+        const terminal = getTerminal(acpProc.id, terminalId);
+        if (!terminal) {
+          sendResponse(acpProc, req.id, { error: { code: -32002, message: `Terminal not found: ${terminalId}` } });
+          return;
+        }
+        terminal.child.kill('SIGTERM');
+        sendResponse(acpProc, req.id, {});
+        return;
+      }
+
+      // ── Terminal: wait_for_exit ──
+      case 'terminal/wait_for_exit': {
+        const terminalId = String(params.terminalId ?? '');
+        const terminal = getTerminal(acpProc.id, terminalId);
+        if (!terminal) {
+          sendResponse(acpProc, req.id, { error: { code: -32002, message: `Terminal not found: ${terminalId}` } });
+          return;
+        }
+        if (terminal.child.exitCode !== null) {
+          sendResponse(acpProc, req.id, { exitCode: terminal.child.exitCode, signal: terminal.child.signalCode });
+          return;
+        }
+        terminal.child.on('exit', (code: number | null, signal: string | null) => {
+          sendResponse(acpProc, req.id, { exitCode: code, signal });
+        });
+        return;
+      }
+
+      // ── Terminal: release ──
+      case 'terminal/release': {
+        const terminalId = String(params.terminalId ?? '');
+        const terminal = getTerminal(acpProc.id, terminalId);
+        if (!terminal) {
+          sendResponse(acpProc, req.id, { error: { code: -32002, message: `Terminal not found: ${terminalId}` } });
+          return;
+        }
+        if (terminal.child.exitCode === null) terminal.child.kill('SIGTERM');
+        removeTerminal(acpProc.id, terminalId);
+        sendResponse(acpProc, req.id, {});
+        return;
+      }
+
+      // ── Permission requests (auto-approve all) ──
+      case 'session/request_permission': {
+        console.log(`[ACP] Auto-approving permission: ${JSON.stringify(params.toolCall ?? {}).slice(0, 200)}`);
+        sendResponse(acpProc, req.id, { outcome: { selected: { optionId: 'allow_once' } } });
+        return;
+      }
+
+      // ── Unknown methods: auto-approve for backwards compat ──
+      default: {
+        console.log(`[ACP] Auto-approving unknown agent request: ${method} (id=${req.id})`);
+        sendResponse(acpProc, req.id, {});
+      }
+    }
+  });
+}
+
+/* ── Terminal management (per ACP process) ─────────────────────────────── */
+
+interface TerminalEntry {
+  child: import('child_process').ChildProcess;
+  output: () => string;
+  truncated: () => boolean;
+}
 
-function buildCommand(entry: AcpRegistryEntry): { cmd: string; args: string[] } {
-  const transport: AcpTransportType = entry.transport;
+const terminalMaps = new Map<string, Map<string, TerminalEntry>>();
 
-  switch (transport) {
-    case 'npx':
-      return { cmd: 'npx', args: [entry.command, ...(entry.args ?? [])] };
-    case 'uvx':
-      return { cmd: 'uvx', args: [entry.command, ...(entry.args ?? [])] };
-    case 'binary':
-    case 'stdio':
-    default:
-      return { cmd: entry.command, args: entry.args ?? [] };
+function getOrCreateTerminalMap(procId: string): Map<string, TerminalEntry> {
+  let map = terminalMaps.get(procId);
+  if (!map) {
+    map = new Map();
+    terminalMaps.set(procId, map);
   }
+  return map;
+}
+
+function getTerminal(procId: string, terminalId: string): TerminalEntry | undefined {
+  return terminalMaps.get(procId)?.get(terminalId);
+}
+
+function removeTerminal(procId: string, terminalId: string): void {
+  terminalMaps.get(procId)?.delete(terminalId);
 }
+
+/* ── Internal — agent command resolution moved to agent-descriptors.ts ─ */

package/app/lib/acp/types.ts

@@ -10,14 +10,63 @@
 /** How an ACP agent is spawned */
 export type AcpTransportType = 'stdio' | 'npx' | 'uvx' | 'binary';
 
+/* ── ContentBlock (ACP prompt format) ─────────────────────────────────── */
+
+export type AcpContentBlock =
+  | { type: 'text'; text: string }
+  | { type: 'image'; data: string; mimeType: string }
+  | { type: 'audio'; data: string; mimeType: string }
+  | { type: 'resource_link'; uri: string; name: string }
+  | { type: 'resource'; resource: { uri: string; text?: string; blob?: string } };
+
+/* ── StopReason ───────────────────────────────────────────────────────── */
+
+export type AcpStopReason = 'end_turn' | 'max_tokens' | 'max_turn_requests' | 'refusal' | 'cancelled';
+
+/* ── Modes & Config ───────────────────────────────────────────────────── */
+
+export interface AcpMode {
+  id: string;
+  name: string;
+  description?: string;
+}
+
+export interface AcpConfigOptionEntry {
+  id: string;
+  label: string;
+}
+
+export interface AcpConfigOption {
+  type: 'select';
+  configId: string;
+  category: 'mode' | 'model' | 'thought_level' | 'other' | string;
+  label?: string;
+  currentValue: string;
+  options: AcpConfigOptionEntry[];
+}
+
+/* ── Auth ──────────────────────────────────────────────────────────────── */
+
+export interface AcpAuthMethod {
+  id: string;
+  name: string;
+  description?: string;
+}
+
 /* ── Capabilities ─────────────────────────────────────────────────────── */
 
-/** What MindOS exposes as an ACP agent */
-export interface AcpCapabilities {
-  streaming: boolean;
-  toolCalls: boolean;
-  multiTurn: boolean;
-  cancellation: boolean;
+/** What the agent declares it supports (from initialize response). */
+export interface AcpAgentCapabilities {
+  loadSession?: boolean;
+  mcpCapabilities?: { http?: boolean; sse?: boolean };
+  promptCapabilities?: { audio?: boolean; embeddedContext?: boolean; image?: boolean };
+  sessionCapabilities?: { list?: boolean };
+}
+
+/** What MindOS declares as a client (sent in initialize request). */
+export interface AcpClientCapabilities {
+  fs?: { readTextFile?: boolean; writeTextFile?: boolean };
+  terminal?: boolean;
 }
 
 /* ── Session ──────────────────────────────────────────────────────────── */
@@ -28,8 +77,25 @@ export interface AcpSession {
   id: string;
   agentId: string;
   state: AcpSessionState;
+  cwd?: string;
   createdAt: string;
   lastActivityAt: string;
+  /** Agent capabilities from initialize response */
+  agentCapabilities?: AcpAgentCapabilities;
+  /** Modes available from session/new or session/load response */
+  modes?: AcpMode[];
+  /** Config options from session/new or session/load response */
+  configOptions?: AcpConfigOption[];
+  /** Auth methods from initialize response */
+  authMethods?: AcpAuthMethod[];
+}
+
+/** Lightweight session info returned by session/list. */
+export interface AcpSessionInfo {
+  sessionId: string;
+  title?: string;
+  cwd?: string;
+  updatedAt?: string;
 }
 
 /* ── JSON-RPC (ACP uses JSON-RPC 2.0 over stdio) ─────────────────────── */
@@ -58,32 +124,27 @@ export interface AcpJsonRpcError {
 
 export interface AcpPromptRequest {
   sessionId: string;
-  text: string;
-  metadata?: Record<string, unknown>;
+  prompt: AcpContentBlock[];
+  context?: { cwd?: string };
+  stream?: boolean;
 }
 
 export interface AcpPromptResponse {
   sessionId: string;
   text: string;
   done: boolean;
+  stopReason?: AcpStopReason;
   toolCalls?: AcpToolCall[];
   metadata?: Record<string, unknown>;
 }
 
-/* ── Session Updates (streaming) ──────────────────────────────────────── */
-
-export type AcpUpdateType = 'text' | 'tool_call' | 'tool_result' | 'done' | 'error';
+/* ── ToolCall (full ACP model) ────────────────────────────────────────── */
 
-export interface AcpSessionUpdate {
-  sessionId: string;
-  type: AcpUpdateType;
-  text?: string;
-  toolCall?: AcpToolCall;
-  toolResult?: AcpToolResult;
-  error?: string;
-}
+export type AcpToolCallKind =
+  | 'read' | 'edit' | 'delete' | 'move' | 'search'
+  | 'execute' | 'think' | 'fetch' | 'switch_mode' | 'other';
 
-/* ── Tool Calls ───────────────────────────────────────────────────────── */
+export type AcpToolCallStatus = 'pending' | 'in_progress' | 'completed' | 'failed';
 
 export interface AcpToolCall {
   id: string;
@@ -91,12 +152,85 @@ export interface AcpToolCall {
   arguments: Record<string, unknown>;
 }
 
+/** Full tool call with status, kind, and content — used in session updates. */
+export interface AcpToolCallFull {
+  toolCallId: string;
+  title?: string;
+  kind?: AcpToolCallKind;
+  status: AcpToolCallStatus;
+  rawInput?: string;
+  rawOutput?: string;
+  content?: AcpContentBlock[];
+  locations?: { path: string; line?: number }[];
+}
+
 export interface AcpToolResult {
   callId: string;
   result: string;
   isError?: boolean;
 }
 
+/* ── Plan ──────────────────────────────────────────────────────────────── */
+
+export type AcpPlanEntryStatus = 'pending' | 'in_progress' | 'completed';
+export type AcpPlanEntryPriority = 'high' | 'medium' | 'low';
+
+export interface AcpPlanEntry {
+  content: string;
+  status: AcpPlanEntryStatus;
+  priority: AcpPlanEntryPriority;
+}
+
+export interface AcpPlan {
+  entries: AcpPlanEntry[];
+}
+
+/* ── Session Updates (streaming) — Full ACP spec ──────────────────────── */
+
+export type AcpUpdateType =
+  | 'user_message_chunk'
+  | 'agent_message_chunk'
+  | 'agent_thought_chunk'
+  | 'tool_call'
+  | 'tool_call_update'
+  | 'plan'
+  | 'available_commands_update'
+  | 'current_mode_update'
+  | 'config_option_update'
+  | 'session_info_update'
+  // Legacy compat (mapped internally)
+  | 'text'
+  | 'tool_result'
+  | 'done'
+  | 'error';
+
+export interface AcpSessionUpdate {
+  sessionId: string;
+  type: AcpUpdateType;
+  /** Text content for message chunk types */
+  text?: string;
+  /** Structured tool call data */
+  toolCall?: AcpToolCallFull;
+  /** Tool result (legacy) */
+  toolResult?: AcpToolResult;
+  /** Plan entries */
+  plan?: AcpPlan;
+  /** Available commands (opaque to client) */
+  availableCommands?: unknown[];
+  /** Current mode ID */
+  currentModeId?: string;
+  /** Updated config options */
+  configOptions?: AcpConfigOption[];
+  /** Session info update */
+  sessionInfo?: { title?: string; updatedAt?: string };
+  /** Error message */
+  error?: string;
+}
+
+/* ── Permission ───────────────────────────────────────────────────────── */
+
+export type AcpPermissionOutcome = 'allow_once' | 'allow_always' | 'reject_once' | 'reject_always';
+
 /* ── Registry ─────────────────────────────────────────────────────────── */
 
 /** An entry from the ACP registry (registry.json) */
@@ -107,6 +241,8 @@ export interface AcpRegistryEntry {
   version?: string;
   transport: AcpTransportType;
   command: string;
+  /** npm package name for npx-based agents (e.g. "@google/gemini-cli") */
+  packageName?: string;
   args?: string[];
   env?: Record<string, string>;
   tags?: string[];
@@ -128,6 +264,8 @@ export const ACP_ERRORS = {
   AGENT_NOT_FOUND: { code: -32003, message: 'Agent not found in registry' },
   SPAWN_FAILED: { code: -32004, message: 'Failed to spawn agent process' },
   TRANSPORT_ERROR: { code: -32005, message: 'Transport error' },
+  AUTH_REQUIRED: { code: -32000, message: 'Authentication required' },
+  RESOURCE_NOT_FOUND: { code: -32002, message: 'Resource not found' },
   PARSE_ERROR: { code: -32700, message: 'Parse error' },
   INVALID_REQUEST: { code: -32600, message: 'Invalid request' },
   METHOD_NOT_FOUND: { code: -32601, message: 'Method not found' },

package/app/lib/agent/model.ts

@@ -1,6 +1,19 @@
 import { getModel as piGetModel, type Model } from '@mariozechner/pi-ai';
 import { effectiveAiConfig } from '@/lib/settings';
 
+/** Check if any message in the conversation contains images */
+export function hasImages(messages: Array<{ images?: unknown[] }>): boolean {
+  return messages.some(m => m.images && m.images.length > 0);
+}
+
+/** Ensure model input includes 'image' when images are present */
+function ensureVisionCapable(model: Model<any>): Model<any> {
+  const inputs = model.input as readonly string[];
+  if (inputs.includes('image')) return model;
+  // Upgrade input to include image — most modern models support it
+  return { ...model, input: [...inputs, 'image'] as any };
+}
+
 /**
  * Build a pi-ai Model for the configured provider.
  *
@@ -11,7 +24,7 @@ import { effectiveAiConfig } from '@/lib/settings';
  *
  * Returns { model, modelName, apiKey } — Agent needs model + apiKey via getApiKey hook.
  */
-export function getModelConfig(): {
+export function getModelConfig(options?: { hasImages?: boolean }): {
   model: Model<any>;
   modelName: string;
   apiKey: string;
@@ -77,7 +90,8 @@ export function getModelConfig(): {
       }
     }
 
-    return { model, modelName, apiKey: cfg.openaiApiKey, provider: 'openai' };
+    const finalModel = options?.hasImages ? ensureVisionCapable(model) : model;
+    return { model: finalModel, modelName, apiKey: cfg.openaiApiKey, provider: 'openai' };
   }
 
   // Anthropic
@@ -104,5 +118,6 @@ export function getModelConfig(): {
     };
   }
 
-  return { model, modelName, apiKey: cfg.anthropicApiKey, provider: 'anthropic' };
+  const finalModel = options?.hasImages ? ensureVisionCapable(model) : model;
+  return { model: finalModel, modelName, apiKey: cfg.anthropicApiKey, provider: 'anthropic' };
 }