@exreve/exk 1.0.16 → 1.0.18

package/dist/agentSession.js

@@ -1,14 +1,57 @@
 import { query } from '@anthropic-ai/claude-agent-sdk';
 import { execSync, spawn } from 'child_process';
-import { existsSync, mkdirSync, readFileSync } from 'fs';
+import { existsSync, mkdirSync, readFileSync, writeFileSync, unlinkSync } from 'fs';
 import { symlink as fsSymlink } from 'fs';
-// Memory system removed for performance
 import { getSkillContent } from './skills/index.js';
+import { isLocalModel, unwrapModelName, startOpenAIAdapter, getAdapterConfig } from './openaiAdapter.js';
 import { createModuleMcpServer } from './moduleMcpServer.js';
 import path from 'path';
 import os from 'os';
 import { createRequire } from 'module';
 import { promisify } from 'util';
+// ============ Session State Persistence ============
+// Persists claudeSessionId to disk so context survives CLI restarts.
+// Files are stored in ~/.talk-to-code/session-state/<sessionId>.json
+const SESSION_STATE_DIR = path.join(os.homedir(), '.talk-to-code', 'session-state');
+function sessionStatePath(sessionId) {
+    return path.join(SESSION_STATE_DIR, `${sessionId}.json`);
+}
+function saveSessionState(sessionId, state) {
+    try {
+        if (!existsSync(SESSION_STATE_DIR)) {
+            mkdirSync(SESSION_STATE_DIR, { recursive: true });
+        }
+        writeFileSync(sessionStatePath(sessionId), JSON.stringify(state, null, 2));
+    }
+    catch (err) {
+        console.error(`[AgentSessionManager] Failed to persist session state for ${sessionId}:`, err);
+    }
+}
+function loadSessionState(sessionId) {
+    try {
+        const filePath = sessionStatePath(sessionId);
+        if (!existsSync(filePath))
+            return null;
+        const data = JSON.parse(readFileSync(filePath, 'utf-8'));
+        if (data && typeof data.claudeSessionId === 'string' && data.claudeSessionId) {
+            return data;
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+function deleteSessionState(sessionId) {
+    try {
+        const filePath = sessionStatePath(sessionId);
+        if (existsSync(filePath))
+            unlinkSync(filePath);
+    }
+    catch {
+        // Ignore cleanup errors
+    }
+}
 /**
  * Resolve path to the SDK's bundled cli.js.
  * We resolve this ourselves so it works reliably on Windows when running from
@@ -91,25 +134,83 @@ function loadAiConfig() {
         const apiKey = typeof config.authToken === 'string' ? config.authToken.trim() : '';
         const baseUrl = typeof config.baseUrl === 'string' ? config.baseUrl.trim() : '';
         const model = typeof config.model === 'string' && config.model.trim() ? config.model.trim() : DEFAULT_AI_MODEL;
-        return { apiKey, baseUrl, model };
+        const proxy = typeof config.proxy === 'string' ? config.proxy.trim() : '';
+        return { apiKey, baseUrl, model, proxy };
+    }
+    catch {
+        return { apiKey: '', baseUrl: '', model: DEFAULT_AI_MODEL, proxy: '' };
+    }
+}
+/** Create (or reuse) an empty directory to use as CLAUDE_CONFIG_DIR.
+ *  Setting this prevents the spawned Claude CLI from reading ~/.claude/settings.json,
+ *  which may contain env.ANTHROPIC_BASE_URL pointing to z.ai and would override our
+ *  carefully configured base URL. */
+function getEmptyConfigDir() {
+    const configDir = path.join(os.homedir(), '.talk-to-code', 'empty-config-dir');
+    if (!existsSync(configDir)) {
+        mkdirSync(configDir, { recursive: true });
+    }
+    return configDir;
+}
+const PROXY_CONFIG_PATH = path.join(os.homedir(), '.talk-to-code', 'proxy.json');
+/** Read proxy toggle state from disk (synchronous) */
+function readProxyToggle() {
+    try {
+        const data = readFileSync(PROXY_CONFIG_PATH, 'utf-8');
+        return JSON.parse(data);
     }
     catch {
-        return { apiKey: '', baseUrl: '', model: DEFAULT_AI_MODEL };
+        return { enabled: false };
     }
 }
-/** Env for the Claude Code child: copy of host env with host ANTHROPIC_* stripped, then inject from ai-config only. */
-function envForClaudeCodeChild() {
+/** Env for the Claude Code child: copy of host env with host ANTHROPIC_* stripped, then inject from ai-config only.
+ *  If a local model is provided, override baseUrl to point to the anthropic-proxy adapter. */
+function envForClaudeCodeChild(localModel) {
     const env = { ...process.env };
+    // Strip any host ANTHROPIC_* vars to prevent leaking credentials or wrong URLs
     delete env.ANTHROPIC_API_KEY;
     delete env.ANTHROPIC_BASE_URL;
     delete env.ANTHROPIC_AUTH_TOKEN;
-    const { apiKey, baseUrl } = loadAiConfig();
+    // Inject from our ai-config.json only
+    const { apiKey, baseUrl, proxy } = loadAiConfig();
     if (apiKey)
         env.ANTHROPIC_API_KEY = apiKey;
     if (baseUrl)
         env.ANTHROPIC_BASE_URL = baseUrl;
+    // Apply proxy if enabled
+    const proxyToggle = readProxyToggle();
+    if (proxyToggle.enabled && proxy) {
+        env.HTTPS_PROXY = proxy;
+        env.HTTP_PROXY = proxy;
+    }
+    else {
+        // Clear any inherited proxy env
+        delete env.HTTPS_PROXY;
+        delete env.HTTP_PROXY;
+        delete env.https_proxy;
+        delete env.http_proxy;
+    }
+    // Prevent ~/.claude/settings.json env section from overriding our base URL.
+    // This redirects the Claude config dir to an empty dir so that
+    // ~/.claude/settings.json (which may have ANTHROPIC_BASE_URL set to z.ai)
+    // is never read during the CLI process initialization.
+    env.CLAUDE_CONFIG_DIR = getEmptyConfigDir();
     return env;
 }
+/** Get env overrides for a local model (adapter proxy URL + dummy key). Returns null if not a local model. */
+async function getLocalModelEnvOverrides(model) {
+    if (!isLocalModel(model))
+        return null;
+    const adapterConfig = getAdapterConfig(model);
+    if (!adapterConfig)
+        return null;
+    const proxyUrl = await startOpenAIAdapter({
+        targetBaseUrl: adapterConfig.targetBaseUrl,
+        model: unwrapModelName(model),
+        apiKey: adapterConfig.apiKey,
+    });
+    return { baseUrl: proxyUrl, apiKey: 'local-no-key-needed' };
+}
 // Lazy config getter - reloads from file each time (so daemon picks up changes without restart)
 const CLAUDE_CONFIG = {
     get apiKey() { return loadAiConfig().apiKey; },
@@ -146,60 +247,39 @@ export class AgentSessionManager {
                 }
             }
         }
-        // If session already exists, update the model if provided
+        // If session already exists, update mutable fields
         if (this.sessions.has(sessionId)) {
             const existingSession = this.sessions.get(sessionId);
             // Update model if a new one is provided
             if (model && model !== existingSession.model) {
                 existingSession.model = model;
-                // DISABLED: File logging removed for performance
-                // if (existingSession.logger) {
-                //   await existingSession.logger.info(`Model updated to: ${model}`)
-                // }
             }
-            // DISABLED: File logging removed for performance
-            // if (existingSession.logger) {
-            //   await existingSession.logger.info('Session already exists, reusing context')
-            // }
-            // Just ensure abort controller is fresh for new queries
+            // Update enabled modules and settings if provided
+            const newModules = handler.enabledModules;
+            if (newModules) {
+                existingSession.enabledModules = newModules;
+            }
+            const newModuleSettings = handler.moduleSettings;
+            if (newModuleSettings) {
+                existingSession.moduleSettings = newModuleSettings;
+            }
+            existingSession.userChoiceEnabled = handler.userChoiceEnabled || false;
+            // Ensure abort controller is fresh for new queries
             existingSession.abortController = new AbortController();
+            // Update handler to keep onChoiceRequest callback fresh
+            this.sessionHandlers.set(sessionId, handler);
             return;
         }
-        // DISABLED: File logging removed for performance
-        // const logger = new AgentLogger(sessionId)
-        // await logger.logSessionCreated(projectPath)
-        // await logger.logModelConfig(sessionModel, CLAUDE_CONFIG.baseUrl)
-        const logger = undefined;
         // Store the handler for this session
         this.sessionHandlers.set(sessionId, handler);
         const abortController = new AbortController();
-        // Create MCP server for modules if enabled modules are provided
-        let mcpServer;
         const enabledModules = handler.enabledModules || [];
         const moduleSettings = handler.moduleSettings || {};
-        if (enabledModules.length > 0) {
-            mcpServer = createModuleMcpServer({
-                enabledModules,
-                moduleSettings,
-                onChoiceRequest: handler.onChoiceRequest
-                    ? async (request) => {
-                        return new Promise((resolve) => {
-                            const session = this.sessions.get(sessionId);
-                            if (session) {
-                                session.pendingChoice = { request, resolve };
-                                handler.onChoiceRequest(request);
-                            }
-                            else {
-                                resolve({ choiceId: request.choiceId, selectedValue: null });
-                            }
-                        });
-                    }
-                    : undefined
-            });
-            // DISABLED: File logging removed for performance
-            // if (logger) {
-            //   await logger.info(`MCP server created with modules: ${enabledModules.join(', ')}`)
-            // }
+        // Restore claudeSessionId from disk (survives CLI restart)
+        const persistedState = loadSessionState(sessionId);
+        const restoredClaudeSessionId = persistedState?.claudeSessionId;
+        if (restoredClaudeSessionId) {
+            console.log(`[AgentSessionManager] Restored claudeSessionId for session ${sessionId}: ${restoredClaudeSessionId}`);
         }
         this.sessions.set(sessionId, {
             abortController,
@@ -209,35 +289,26 @@ export class AgentSessionManager {
             totalCostUsd: 0,
             promptQueue: [],
             isProcessingQueue: false,
-            claudeSessionId: undefined, // Will be set when Claude SDK returns session ID
-            // logger, // DISABLED: File logging removed for performance
-            // Memory system removed for performance
+            claudeSessionId: restoredClaudeSessionId, // Restored from disk or undefined
             childProcesses: new Set(),
             claudeProcessGroupId: undefined,
             currentPromptId: undefined,
             model: sessionModel,
             userChoiceEnabled: handler.userChoiceEnabled || false,
             enabledModules,
-            moduleSettings,
-            mcpServer
+            moduleSettings
         });
         // Auto-regenerate CLAUDE.md for fresh project context
-        // DISABLED: File logging removed for performance
-        await this.regenerateClaudeMd(projectPath, undefined);
+        await this.regenerateClaudeMd(projectPath);
     }
     /**
      * Regenerate CLAUDE.md for fresh project context
      */
-    async regenerateClaudeMd(projectPath, logger) {
+    async regenerateClaudeMd(projectPath) {
         try {
             const scriptPath = path.join(projectPath, 'scripts', 'generate-claude-md.js');
             if (existsSync(scriptPath)) {
-                const startTime = Date.now();
                 execSync(`node "${scriptPath}"`, { cwd: projectPath, stdio: 'ignore' });
-                const duration = Date.now() - startTime;
-                if (logger) {
-                    await logger.info(`CLAUDE.md regenerated in ${duration}ms`);
-                }
             }
         }
         catch (error) {
@@ -245,7 +316,6 @@ export class AgentSessionManager {
             console.error('[AgentSessionManager] Failed to regenerate CLAUDE.md:', error);
         }
     }
-    // Memory system removed for performance - no loadMemoryContext or storeConversationInMemory
     async sendPrompt(sessionId, prompt, enhancers = [], handler) {
         // Ensure session exists
         if (!this.sessions.has(sessionId)) {
@@ -255,10 +325,6 @@ export class AgentSessionManager {
         // Update session model if provided in handler
         if (handler.model && handler.model !== session.model) {
             session.model = handler.model;
-            // DISABLED: File logging removed for performance
-            // if (session.logger) {
-            //   await session.logger.info(`Model updated to: ${handler.model}`)
-            // }
         }
         // Add prompt to queue - store promptId for cancellation
         session.promptQueue.push({
@@ -317,19 +383,12 @@ export class AgentSessionManager {
                 // Emit status update: CLI is starting to process the prompt (IMMEDIATELY)
                 // This ensures real-time status updates before any async operations
                 onStatusUpdate?.('running');
-                // DISABLED: File logging removed for performance
-                // // Log prompt start
-                // if (session.logger) {
-                //   await session.logger.logPromptStart(prompt, projectPath)
-                // }
                 // Wait for current query to finish before starting next prompt
-                // REMOVED: 200ms artificial delay - stream draining is sufficient
                 if (session.activeQueryStream !== undefined) {
                     try {
                         for await (const _ of session.activeQueryStream) { }
                     }
                     catch { }
-                    // REMOVED: await new Promise(resolve => setTimeout(resolve, 200))
                     session.activeQueryStream = undefined;
                 }
                 session.activeQueryStream = undefined;
@@ -339,11 +398,6 @@ export class AgentSessionManager {
                     const skillContent = getSkillContent(enhancers);
                     if (skillContent) {
                         finalPrompt = `${skillContent}\n\n${prompt}`;
-                        // DISABLED: File logging removed for performance
-                        // // Log that enhancers are being used
-                        // if (session.logger) {
-                        //   await session.logger.info(`Using enhancers: ${enhancers.join(', ')}`)
-                        // }
                     }
                 }
                 // Add user message to history
@@ -375,14 +429,6 @@ export class AgentSessionManager {
                 });
                 // Use cached Claude executable path (resolved at module load time for performance)
                 const pathToClaudeCodeExecutable = CACHED_CLAUDE_PATH;
-                // DISABLED: File logging removed for performance
-                // if (session.logger) {
-                //   if (pathToClaudeCodeExecutable) {
-                //     session.logger.info(`Using Claude (cli.js): ${pathToClaudeCodeExecutable}`).catch(() => {})
-                //   } else {
-                //     session.logger.info('Using SDK built-in Claude (cli.js)').catch(() => {})
-                //   }
-                // }
                 // Build query options - include abort signal for cancellation
                 const queryOptions = {
                     signal: abortController.signal, // Pass abort signal to SDK for interruption
@@ -394,11 +440,18 @@ export class AgentSessionManager {
                     settingSources: ['project'], // Enable CLAUDE.md loading
                     permissionMode: 'bypassPermissions',
                     allowDangerouslySkipPermissions: true,
-                    // Add MCP server for modules if configured
-                    ...(session.mcpServer ? { mcpServers: [session.mcpServer] } : {}),
+                    // Create a fresh MCP server for each query call (SDK connects transport internally, cannot reuse)
+                    ...(() => {
+                        const mcpServer = this.buildMcpServer(sessionId);
+                        return mcpServer ? { mcpServers: [mcpServer] } : {};
+                    })(),
                     ...(pathToClaudeCodeExecutable ? { pathToClaudeCodeExecutable } : {}),
                     spawnClaudeCodeProcess: (spawnOptions) => {
                         const { command, args, cwd: cwd2, env, signal } = spawnOptions;
+                        // Debug: log what env/args are being passed to Claude process
+                        console.log(`[agentSession] Spawn ANTHROPIC_BASE_URL:`, env?.ANTHROPIC_BASE_URL || '(not set)');
+                        console.log(`[agentSession] Spawn ANTHROPIC_API_KEY:`, env?.ANTHROPIC_API_KEY ? '(set)' : '(not set)');
+                        console.log(`[agentSession] Spawn args:`, args?.join(' '));
                         // Only check file existence when command is a path (not a bare name like "claude" from PATH)
                         const hasPathSep = command.includes(path.sep) || command.includes('/') || command.includes('\\');
                         if (hasPathSep && !existsSync(command)) {
@@ -514,18 +567,51 @@ export class AgentSessionManager {
                 };
                 // Log model being used for debugging
                 const sessionModel = session.model || CLAUDE_CONFIG.model;
-                // DISABLED: File logging removed for performance
-                // if (session.logger) {
-                //   await session.logger.logModelConfig(sessionModel, CLAUDE_CONFIG.baseUrl)
-                // }
+                // Resolve local model adapter overrides (if using OpenAI-compatible endpoint)
+                let effectiveModel = sessionModel;
+                let effectiveApiKey = queryOptions.apiKey;
+                let effectiveEnv = queryOptions.env;
+                let effectiveSettings;
+                const localOverrides = await getLocalModelEnvOverrides(sessionModel);
+                if (localOverrides) {
+                    effectiveModel = unwrapModelName(sessionModel);
+                    effectiveApiKey = localOverrides.apiKey;
+                    effectiveEnv = {
+                        ...effectiveEnv,
+                        ANTHROPIC_API_KEY: localOverrides.apiKey,
+                        ANTHROPIC_BASE_URL: localOverrides.baseUrl,
+                    };
+                    // Override settings to prevent ~/.claude/settings.json env from overriding our proxy URL.
+                    // Claude Code CLI reads settings.json → env section and applies those on top of spawn env,
+                    // which would replace our ANTHROPIC_BASE_URL with the z.ai URL.
+                    effectiveSettings = { env: { ANTHROPIC_API_KEY: localOverrides.apiKey, ANTHROPIC_BASE_URL: localOverrides.baseUrl } };
+                    console.log(`[agentSession] Using local model adapter: ${sessionModel} -> ${localOverrides.baseUrl}`);
+                    console.log(`[agentSession] effectiveSettings for local model:`, JSON.stringify(effectiveSettings));
+                }
+                else {
+                    // Even for non-local models, ensure ~/.claude/settings.json env doesn't override our baseUrl
+                    const aiConfig = loadAiConfig();
+                    if (aiConfig.baseUrl || aiConfig.apiKey) {
+                        const settingsEnv = {};
+                        if (aiConfig.apiKey)
+                            settingsEnv.ANTHROPIC_API_KEY = aiConfig.apiKey;
+                        if (aiConfig.baseUrl)
+                            settingsEnv.ANTHROPIC_BASE_URL = aiConfig.baseUrl;
+                        effectiveSettings = { env: settingsEnv };
+                    }
+                }
                 // Create query stream - resume session if we have a Claude session ID
                 // Always explicitly set model even when resuming to ensure we use the session's model
                 const queryStream = query({
                     prompt,
                     options: {
                         ...queryOptions,
-                        model: sessionModel, // Use session-specific model (supports switching between prompts)
-                        ...(session.claudeSessionId ? { resume: session.claudeSessionId } : {})
+                        apiKey: effectiveApiKey,
+                        model: effectiveModel,
+                        env: effectiveEnv,
+                        ...(effectiveSettings ? { settings: effectiveSettings } : {}),
+                        ...(session.claudeSessionId && !localOverrides ? { resume: session.claudeSessionId } : {})
+                        // Note: don't resume session for local models - context format differs
                     }
                 });
                 session.activeQueryStream = queryStream;
@@ -554,10 +640,7 @@ export class AgentSessionManager {
                             const systemMsg = message;
                             if (systemMsg.session_id && !session.claudeSessionId) {
                                 session.claudeSessionId = systemMsg.session_id;
-                                // DISABLED: File logging removed for performance
-                                // if (session.logger) {
-                                //   await session.logger.logClaudeSessionId(systemMsg.session_id)
-                                // }
+                                saveSessionState(sessionId, { claudeSessionId: systemMsg.session_id, model: session.model, updatedAt: Date.now() });
                             }
                         }
                         if (message.type === 'assistant') {
@@ -565,27 +648,13 @@ export class AgentSessionManager {
                             // Capture Claude session ID from assistant message if not already set
                             if (msg.session_id && !session.claudeSessionId) {
                                 session.claudeSessionId = msg.session_id;
-                                // DISABLED: File logging removed for performance
-                                // if (session.logger) {
-                                //   await session.logger.logClaudeSessionId(msg.session_id)
-                                // }
+                                saveSessionState(sessionId, { claudeSessionId: msg.session_id, model: session.model, updatedAt: Date.now() });
                             }
                             session.messages.push({
                                 role: 'assistant',
                                 content: msg.message,
                                 timestamp: Date.now()
                             });
-                            // DISABLED: File logging removed for performance
-                            // // Log agent response
-                            // const responseText = typeof msg.message === 'string' ? msg.message : JSON.stringify(msg.message)
-                            // if (session.logger) {
-                            //   await session.logger.logAgentResponse(responseText, {
-                            //     uuid: msg.uuid,
-                            //     sessionId: msg.session_id,
-                            //     error: msg.error,
-                            //     contextSize: session.messages.length
-                            //   })
-                            // }
                             onOutput({
                                 type: 'assistant',
                                 data: msg.message,
@@ -614,31 +683,7 @@ export class AgentSessionManager {
                                     outputTokens,
                                     totalTokens: inputTokens + outputTokens
                                 };
-                                // DISABLED: File logging removed for performance
-                                // // Log token usage
-                                // if (session.logger) {
-                                //   await session.logger.logTokenUsage({
-                                //     inputTokens: session.totalInputTokens,
-                                //     outputTokens: session.totalOutputTokens,
-                                //     totalTokens: session.totalInputTokens + session.totalOutputTokens,
-                                //     costUsd: session.totalCostUsd
-                                //   })
-                                // }
                             }
-                            const promptDuration = Date.now() - promptStartTime;
-                            // DISABLED: File logging removed for performance
-                            // // Log prompt completion
-                            // if (session.logger) {
-                            //   await session.logger.logPromptEnd(
-                            //     msg.is_error ? 1 : 0,
-                            //     promptDuration,
-                            //     session.lastUsage ? {
-                            //       inputTokens: session.lastUsage.inputTokens,
-                            //       outputTokens: session.lastUsage.outputTokens,
-                            //       costUsd: msg.total_cost_usd || 0
-                            //     } : undefined
-                            //   )
-                            // }
                             onOutput({
                                 type: 'result',
                                 data: msg,
@@ -672,7 +717,6 @@ export class AgentSessionManager {
                             onStatusUpdate?.(exitCode === 0 ? 'completed' : 'error');
                             onComplete(exitCode);
                             session.activeQueryStream = undefined;
-                            // Memory system removed for performance
                             break; // Prompt complete, continue to next in queue
                         }
                         else if (message.type === 'user') {
@@ -872,14 +916,6 @@ export class AgentSessionManager {
                 const currentSession = this.sessions.get(sessionId);
                 if (currentSession) {
                     currentSession.activeQueryStream = undefined;
-                    // DISABLED: File logging removed for performance
-                    // // Log error
-                    // if (currentSession.logger) {
-                    //   await currentSession.logger.logSessionError(error, {
-                    //     prompt: prompt.substring(0, 200),
-                    //     projectPath
-                    //   })
-                    // }
                 }
                 // Clean up abort controller (promptId is guaranteed to exist here due to check at line 204)
                 if (promptId) {
@@ -920,6 +956,8 @@ export class AgentSessionManager {
             // Clear Claude session ID to start fresh
             session.claudeSessionId = undefined;
             session.lastUsage = undefined;
+            // Also clear persisted state
+            deleteSessionState(sessionId);
         }
     }
     async deleteSession(sessionId) {
@@ -929,6 +967,8 @@ export class AgentSessionManager {
             session.activeQueryStream = undefined;
             this.sessions.delete(sessionId);
         }
+        // Clean up persisted state
+        deleteSessionState(sessionId);
     }
     /**
      * Cancel a running or queued prompt by promptId
@@ -1106,6 +1146,43 @@ export class AgentSessionManager {
             return { success: false, message: error.message || 'Emergency stop failed' };
         }
     }
+    /**
+     * Build a fresh MCP server for a query call.
+     * The SDK's query() connects the MCP server's internal transport, so we cannot
+     * reuse a single instance across multiple queries. This must be called fresh each time.
+     */
+    buildMcpServer(sessionId) {
+        const session = this.sessions.get(sessionId);
+        if (!session) {
+            console.log(`[buildMcpServer] No session found for ${sessionId}`);
+            return undefined;
+        }
+        const enabledModules = session.enabledModules || [];
+        console.log(`[buildMcpServer] Session ${sessionId}: enabledModules=${JSON.stringify(enabledModules)}`);
+        if (enabledModules.length === 0) {
+            console.log(`[buildMcpServer] No enabled modules, skipping MCP server creation`);
+            return undefined;
+        }
+        const handler = this.sessionHandlers.get(sessionId);
+        return createModuleMcpServer({
+            enabledModules,
+            moduleSettings: session.moduleSettings || {},
+            onChoiceRequest: handler?.onChoiceRequest
+                ? async (request) => {
+                    return new Promise((resolve) => {
+                        const sess = this.sessions.get(sessionId);
+                        if (sess) {
+                            sess.pendingChoice = { request, resolve };
+                            handler.onChoiceRequest(request);
+                        }
+                        else {
+                            resolve({ choiceId: request.choiceId, selectedValue: null });
+                        }
+                    });
+                }
+                : undefined
+        });
+    }
     /**
      * Handle user choice response from frontend
      */

package/dist/index.js

@@ -66,6 +66,33 @@ async function fetchAiConfig(authToken) {
     }
 }
 const AI_CONFIG_FILE = path.join(CONFIG_DIR, 'ai-config.json');
+const PROXY_CONFIG_FILE = path.join(CONFIG_DIR, 'proxy.json');
+/** Read proxy toggle state from disk */
+async function readProxyConfig() {
+    try {
+        const raw = await fs.readFile(PROXY_CONFIG_FILE, 'utf-8');
+        return JSON.parse(raw);
+    }
+    catch {
+        return { enabled: false };
+    }
+}
+/** Write proxy toggle state to disk */
+async function writeProxyConfig(cfg) {
+    await fs.mkdir(CONFIG_DIR, { recursive: true });
+    await fs.writeFile(PROXY_CONFIG_FILE, JSON.stringify(cfg, null, 2));
+}
+/** Get the proxy URL from ai-config.json (saved from backend) */
+function getProxyUrl() {
+    try {
+        const raw = fsSync.readFileSync(AI_CONFIG_FILE, 'utf-8');
+        const j = JSON.parse(raw);
+        return typeof j.proxy === 'string' ? j.proxy.trim() : '';
+    }
+    catch {
+        return '';
+    }
+}
 /** True if ai-config.json has a model API key (not read from host ANTHROPIC_* env). */
 function hasAiCredentials() {
     try {
@@ -1796,6 +1823,39 @@ async function runDaemon(foreground = false, email) {
                 });
             });
             // Cloudflared handlers
+            // Proxy toggle handler
+            socket.on('proxy:toggle:request', async (data, callback) => {
+                try {
+                    const { enable } = data;
+                    const proxyUrl = getProxyUrl();
+                    if (enable && !proxyUrl) {
+                        callback?.({ success: false, enabled: false });
+                        return;
+                    }
+                    await writeProxyConfig({ enabled: enable });
+                    if (foreground) {
+                        console.log(`[CLI] Proxy ${enable ? 'enabled' : 'disabled'}${proxyUrl ? `: ${proxyUrl}` : ''}`);
+                    }
+                    else {
+                        console.log(`Proxy ${enable ? 'enabled' : 'disabled'}`);
+                    }
+                    callback?.({ success: true, enabled: enable, proxyUrl: enable ? proxyUrl : undefined });
+                }
+                catch (error) {
+                    callback?.({ success: false, enabled: false });
+                }
+            });
+            // Proxy status handler
+            socket.on('proxy:status:request', async (_data, callback) => {
+                try {
+                    const proxyConfig = await readProxyConfig();
+                    const proxyUrl = getProxyUrl();
+                    callback?.({ enabled: proxyConfig.enabled, proxyUrl: proxyConfig.enabled ? proxyUrl : undefined });
+                }
+                catch {
+                    callback?.({ enabled: false });
+                }
+            });
             socket.on('cloudflared:check:request', async () => {
                 try {
                     let installed = false;
@@ -2779,4 +2839,37 @@ program
         process.exit(1);
     });
 });
+// Enable proxy command
+program
+    .command('enable')
+    .description('Enable a feature (e.g. proxy)')
+    .argument('<feature>', 'Feature to enable (proxy)')
+    .action(async (feature) => {
+    if (feature !== 'proxy') {
+        console.error(`Unknown feature: ${feature}. Available: proxy`);
+        process.exit(1);
+    }
+    const proxyUrl = getProxyUrl();
+    if (!proxyUrl) {
+        console.log('No proxy URL configured. Run "exk daemon" first to sync config from server.');
+        process.exit(1);
+    }
+    await writeProxyConfig({ enabled: true });
+    console.log(`Proxy enabled: ${proxyUrl}`);
+    process.exit(0);
+});
+// Disable proxy command
+program
+    .command('disable')
+    .description('Disable a feature (e.g. proxy)')
+    .argument('<feature>', 'Feature to disable (proxy)')
+    .action(async (feature) => {
+    if (feature !== 'proxy') {
+        console.error(`Unknown feature: ${feature}. Available: proxy`);
+        process.exit(1);
+    }
+    await writeProxyConfig({ enabled: false });
+    console.log('Proxy disabled');
+    process.exit(0);
+});
 program.parse();

package/dist/openaiAdapter.js

@@ -0,0 +1,192 @@
+/**
+ * OpenAI Adapter - Spawns an anthropic-proxy that translates Anthropic Messages API
+ * to OpenAI Chat Completions API. This allows Claude Agent SDK to talk to any
+ * OpenAI-compatible endpoint (Ollama, vLLM, local LLMs, etc.)
+ *
+ * Usage:
+ *   import { startOpenAIAdapter, isLocalModel } from './openaiAdapter.js'
+ *
+ *   if (isLocalModel(sessionModel)) {
+ *     const proxyUrl = await startOpenAIAdapter({
+ *       targetBaseUrl: 'http://192.168.1.101:3000',
+ *       model: 'qwen3.5-27b',
+ *     })
+ *     // point ANTHROPIC_BASE_URL to proxyUrl
+ *   }
+ */
+import { spawn } from 'child_process';
+import { createRequire } from 'module';
+const VALID_LOCAL_PREFIXES = ['ollama:', 'openai:', 'local:'];
+/** Check if a model ID refers to a local/OpenAI model that needs the adapter */
+export function isLocalModel(model) {
+    return VALID_LOCAL_PREFIXES.some(p => model.startsWith(p));
+}
+/** Extract the actual model name by stripping the prefix (e.g. "ollama:qwen3:4b" -> "qwen3:4b") */
+export function unwrapModelName(model) {
+    for (const prefix of VALID_LOCAL_PREFIXES) {
+        if (model.startsWith(prefix)) {
+            return model.slice(prefix.length);
+        }
+    }
+    return model;
+}
+// Track running proxies by target+model to reuse them
+const runningProxies = new Map();
+function getProxyKey(config) {
+    return `${config.targetBaseUrl}::${config.model}`;
+}
+/** Find a free port in the given range */
+async function findFreePort(start, end) {
+    const net = await import('net');
+    return new Promise((resolve, reject) => {
+        function tryPort(port) {
+            if (port > end) {
+                reject(new Error(`No free port found in range ${start}-${end}`));
+                return;
+            }
+            const server = net.createServer();
+            server.listen(port, '127.0.0.1', () => {
+                const addr = server.address();
+                server.close(() => resolve(typeof addr === 'object' && addr ? addr.port : port));
+            });
+            server.on('error', () => tryPort(port + 1));
+        }
+        tryPort(start);
+    });
+}
+/**
+ * Start an anthropic-proxy instance for the given config.
+ * Returns the local proxy URL (e.g. http://127.0.0.1:8321) that speaks Anthropic Messages API.
+ *
+ * Proxies are reused - calling this twice with the same target+model returns the same URL.
+ */
+export async function startOpenAIAdapter(config) {
+    const key = getProxyKey(config);
+    // Reuse existing proxy if running
+    const existing = runningProxies.get(key);
+    if (existing && !existing.process.killed) {
+        return existing.url;
+    }
+    const port = config.port || await findFreePort(8321, 8340);
+    // Resolve anthropic-proxy entry point
+    const req = typeof globalThis.require === 'function'
+        ? globalThis.require
+        : createRequire(import.meta.url);
+    let proxyPath;
+    try {
+        const pkgPath = req.resolve('anthropic-proxy/package.json');
+        proxyPath = pkgPath.replace(/package\.json$/, 'index.js');
+    }
+    catch {
+        throw new Error('anthropic-proxy package not found. Run: npm install anthropic-proxy');
+    }
+    const env = {
+        ...process.env,
+        ANTHROPIC_PROXY_BASE_URL: config.targetBaseUrl,
+        PORT: String(port),
+        REASONING_MODEL: config.model,
+        COMPLETION_MODEL: config.model,
+        // Suppress fastify logger noise
+        FASTIFY_LOG_LEVEL: 'error',
+    };
+    if (config.apiKey) {
+        env.OPENAI_API_KEY = config.apiKey;
+    }
+    const child = spawn('node', [proxyPath], {
+        env,
+        stdio: ['ignore', 'pipe', 'pipe'],
+        windowsHide: true,
+    });
+    // Suppress stdout/stderr but log errors
+    let stderrBuf = '';
+    child.stderr?.on('data', (data) => {
+        stderrBuf += data.toString();
+        // Only log actual errors, not fastify startup messages
+        if (stderrBuf.toLowerCase().includes('error') && !stderrBuf.includes('fastify')) {
+            console.error(`[openaiAdapter] Proxy stderr: ${stderrBuf}`);
+        }
+        stderrBuf = '';
+    });
+    child.on('exit', (code) => {
+        runningProxies.delete(key);
+        if (code && code !== 0) {
+            console.error(`[openaiAdapter] Proxy exited with code ${code}`);
+        }
+    });
+    const url = `http://127.0.0.1:${port}`;
+    // Wait for proxy to be ready (poll /v1/messages with a simple request)
+    const maxAttempts = 20;
+    for (let i = 0; i < maxAttempts; i++) {
+        await new Promise(r => setTimeout(r, 100));
+        try {
+            const resp = await fetch(`${url}/v1/messages`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({
+                    model: config.model,
+                    max_tokens: 1,
+                    messages: [{ role: 'user', content: 'ping' }],
+                }),
+            });
+            if (resp.ok || resp.status === 400 || resp.status === 422) {
+                // 400/422 means the proxy is up but the request was invalid - that's fine for a health check
+                runningProxies.set(key, { process: child, port, url });
+                console.log(`[openaiAdapter] Proxy ready at ${url} -> ${config.targetBaseUrl} (model: ${config.model})`);
+                return url;
+            }
+        }
+        catch {
+            // Not ready yet, retry
+        }
+    }
+    // If health check failed but process is still running, assume it's ready
+    if (!child.killed) {
+        runningProxies.set(key, { process: child, port, url });
+        console.log(`[openaiAdapter] Proxy started at ${url} (health check timed out, assuming ready)`);
+        return url;
+    }
+    throw new Error(`Failed to start anthropic-proxy for ${config.targetBaseUrl}`);
+}
+/** Stop all running proxy instances */
+export function stopAllAdapters() {
+    for (const [key, { process }] of runningProxies) {
+        try {
+            if (!process.killed)
+                process.kill('SIGTERM');
+        }
+        catch { }
+        runningProxies.delete(key);
+    }
+}
+/**
+ * Get the adapter configuration for a local model.
+ * Reads from ~/.talk-to-code/openai-adapters.json or falls back to defaults.
+ */
+export function getAdapterConfig(model) {
+    // Strip prefix to get the raw model name
+    const rawModel = unwrapModelName(model);
+    // Determine provider from prefix
+    if (model.startsWith('ollama:')) {
+        return { targetBaseUrl: 'http://127.0.0.1:11434' };
+    }
+    // For 'openai:' and 'local:' prefix, read from config file
+    try {
+        const req = typeof globalThis.require === 'function'
+            ? globalThis.require
+            : createRequire(import.meta.url);
+        const fs = req('fs');
+        const path = req('path');
+        const os = req('os');
+        const configPath = path.join(os.homedir(), '.talk-to-code', 'openai-adapters.json');
+        const config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+        // Config format: { "default": { "baseUrl": "...", "apiKey": "..." }, ... }
+        const entry = config.default || config[rawModel];
+        if (entry?.baseUrl) {
+            return { targetBaseUrl: entry.baseUrl, apiKey: entry.apiKey };
+        }
+    }
+    catch (e) {
+        console.error('[openaiAdapter] Failed to read adapter config:', e);
+    }
+    return null;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exreve/exk",
-  "version": "1.0.16",
+  "version": "1.0.18",
   "description": "exk - Control Claude CLI with voice and programmable interfaces",
   "type": "module",
   "bin": {
@@ -37,6 +37,7 @@
     "@anthropic-ai/sdk": "^0.80.0",
     "@fastify/static": "^9.0.0",
     "@xenova/transformers": "^2.17.2",
+    "anthropic-proxy": "^1.3.0",
     "chokidar": "^3.6.0",
     "commander": "^13.1.0",
     "express": "^4.18.2",
@@ -47,8 +48,8 @@
     "uuid": "^11.0.3"
   },
   "devDependencies": {
-    "@types/node": "^22.10.2",
     "@types/chokidar": "^2.1.3",
+    "@types/node": "^22.10.2",
     "@types/uuid": "^10.0.0",
     "@vercel/ncc": "^0.38.1",
     "esbuild": "^0.27.2",