codeep 1.2.14 → 1.2.16

package/dist/api/index.js

@@ -1,5 +1,5 @@
 import { config, getApiKey } from '../config/index.js';
-import { withRetry, isNetworkError, isTimeoutError } from '../utils/retry.js';
+import { withRetry, isNetworkError } from '../utils/retry.js';
 import { getProvider, getProviderBaseUrl, getProviderAuthHeader } from '../config/providers.js';
 import { logApiRequest, logApiResponse } from '../utils/logger.js';
 import { loadProjectIntelligence, generateContextFromIntelligence } from '../utils/projectIntelligence.js';
@@ -92,6 +92,30 @@ export function setProjectContext(ctx) {
         cachedIntelligence = null;
     }
 }
+/**
+ * Parse API error response body into a human-readable message.
+ * Handles JSON error responses from OpenAI, Anthropic, and other providers.
+ */
+function parseApiError(status, body) {
+    try {
+        const json = JSON.parse(body);
+        // OpenAI format: { error: { message: "..." } }
+        if (json.error?.message)
+            return `${status} - ${json.error.message}`;
+        // Anthropic format: { error: { type: "...", message: "..." } }
+        if (json.message)
+            return `${status} - ${json.message}`;
+        // Other: { detail: "..." }
+        if (json.detail)
+            return `${status} - ${json.detail}`;
+    }
+    catch {
+        // Not JSON — use raw body but truncate
+    }
+    // Truncate long raw error bodies
+    const truncated = body.length > 200 ? body.slice(0, 200) + '...' : body;
+    return `${status} - ${truncated}`;
+}
 export async function chat(message, history = [], onChunk, onRetry, projectContext, abortSignal) {
     // Update project context if provided
     if (projectContext !== undefined) {
@@ -119,13 +143,15 @@ export async function chat(message, history = [], onChunk, onRetry, projectConte
                 }
             },
             shouldRetry: (error) => {
-                // Don't retry on user abort
+                // Don't retry on user abort or timeout
                 if (error.name === 'AbortError')
                     return false;
+                if (error.isTimeout)
+                    return false;
                 // Don't retry on 4xx client errors (except 429 rate limit)
                 if (error.status >= 400 && error.status < 500 && error.status !== 429)
                     return false;
-                // Retry on network errors, timeouts, 5xx, and rate limits
+                // Retry on network errors, 5xx, and rate limits
                 return true;
             },
         });
@@ -135,9 +161,14 @@ export async function chat(message, history = [], onChunk, onRetry, projectConte
     }
     catch (error) {
         const err = error;
-        // Don't log or throw if request was aborted by user
+        // Timeout errors (from chatOpenAI/chatAnthropic) — show user-friendly message
+        if (err.isTimeout) {
+            logApiResponse(providerId, false, undefined, 'timeout');
+            throw error;
+        }
+        // User cancel (Escape key) — re-throw silently without logging
         if (err.name === 'AbortError' || err.message?.includes('aborted')) {
-            throw error; // Re-throw abort errors silently
+            throw error;
         }
         // Log error
         logApiResponse(providerId, false, undefined, err.message);
@@ -145,9 +176,6 @@ export async function chat(message, history = [], onChunk, onRetry, projectConte
         if (isNetworkError(error)) {
             throw new Error(getErrorMessage('noInternet'));
         }
-        if (isTimeoutError(error)) {
-            throw new Error(getErrorMessage('timeout'));
-        }
         throw error;
     }
 }
@@ -247,10 +275,11 @@ async function chatOpenAI(message, history, model, apiKey, onChunk, abortSignal)
     if (!baseUrl) {
         throw new Error(`Provider ${providerId} does not support OpenAI protocol`);
     }
-    // Create abort controller for timeout or use provided one
-    const controller = abortSignal ? new AbortController() : new AbortController();
-    const timeoutId = setTimeout(() => controller.abort(), timeout);
-    // Listen to external abort signal if provided
+    // Create abort controller with timeout flag to distinguish from user cancel
+    const controller = new AbortController();
+    let timedOut = false;
+    const timeoutId = setTimeout(() => { timedOut = true; controller.abort(); }, timeout);
+    // Listen to external abort signal if provided (user cancel)
     if (abortSignal) {
         abortSignal.addEventListener('abort', () => controller.abort());
     }
@@ -279,8 +308,8 @@ async function chatOpenAI(message, history, model, apiKey, onChunk, abortSignal)
             signal: controller.signal,
         });
         if (!response.ok) {
-            const error = await response.text();
-            const err = new Error(`${getErrorMessage('apiError')}: ${response.status} - ${error}`);
+            const body = await response.text();
+            const err = new Error(`${getErrorMessage('apiError')}: ${parseApiError(response.status, body)}`);
             err.status = response.status;
             throw err;
         }
@@ -296,6 +325,14 @@ async function chatOpenAI(message, history, model, apiKey, onChunk, abortSignal)
             return stripThinkTags(content);
         }
     }
+    catch (error) {
+        if (timedOut) {
+            const err = new Error(getErrorMessage('timeout'));
+            err.isTimeout = true;
+            throw err;
+        }
+        throw error;
+    }
     finally {
         clearTimeout(timeoutId);
     }
@@ -342,27 +379,31 @@ async function handleOpenAIStream(body, onChunk) {
 }
 async function chatAnthropic(message, history, model, apiKey, onChunk, abortSignal) {
     const systemPrompt = getSystemPrompt();
-    const messages = [
-        { role: 'user', content: systemPrompt },
-        { role: 'assistant', content: 'Understood. I will follow your language instructions.' },
-        ...history,
-        { role: 'user', content: message },
-    ];
+    const providerId = config.get('provider');
+    // Use native system parameter for Anthropic, fake turns for other providers
+    const useNativeSystem = providerId === 'anthropic';
+    const messages = useNativeSystem
+        ? [...history, { role: 'user', content: message }]
+        : [
+            { role: 'user', content: systemPrompt },
+            { role: 'assistant', content: 'Understood.' },
+            ...history,
+            { role: 'user', content: message },
+        ];
     const stream = Boolean(onChunk);
     const timeout = config.get('apiTimeout');
     const temperature = config.get('temperature');
     const maxTokens = config.get('maxTokens');
-    // Get provider-specific URL and auth
-    const providerId = config.get('provider');
     const baseUrl = getProviderBaseUrl(providerId, 'anthropic');
     const authHeader = getProviderAuthHeader(providerId, 'anthropic');
     if (!baseUrl) {
         throw new Error(`Provider ${providerId} does not support Anthropic protocol`);
     }
-    // Create abort controller for timeout or use provided one
+    // Create abort controller with timeout flag to distinguish from user cancel
     const controller = new AbortController();
-    const timeoutId = setTimeout(() => controller.abort(), timeout);
-    // Listen to external abort signal if provided
+    let timedOut = false;
+    const timeoutId = setTimeout(() => { timedOut = true; controller.abort(); }, timeout);
+    // Listen to external abort signal if provided (user cancel)
     if (abortSignal) {
         abortSignal.addEventListener('abort', () => controller.abort());
     }
@@ -387,12 +428,13 @@ async function chatAnthropic(message, history, model, apiKey, onChunk, abortSign
                 max_tokens: maxTokens,
                 temperature,
                 stream,
+                ...(useNativeSystem ? { system: systemPrompt } : {}),
             }),
             signal: controller.signal,
         });
         if (!response.ok) {
-            const error = await response.text();
-            const err = new Error(`${getErrorMessage('apiError')}: ${response.status} - ${error}`);
+            const body = await response.text();
+            const err = new Error(`${getErrorMessage('apiError')}: ${parseApiError(response.status, body)}`);
             err.status = response.status;
             throw err;
         }
@@ -408,6 +450,14 @@ async function chatAnthropic(message, history, model, apiKey, onChunk, abortSign
             return stripThinkTags(content);
         }
     }
+    catch (error) {
+        if (timedOut) {
+            const err = new Error(getErrorMessage('timeout'));
+            err.isTimeout = true;
+            throw err;
+        }
+        throw error;
+    }
     finally {
         clearTimeout(timeoutId);
     }

package/dist/config/providers.js

@@ -85,6 +85,29 @@ export const PROVIDERS = {
         envKey: 'MINIMAX_API_KEY',
         subscribeUrl: 'https://platform.minimax.io/subscribe/coding-plan?code=2lWvoWUhrp&source=link',
     },
+    'minimax-cn': {
+        name: 'MiniMax China',
+        description: 'MiniMax Coding Plan (China)',
+        protocols: {
+            openai: {
+                baseUrl: 'https://api.minimaxi.com/v1',
+                authHeader: 'Bearer',
+                supportsNativeTools: true,
+            },
+            anthropic: {
+                baseUrl: 'https://api.minimaxi.com/anthropic',
+                authHeader: 'x-api-key',
+                supportsNativeTools: false,
+            },
+        },
+        models: [
+            { id: 'MiniMax-M2.5', name: 'MiniMax M2.5', description: 'Latest MiniMax coding model' },
+        ],
+        defaultModel: 'MiniMax-M2.5',
+        defaultProtocol: 'anthropic',
+        envKey: 'MINIMAX_CN_API_KEY',
+        subscribeUrl: 'https://platform.minimaxi.com',
+    },
     'deepseek': {
         name: 'DeepSeek',
         description: 'DeepSeek AI models',
@@ -115,11 +138,12 @@ export const PROVIDERS = {
             },
         },
         models: [
-            { id: 'claude-sonnet-4-5-20250929', name: 'Claude Sonnet 4.5', description: 'Best balance of speed and intelligence' },
-            { id: 'claude-haiku-4-5-20251001', name: 'Claude Haiku 4.5', description: 'Fastest and most affordable' },
+            { id: 'claude-sonnet-4-6', name: 'Claude Sonnet 4.6', description: 'Latest Sonnet — best balance of speed and intelligence' },
             { id: 'claude-opus-4-6', name: 'Claude Opus 4.6', description: 'Most capable model' },
+            { id: 'claude-sonnet-4-5-20250929', name: 'Claude Sonnet 4.5', description: 'Previous generation Sonnet' },
+            { id: 'claude-haiku-4-5-20251001', name: 'Claude Haiku 4.5', description: 'Fastest and most affordable' },
         ],
-        defaultModel: 'claude-sonnet-4-5-20250929',
+        defaultModel: 'claude-sonnet-4-6',
         defaultProtocol: 'anthropic',
         envKey: 'ANTHROPIC_API_KEY',
     },

package/dist/config/providers.test.js

@@ -72,12 +72,14 @@ describe('providers', () => {
                 expect(item.description).toBeDefined();
             }
         });
-        it('should include z.ai, z.ai-cn, and minimax', () => {
+        it('should include z.ai, z.ai-cn, minimax, minimax-cn, and anthropic', () => {
             const list = getProviderList();
             const ids = list.map(p => p.id);
             expect(ids).toContain('z.ai');
             expect(ids).toContain('z.ai-cn');
             expect(ids).toContain('minimax');
+            expect(ids).toContain('minimax-cn');
+            expect(ids).toContain('anthropic');
         });
     });
     describe('getProviderModels', () => {
@@ -136,6 +138,30 @@ describe('providers', () => {
         it('should have env key for minimax', () => {
             expect(PROVIDERS['minimax'].envKey).toBe('MINIMAX_API_KEY');
         });
+        it('should have env key for minimax-cn', () => {
+            expect(PROVIDERS['minimax-cn'].envKey).toBe('MINIMAX_CN_API_KEY');
+        });
+        it('should have env key for anthropic', () => {
+            expect(PROVIDERS['anthropic'].envKey).toBe('ANTHROPIC_API_KEY');
+        });
+    });
+    describe('minimax-cn provider', () => {
+        it('should have correct name and endpoints', () => {
+            expect(PROVIDERS['minimax-cn']).toBeDefined();
+            expect(PROVIDERS['minimax-cn'].name).toBe('MiniMax China');
+            expect(getProviderBaseUrl('minimax-cn', 'openai')).toContain('api.minimaxi.com');
+            expect(getProviderBaseUrl('minimax-cn', 'anthropic')).toContain('api.minimaxi.com');
+        });
+    });
+    describe('anthropic provider', () => {
+        it('should include Claude Sonnet 4.6 as default model', () => {
+            expect(PROVIDERS['anthropic'].defaultModel).toBe('claude-sonnet-4-6');
+            const modelIds = PROVIDERS['anthropic'].models.map(m => m.id);
+            expect(modelIds).toContain('claude-sonnet-4-6');
+            expect(modelIds).toContain('claude-opus-4-6');
+            expect(modelIds).toContain('claude-sonnet-4-5-20250929');
+            expect(modelIds).toContain('claude-haiku-4-5-20251001');
+        });
     });
     describe('MCP endpoints', () => {
         it('should have MCP endpoints for z.ai', () => {

package/dist/renderer/App.js

@@ -358,6 +358,7 @@ export class App {
         this.screen.init();
         this.input.start();
         this.input.onKey((event) => this.handleKey(event));
+        this.screen.onResize(() => this.render());
         this.render();
     }
     /**
@@ -1733,7 +1734,7 @@ export class App {
         if (this.pasteInfoOpen && this.pasteInfo) {
             this.renderInlinePasteInfo(statusLine + 1, width);
         }
-        this.screen.fullRender();
+        this.screen.render();
     }
     /**
      * Render inline confirmation dialog below status bar

package/dist/renderer/Input.d.ts

@@ -58,7 +58,19 @@ export declare class LineEditor {
      */
     setCursorPos(pos: number): void;
     /**
-     * Delete word backward (Ctrl+W)
+     * Check if character is a word boundary (space, path separator, punctuation)
+     */
+    private isWordBoundary;
+    /**
+     * Move cursor to previous word boundary (Ctrl+Left)
+     */
+    wordLeft(): void;
+    /**
+     * Move cursor to next word boundary (Ctrl+Right)
+     */
+    wordRight(): void;
+    /**
+     * Delete word backward (Ctrl+W) — respects path separators
      */
     deleteWordBackward(): void;
     /**

package/dist/renderer/Input.js

@@ -19,7 +19,8 @@ export class Input {
         // Enable mouse tracking (SGR mode for better compatibility)
         // \x1b[?1000h - enable basic mouse tracking
         // \x1b[?1006h - enable SGR extended mouse mode
-        process.stdout.write('\x1b[?1000h\x1b[?1006h');
+        // \x1b[?2004h - enable bracketed paste mode (wraps pastes in \x1b[200~ ... \x1b[201~)
+        process.stdout.write('\x1b[?1000h\x1b[?1006h\x1b[?2004h');
         this.dataHandler = (data) => {
             const event = this.parseKey(data);
             this.emit(event);
@@ -35,8 +36,8 @@ export class Input {
             process.stdin.removeListener('data', this.dataHandler);
             this.dataHandler = null;
         }
-        // Disable mouse tracking
-        process.stdout.write('\x1b[?1006l\x1b[?1000l');
+        // Disable mouse tracking and bracketed paste mode
+        process.stdout.write('\x1b[?2004l\x1b[?1006l\x1b[?1000l');
         if (process.stdin.isTTY) {
             process.stdin.setRawMode(false);
         }
@@ -239,6 +240,16 @@ export class Input {
                 case '6~':
                     event.key = 'pagedown';
                     break;
+                // Ctrl+Right (word jump forward)
+                case '1;5C':
+                    event.key = 'ctrl-right';
+                    event.ctrl = true;
+                    break;
+                // Ctrl+Left (word jump backward)
+                case '1;5D':
+                    event.key = 'ctrl-left';
+                    event.ctrl = true;
+                    break;
                 default:
                     event.key = 'unknown';
             }
@@ -300,20 +311,57 @@ export class LineEditor {
         this.cursorPos = Math.max(0, Math.min(pos, this.value.length));
     }
     /**
-     * Delete word backward (Ctrl+W)
+     * Check if character is a word boundary (space, path separator, punctuation)
+     */
+    isWordBoundary(ch) {
+        return ' \t/\\.-_:'.includes(ch);
+    }
+    /**
+     * Move cursor to previous word boundary (Ctrl+Left)
+     */
+    wordLeft() {
+        if (this.cursorPos === 0)
+            return;
+        let i = this.cursorPos - 1;
+        // Skip current boundary chars
+        while (i > 0 && this.isWordBoundary(this.value[i]))
+            i--;
+        // Move to start of word
+        while (i > 0 && !this.isWordBoundary(this.value[i - 1]))
+            i--;
+        this.cursorPos = i;
+    }
+    /**
+     * Move cursor to next word boundary (Ctrl+Right)
+     */
+    wordRight() {
+        const len = this.value.length;
+        if (this.cursorPos >= len)
+            return;
+        let i = this.cursorPos;
+        // Skip current word chars
+        while (i < len && !this.isWordBoundary(this.value[i]))
+            i++;
+        // Skip boundary chars
+        while (i < len && this.isWordBoundary(this.value[i]))
+            i++;
+        this.cursorPos = i;
+    }
+    /**
+     * Delete word backward (Ctrl+W) — respects path separators
      */
     deleteWordBackward() {
         if (this.cursorPos === 0)
             return;
-        const beforeCursor = this.value.slice(0, this.cursorPos);
         const afterCursor = this.value.slice(this.cursorPos);
-        // Find last word boundary (skip trailing spaces, then find space)
-        let i = beforeCursor.length - 1;
-        while (i >= 0 && beforeCursor[i] === ' ')
+        let i = this.cursorPos - 1;
+        // Skip trailing spaces
+        while (i >= 0 && this.value[i] === ' ')
             i--;
-        while (i >= 0 && beforeCursor[i] !== ' ')
+        // Delete back to next word boundary
+        while (i >= 0 && !this.isWordBoundary(this.value[i]))
             i--;
-        const newBefore = beforeCursor.slice(0, i + 1);
+        const newBefore = this.value.slice(0, i + 1);
         this.value = newBefore + afterCursor;
         this.cursorPos = newBefore.length;
     }
@@ -361,6 +409,12 @@ export class LineEditor {
                     this.cursorPos++;
                 }
                 break;
+            case 'ctrl-left':
+                this.wordLeft();
+                break;
+            case 'ctrl-right':
+                this.wordRight();
+                break;
             case 'home':
                 this.cursorPos = 0;
                 break;

package/dist/renderer/Screen.d.ts

@@ -14,7 +14,12 @@ export declare class Screen {
     private cursorX;
     private cursorY;
     private cursorVisible;
+    private resizeCallback;
     constructor();
+    /**
+     * Register a callback to be called on terminal resize
+     */
+    onResize(callback: () => void): void;
     private createEmptyBuffer;
     /**
      * Get terminal dimensions

package/dist/renderer/Screen.js

@@ -11,6 +11,7 @@ export class Screen {
     cursorX = 0;
     cursorY = 0;
     cursorVisible = true;
+    resizeCallback = null;
     constructor() {
         this.width = process.stdout.columns || 80;
         this.height = process.stdout.rows || 24;
@@ -22,9 +23,18 @@ export class Screen {
             this.height = process.stdout.rows || 24;
             this.buffer = this.createEmptyBuffer();
             this.rendered = this.createEmptyBuffer();
-            this.fullRender();
+            // Notify the app to re-render with new dimensions
+            if (this.resizeCallback) {
+                this.resizeCallback();
+            }
         });
     }
+    /**
+     * Register a callback to be called on terminal resize
+     */
+    onResize(callback) {
+        this.resizeCallback = callback;
+    }
     createEmptyBuffer() {
         const buffer = [];
         for (let y = 0; y < this.height; y++) {

package/dist/renderer/main.js

@@ -16,6 +16,7 @@ import { isProjectDirectory, getProjectContext } from '../utils/project.js';
 import { getCurrentVersion } from '../utils/update.js';
 import { getProviderList, getProvider } from '../config/providers.js';
 import { getSessionStats } from '../utils/tokenTracker.js';
+import { checkApiRateLimit } from '../utils/ratelimit.js';
 // State
 let projectPath = process.cwd();
 let projectContext = null;
@@ -127,6 +128,12 @@ async function handleSubmit(message) {
         runAgentTask(message, false);
         return;
     }
+    // Check API rate limit
+    const rateCheck = checkApiRateLimit();
+    if (!rateCheck.allowed) {
+        app.notify(rateCheck.message || 'Rate limit exceeded', 5000);
+        return;
+    }
     try {
         app.startStreaming();
         // Get conversation history for context
@@ -144,6 +151,9 @@ async function handleSubmit(message) {
     catch (error) {
         app.endStreaming();
         const err = error;
+        // Don't show error for user-cancelled requests
+        if (err.name === 'AbortError')
+            return;
         app.notify(`Error: ${err.message}`, 5000);
     }
 }
@@ -966,12 +976,23 @@ function handleCommand(command, args) {
                     for (const p of configuredProviders) {
                         clearApiKey(p.id);
                     }
-                    app.notify('Logged out from all providers');
+                    app.notify('Logged out from all providers. Use /login to sign in.');
                 }
                 else {
                     clearApiKey(result);
                     const provider = configuredProviders.find(p => p.id === result);
                     app.notify(`Logged out from ${provider?.name || result}`);
+                    // If we logged out from the active provider, switch to another configured one
+                    if (result === currentProvider.id) {
+                        const remaining = configuredProviders.filter(p => p.id !== result);
+                        if (remaining.length > 0) {
+                            setProvider(remaining[0].id);
+                            app.notify(`Switched to ${remaining[0].name}`);
+                        }
+                        else {
+                            app.notify('No providers configured. Use /login to sign in.');
+                        }
+                    }
                 }
             });
             break;
@@ -1057,12 +1078,24 @@ function handleCommand(command, args) {
                 app.notify('No assistant response to apply');
                 return;
             }
-            // Find file changes in the response
-            const filePattern = /```(\w+)?\s*\n\/\/\s*(?:File:|Path:)\s*([^\n]+)\n([\s\S]*?)```/g;
+            // Find file changes in the response using multiple patterns
             const changes = [];
+            // Pattern 1: ```lang filepath\n...\n``` (most common AI format)
+            const fenceFilePattern = /```\w*\s+([\w./\\-]+(?:\.\w+))\n([\s\S]*?)```/g;
             let match;
-            while ((match = filePattern.exec(lastAssistant.content)) !== null) {
-                changes.push({ path: match[2].trim(), content: match[3] });
+            while ((match = fenceFilePattern.exec(lastAssistant.content)) !== null) {
+                const path = match[1].trim();
+                // Must look like a file path (has extension, no spaces)
+                if (path.includes('.') && !path.includes(' ')) {
+                    changes.push({ path, content: match[2] });
+                }
+            }
+            // Pattern 2: // File: or // Path: comment on first line of code block
+            if (changes.length === 0) {
+                const commentPattern = /```(\w+)?\s*\n(?:\/\/|#|--|\/\*)\s*(?:File|Path|file|path):\s*([^\n*]+)\n([\s\S]*?)```/g;
+                while ((match = commentPattern.exec(lastAssistant.content)) !== null) {
+                    changes.push({ path: match[2].trim(), content: match[3] });
+                }
             }
             if (changes.length === 0) {
                 app.notify('No file changes found in response');

package/dist/utils/agent.js

@@ -80,7 +80,7 @@ export function loadProjectRules(projectRoot) {
  * Keeps the most recent messages within a character budget so the agent
  * has conversational context without overwhelming the context window.
  */
-export function formatChatHistoryForAgent(history, maxChars = 8000) {
+export function formatChatHistoryForAgent(history, maxChars = 16000) {
     if (!history || history.length === 0)
         return '';
     // Filter out agent execution messages

package/dist/utils/tools.d.ts

@@ -262,6 +262,17 @@ export declare const AGENT_TOOLS: {
             };
         };
     };
+    minimax_web_search: {
+        name: string;
+        description: string;
+        parameters: {
+            query: {
+                type: string;
+                description: string;
+                required: boolean;
+            };
+        };
+    };
 };
 export declare function formatToolDefinitions(): string;
 /**

package/dist/utils/tools.js

@@ -13,11 +13,15 @@ import { executeCommand } from './shell.js';
 import { recordWrite, recordEdit, recordDelete, recordMkdir, recordCommand } from './history.js';
 import { loadIgnoreRules, isIgnored } from './gitignore.js';
 import { config, getApiKey } from '../config/index.js';
-import { getProviderMcpEndpoints } from '../config/providers.js';
+import { getProviderMcpEndpoints, PROVIDERS } from '../config/providers.js';
 // Z.AI MCP tool names (available when user has any Z.AI API key)
 const ZAI_MCP_TOOLS = ['web_search', 'web_read', 'github_read'];
 // Z.AI provider IDs that have MCP endpoints
 const ZAI_PROVIDER_IDS = ['z.ai', 'z.ai-cn'];
+// MiniMax MCP tool names (available when user has any MiniMax API key)
+const MINIMAX_MCP_TOOLS = ['minimax_web_search'];
+// MiniMax provider IDs
+const MINIMAX_PROVIDER_IDS = ['minimax', 'minimax-cn'];
 /**
  * Find a Z.AI provider that has an API key configured.
  * Returns the provider ID and API key, or null if none found.
@@ -49,6 +53,77 @@ function getZaiMcpConfig() {
 function hasZaiMcpAccess() {
     return getZaiMcpConfig() !== null;
 }
+/**
+ * Find a MiniMax provider that has an API key configured.
+ * Returns the base host URL and API key, or null if none found.
+ */
+function getMinimaxMcpConfig() {
+    // First check if active provider is MiniMax
+    const activeProvider = config.get('provider');
+    if (MINIMAX_PROVIDER_IDS.includes(activeProvider)) {
+        const key = getApiKey(activeProvider);
+        if (key) {
+            const provider = PROVIDERS[activeProvider];
+            const baseUrl = provider?.protocols?.openai?.baseUrl;
+            if (baseUrl) {
+                // Extract host from baseUrl (e.g. https://api.minimax.io/v1 -> https://api.minimax.io)
+                const host = baseUrl.replace(/\/v1\/?$/, '');
+                return { host, apiKey: key };
+            }
+        }
+    }
+    // Otherwise check all MiniMax providers
+    for (const pid of MINIMAX_PROVIDER_IDS) {
+        const key = getApiKey(pid);
+        if (key) {
+            const provider = PROVIDERS[pid];
+            const baseUrl = provider?.protocols?.openai?.baseUrl;
+            if (baseUrl) {
+                const host = baseUrl.replace(/\/v1\/?$/, '');
+                return { host, apiKey: key };
+            }
+        }
+    }
+    return null;
+}
+/**
+ * Check if MiniMax MCP tools are available
+ */
+function hasMinimaxMcpAccess() {
+    return getMinimaxMcpConfig() !== null;
+}
+/**
+ * Call a MiniMax MCP REST API endpoint
+ */
+async function callMinimaxApi(host, path, body, apiKey) {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 60000);
+    try {
+        const response = await fetch(`${host}${path}`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'Authorization': `Bearer ${apiKey}`,
+            },
+            body: JSON.stringify(body),
+            signal: controller.signal,
+        });
+        if (!response.ok) {
+            const errorText = await response.text().catch(() => '');
+            throw new Error(`MiniMax API error ${response.status}: ${errorText || response.statusText}`);
+        }
+        const data = await response.json();
+        // MiniMax returns content array like MCP
+        if (data.content && Array.isArray(data.content)) {
+            return data.content.map((c) => c.text || '').join('\n');
+        }
+        // Fallback: return raw result
+        return typeof data === 'string' ? data : JSON.stringify(data);
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}
 /**
  * Call a Z.AI MCP endpoint via JSON-RPC 2.0
  */
@@ -196,18 +271,28 @@ export const AGENT_TOOLS = {
             path: { type: 'string', description: 'File path (for action=read_file) or directory path (for action=tree)', required: false },
         },
     },
+    minimax_web_search: {
+        name: 'minimax_web_search',
+        description: 'Search the web using MiniMax search engine. Returns relevant results with summaries. Requires a MiniMax API key.',
+        parameters: {
+            query: { type: 'string', description: 'Search query', required: true },
+        },
+    },
 };
 /**
  * Format tool definitions for system prompt (text-based fallback)
  */
 /**
- * Get filtered tool entries (excludes Z.AI-only tools when not using Z.AI provider)
+ * Get filtered tool entries (excludes provider-specific tools when API key not available)
  */
 function getFilteredToolEntries() {
     const hasMcp = hasZaiMcpAccess();
+    const hasMinimaxMcp = hasMinimaxMcpAccess();
     return Object.entries(AGENT_TOOLS).filter(([name]) => {
         if (ZAI_MCP_TOOLS.includes(name))
             return hasMcp;
+        if (MINIMAX_MCP_TOOLS.includes(name))
+            return hasMinimaxMcp;
         return true;
     });
 }
@@ -1099,6 +1184,20 @@ export async function executeTool(toolCall, projectRoot) {
                 const output = result.length > 15000 ? result.substring(0, 15000) + '\n\n... (truncated)' : result;
                 return { success: true, output, tool, parameters };
             }
+            // === MiniMax MCP Tools ===
+            case 'minimax_web_search': {
+                const mmConfig = getMinimaxMcpConfig();
+                if (!mmConfig) {
+                    return { success: false, output: '', error: 'minimax_web_search requires a MiniMax API key. Configure one via /provider minimax', tool, parameters };
+                }
+                const query = parameters.query;
+                if (!query) {
+                    return { success: false, output: '', error: 'Missing required parameter: query', tool, parameters };
+                }
+                const result = await callMinimaxApi(mmConfig.host, '/v1/coding_plan/search', { q: query }, mmConfig.apiKey);
+                const output = result.length > 15000 ? result.substring(0, 15000) + '\n\n... (truncated)' : result;
+                return { success: true, output, tool, parameters };
+            }
             default:
                 return { success: false, output: '', error: `Unknown tool: ${tool}`, tool, parameters };
         }
@@ -1217,6 +1316,7 @@ export function createActionLog(toolCall, result) {
         web_search: 'fetch',
         web_read: 'fetch',
         github_read: 'fetch',
+        minimax_web_search: 'fetch',
     };
     const target = toolCall.parameters.path ||
         toolCall.parameters.command ||

package/dist/utils/tools.test.js

@@ -2,9 +2,11 @@ import { describe, it, expect } from 'vitest';
 import { getOpenAITools, getAnthropicTools, parseToolCalls, parseOpenAIToolCalls, parseAnthropicToolCalls, createActionLog, AGENT_TOOLS, } from './tools.js';
 // ─── CONSTANTS ───────────────────────────────────────────────────────────────
 const ALL_TOOL_NAMES = Object.keys(AGENT_TOOLS);
-// MCP tools are filtered out when no Z.AI API key is configured (e.g. in tests)
+// MCP tools are filtered out when no API key is configured (e.g. in tests)
 const ZAI_MCP_TOOLS = ['web_search', 'web_read', 'github_read'];
-const CORE_TOOL_NAMES = ALL_TOOL_NAMES.filter(n => !ZAI_MCP_TOOLS.includes(n));
+const MINIMAX_MCP_TOOLS = ['minimax_web_search'];
+const MCP_TOOLS = [...ZAI_MCP_TOOLS, ...MINIMAX_MCP_TOOLS];
+const CORE_TOOL_NAMES = ALL_TOOL_NAMES.filter(n => !MCP_TOOLS.includes(n));
 // ─── getOpenAITools ──────────────────────────────────────────────────────────
 describe('getOpenAITools', () => {
     it('should return one entry per AGENT_TOOLS definition', () => {
@@ -578,6 +580,11 @@ describe('createActionLog', () => {
         const log = createActionLog(tc, makeResult({ tool: 'fetch_url' }));
         expect(log.type).toBe('fetch');
     });
+    it('should map minimax_web_search to type "fetch"', () => {
+        const tc = { tool: 'minimax_web_search', parameters: { query: 'test' } };
+        const log = createActionLog(tc, makeResult({ tool: 'minimax_web_search' }));
+        expect(log.type).toBe('fetch');
+    });
     it('should default to type "command" for unknown tools', () => {
         const tc = { tool: 'unknown_tool', parameters: {} };
         const log = createActionLog(tc, makeResult({ tool: 'unknown_tool' }));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codeep",
-  "version": "1.2.14",
+  "version": "1.2.16",
   "description": "AI-powered coding assistant built for the terminal. Multiple LLM providers, project-aware context, and a seamless development workflow.",
   "type": "module",
   "main": "dist/index.js",