@exreve/exk 1.0.26 → 1.0.28

package/dist/agentSession.js

@@ -4,7 +4,7 @@ import { existsSync, mkdirSync, readFileSync, writeFileSync, unlinkSync } from '
 import { symlink as fsSymlink } from 'fs';
 import { getSkillContent } from './skills/index.js';
 import { isLocalModel, unwrapModelName, startOpenAIAdapter, getAdapterConfig } from './openaiAdapter.js';
-import { createModuleMcpServer, getModuleToolHint } from './moduleMcpServer.js';
+import { createModuleMcpServer } from './moduleMcpServer.js';
 import path from 'path';
 import os from 'os';
 import { createRequire } from 'module';
@@ -127,6 +127,48 @@ function lookupToolNameFromHistory(messages, toolUseId) {
 // (Do not read ANTHROPIC_* / CLAUDE_MODEL from the host environment — only this file + code default model.)
 const AI_CONFIG_PATH = path.join(os.homedir(), '.talk-to-code', 'ai-config.json');
 const DEFAULT_AI_MODEL = 'glm-5.1';
+const PROVIDERS = {
+    zai: {
+        apiKey: process.env.ZHIPU_API_KEY || '',
+        baseUrl: process.env.CLI_AI_BASE_URL || 'https://api.z.ai/api/anthropic',
+        models: ['glm-5.1', 'glm-4.7', 'glm-4.5-air'],
+    },
+    minimax: {
+        apiKey: '', // Populated from ai-config.json (served by backend)
+        baseUrl: 'https://api.minimax.io/anthropic',
+        models: ['MiniMax-M2.7', 'MiniMax-M2.7-highspeed'],
+    },
+};
+/** Resolve which provider to use based on model name or explicit provider ID.
+ *  1. Populate provider API keys from ai-config.json (served by backend).
+ *  2. If explicit providerId is given and has an API key configured, use that provider.
+ *  3. Else if model name matches one of a provider's model list, use that provider.
+ *  4. Else fall back to zai (default). */
+function resolveProvider(model, providerId) {
+    // Populate provider keys from ai-config.json
+    const aiConfig = loadAiConfig();
+    PROVIDERS.minimax.apiKey = aiConfig.minimaxApiKey || process.env.MINIMAX_API_KEY || '';
+    if (!PROVIDERS.zai.apiKey)
+        PROVIDERS.zai.apiKey = aiConfig.apiKey || '';
+    // 1. Explicit provider selection
+    if (providerId && PROVIDERS[providerId]?.apiKey) {
+        const provider = PROVIDERS[providerId];
+        return { provider: providerId, apiKey: provider.apiKey, baseUrl: provider.baseUrl, model };
+    }
+    // 2. Match model name to a provider
+    for (const [id, config] of Object.entries(PROVIDERS)) {
+        if (config.models.includes(model) && config.apiKey) {
+            return { provider: id, apiKey: config.apiKey, baseUrl: config.baseUrl, model };
+        }
+    }
+    // 3. Fallback: use ai-config.json credentials (z.ai default)
+    return {
+        provider: 'zai',
+        apiKey: aiConfig.apiKey,
+        baseUrl: aiConfig.baseUrl || PROVIDERS.zai.baseUrl,
+        model,
+    };
+}
 function loadAiConfig() {
     try {
         const data = readFileSync(AI_CONFIG_PATH, 'utf-8');
@@ -134,10 +176,12 @@ 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() : '';
+        const minimaxApiKey = typeof config.minimaxApiKey === 'string' ? config.minimaxApiKey.trim() : '';
+        return { apiKey, baseUrl, model, proxy, minimaxApiKey };
     }
     catch {
-        return { apiKey: '', baseUrl: '', model: DEFAULT_AI_MODEL };
+        return { apiKey: '', baseUrl: '', model: DEFAULT_AI_MODEL, proxy: '', minimaxApiKey: '' };
     }
 }
 /** Create (or reuse) an empty directory to use as CLAUDE_CONFIG_DIR.
@@ -151,32 +195,66 @@ function getEmptyConfigDir() {
     }
     return configDir;
 }
-/** 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 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 { enabled: false };
+    }
+}
+/** Env for the Claude Code child: copy of host env with host ANTHROPIC_* stripped, then inject from provider or ai-config.
+ *  If a local model is provided, override baseUrl to point to the anthropic-proxy adapter.
+ *  If resolvedProvider is provided, use its credentials instead of ai-config defaults. */
+function envForClaudeCodeChild(localModel, resolvedProvider) {
     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;
-    // Inject from our ai-config.json only
-    const { apiKey, baseUrl } = loadAiConfig();
-    if (apiKey)
-        env.ANTHROPIC_API_KEY = apiKey;
-    if (baseUrl)
-        env.ANTHROPIC_BASE_URL = baseUrl;
-    // Clear any inherited proxy env
-    delete env.HTTPS_PROXY;
-    delete env.HTTP_PROXY;
-    delete env.https_proxy;
-    delete env.http_proxy;
+    // Also strip model alias env vars to prevent stale overrides
+    delete env.ANTHROPIC_MODEL;
+    delete env.ANTHROPIC_DEFAULT_SONNET_MODEL;
+    delete env.ANTHROPIC_DEFAULT_OPUS_MODEL;
+    delete env.ANTHROPIC_DEFAULT_HAIKU_MODEL;
+    // Determine credentials: use resolvedProvider if provided, else ai-config defaults
+    const { apiKey, baseUrl, proxy } = loadAiConfig();
+    const effectiveApiKey = resolvedProvider?.apiKey || apiKey;
+    const effectiveBaseUrl = resolvedProvider?.baseUrl || baseUrl;
+    if (effectiveApiKey)
+        env.ANTHROPIC_API_KEY = effectiveApiKey;
+    if (effectiveBaseUrl)
+        env.ANTHROPIC_BASE_URL = effectiveBaseUrl;
+    // For MiniMax specifically: override ALL model aliases so the SDK
+    // sends the correct model ID to the Anthropic-compatible endpoint
+    if (resolvedProvider?.provider === 'minimax') {
+        env.ANTHROPIC_MODEL = resolvedProvider.model;
+        env.ANTHROPIC_DEFAULT_SONNET_MODEL = resolvedProvider.model;
+        env.ANTHROPIC_DEFAULT_OPUS_MODEL = resolvedProvider.model;
+        env.ANTHROPIC_DEFAULT_HAIKU_MODEL = resolvedProvider.model;
+        env.CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC = '1';
+    }
+    // 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();
-    // Allow Claude to run as root (e.g. inside Docker containers)
-    env.IS_SANDBOX = '1';
     return env;
 }
 /** Get env overrides for a local model (adapter proxy URL + dummy key). Returns null if not a local model. */
@@ -316,7 +394,8 @@ export class AgentSessionManager {
             timestamp: Date.now(),
             promptId: handler.promptId,
             abortController: new AbortController(), // Pre-create for queued cancellation
-            model: handler.model || session.model // Use handler model or fall back to session model
+            model: handler.model || session.model, // Use handler model or fall back to session model
+            attachments: handler.attachments // Pass attachments through
         });
         // Start processing queue if not already processing
         if (!session.isProcessingQueue) {
@@ -339,13 +418,30 @@ export class AgentSessionManager {
         session.isProcessingQueue = true;
         while (session.promptQueue.length > 0 && !this.emergencyStopInProgress.has(sessionId)) {
             const queuedPrompt = session.promptQueue.shift();
-            const { prompt, enhancers, handler, promptId: queuedPromptId, abortController: queuedAbortController } = queuedPrompt;
+            const { enhancers, handler, promptId: queuedPromptId, abortController: queuedAbortController } = queuedPrompt;
             const { projectPath, promptId, onOutput, onError, onComplete, onStatusUpdate } = handler;
             const promptStartTime = Date.now();
+            // Write attachments to temp dir and inject paths into prompt
+            let effectivePrompt = queuedPrompt.prompt;
+            let attachmentDir;
+            if (queuedPrompt.attachments && queuedPrompt.attachments.length > 0) {
+                attachmentDir = path.join(os.tmpdir(), 'talk-to-code', 'attachments', sessionId, String(promptId || Date.now()));
+                mkdirSync(attachmentDir, { recursive: true });
+                const attachmentLines = [];
+                for (const att of queuedPrompt.attachments) {
+                    const safeName = att.filename.replace(/[^a-zA-Z0-9._-]/g, '_');
+                    const filePath = path.join(attachmentDir, safeName);
+                    const buf = Buffer.from(att.content, 'base64');
+                    writeFileSync(filePath, buf);
+                    attachmentLines.push(`- ${safeName} (${att.mimeType}): path="${filePath}"`);
+                }
+                effectivePrompt += `\n\n[Attachments]\nThe following files are attached and available on disk. Use the analyze_image tool to examine images.\n${attachmentLines.join('\n')}`;
+                console.log(`[agentSession] Wrote ${queuedPrompt.attachments.length} attachment(s) to ${attachmentDir}`);
+            }
             try {
                 // Verify promptId is present in handler
                 if (!promptId) {
-                    console.error(`[agentSession] Missing promptId in handler for prompt: ${prompt.substring(0, 50)}...`);
+                    console.error(`[agentSession] Missing promptId in handler for prompt: ${queuedPrompt.prompt.substring(0, 50)}...`);
                     onError?.('Missing promptId in handler');
                     continue;
                 }
@@ -375,11 +471,11 @@ export class AgentSessionManager {
                 }
                 session.activeQueryStream = undefined;
                 // Build final prompt with enhancers
-                let finalPrompt = prompt;
+                let finalPrompt = effectivePrompt;
                 if (enhancers && enhancers.length > 0) {
                     const skillContent = getSkillContent(enhancers);
                     if (skillContent) {
-                        finalPrompt = `${skillContent}\n\n${prompt}`;
+                        finalPrompt = `${skillContent}\n\n${effectivePrompt}`;
                     }
                 }
                 // Add user message to history
@@ -418,25 +514,16 @@ export class AgentSessionManager {
                     apiKey: CLAUDE_CONFIG.apiKey,
                     model: CLAUDE_CONFIG.model,
                     tools: { type: 'preset', preset: 'claude_code' },
-                    disallowedTools: ['AskUserQuestion'],
+                    disallowedTools: attachmentDir
+                        ? ['AskUserQuestion', 'analyze_image'] // Disable built-in analyze_image when we have our own
+                        : ['AskUserQuestion'],
                     settingSources: ['project'], // Enable CLAUDE.md loading
                     permissionMode: 'bypassPermissions',
                     allowDangerouslySkipPermissions: true,
                     // Create a fresh MCP server for each query call (SDK connects transport internally, cannot reuse)
                     ...(() => {
-                        const mcpServer = this.buildMcpServer(sessionId);
-                        if (mcpServer) {
-                            const toolHint = getModuleToolHint(session.enabledModules || []);
-                            console.log(`[agentSession] MCP server created: name=${mcpServer.name}, hasHint=${!!toolHint}`);
-                            console.log(`[agentSession] MCP server keys:`, Object.keys(mcpServer));
-                            console.log(`[agentSession] MCP server type:`, mcpServer.type);
-                            return {
-                                mcpServers: { [mcpServer.name]: mcpServer },
-                                ...(toolHint ? { systemPrompt: { type: 'preset', preset: 'claude_code', append: toolHint } } : {})
-                            };
-                        }
-                        console.log(`[agentSession] No MCP server created (enabledModules=${JSON.stringify(session.enabledModules)})`);
-                        return {};
+                        const mcpServer = this.buildMcpServer(sessionId, attachmentDir);
+                        return mcpServer ? { mcpServers: [mcpServer] } : {};
                     })(),
                     ...(pathToClaudeCodeExecutable ? { pathToClaudeCodeExecutable } : {}),
                     spawnClaudeCodeProcess: (spawnOptions) => {
@@ -582,29 +669,45 @@ export class AgentSessionManager {
                     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 };
+                    // Resolve provider for multi-provider switching (Z.ai / MiniMax)
+                    const resolved = resolveProvider(sessionModel);
+                    console.log(`[agentSession] Resolved provider: ${resolved.provider} for model: ${sessionModel}`);
+                    effectiveApiKey = resolved.apiKey;
+                    effectiveEnv = envForClaudeCodeChild(undefined, resolved);
+                    // Build settings env to prevent ~/.claude/settings.json from overriding our credentials
+                    const settingsEnv = {
+                        ANTHROPIC_API_KEY: resolved.apiKey,
+                        ANTHROPIC_BASE_URL: resolved.baseUrl,
+                    };
+                    // For MiniMax: also override all model aliases in settings
+                    if (resolved.provider === 'minimax') {
+                        settingsEnv.ANTHROPIC_MODEL = resolved.model;
+                        settingsEnv.ANTHROPIC_DEFAULT_SONNET_MODEL = resolved.model;
+                        settingsEnv.ANTHROPIC_DEFAULT_OPUS_MODEL = resolved.model;
+                        settingsEnv.ANTHROPIC_DEFAULT_HAIKU_MODEL = resolved.model;
+                        settingsEnv.CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC = '1';
                     }
+                    effectiveSettings = { env: settingsEnv };
+                    console.log(`[agentSession] Provider: ${resolved.provider}, baseUrl: ${resolved.baseUrl}, model: ${resolved.model}`);
                 }
                 // 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,
+                    prompt: finalPrompt,
                     options: {
                         ...queryOptions,
                         apiKey: effectiveApiKey,
                         model: effectiveModel,
                         env: effectiveEnv,
                         ...(effectiveSettings ? { settings: effectiveSettings } : {}),
-                        ...(session.claudeSessionId && !localOverrides ? { resume: session.claudeSessionId } : {})
+                        ...(session.claudeSessionId && !localOverrides && (() => {
+                            // Don't resume if provider changed since last session (context format may differ)
+                            const persisted = loadSessionState(sessionId);
+                            const currentProvider = resolveProvider(sessionModel).provider;
+                            return persisted?.provider === currentProvider;
+                        })() ? { resume: session.claudeSessionId } : {})
                         // Note: don't resume session for local models - context format differs
+                        // Note: also don't resume if provider differs from persisted session provider (context format may differ)
                     }
                 });
                 session.activeQueryStream = queryStream;
@@ -633,7 +736,7 @@ export class AgentSessionManager {
                             const systemMsg = message;
                             if (systemMsg.session_id && !session.claudeSessionId) {
                                 session.claudeSessionId = systemMsg.session_id;
-                                saveSessionState(sessionId, { claudeSessionId: systemMsg.session_id, model: session.model, updatedAt: Date.now() });
+                                saveSessionState(sessionId, { claudeSessionId: systemMsg.session_id, model: session.model, provider: resolveProvider(session.model).provider, updatedAt: Date.now() });
                             }
                         }
                         if (message.type === 'assistant') {
@@ -641,7 +744,7 @@ 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;
-                                saveSessionState(sessionId, { claudeSessionId: msg.session_id, model: session.model, updatedAt: Date.now() });
+                                saveSessionState(sessionId, { claudeSessionId: msg.session_id, model: session.model, provider: resolveProvider(session.model).provider, updatedAt: Date.now() });
                             }
                             session.messages.push({
                                 role: 'assistant',
@@ -1144,22 +1247,23 @@ export class AgentSessionManager {
      * 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) {
+    buildMcpServer(sessionId, attachmentDir) {
         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`);
+        console.log(`[buildMcpServer] Session ${sessionId}: enabledModules=${JSON.stringify(enabledModules)}, attachmentDir=${attachmentDir || 'none'}`);
+        if (enabledModules.length === 0 && !attachmentDir) {
+            console.log(`[buildMcpServer] No enabled modules and no attachments, skipping MCP server creation`);
             return undefined;
         }
         const handler = this.sessionHandlers.get(sessionId);
         return createModuleMcpServer({
             enabledModules,
             moduleSettings: session.moduleSettings || {},
+            attachmentDir,
             onChoiceRequest: handler?.onChoiceRequest
                 ? async (request) => {
                     return new Promise((resolve) => {