minovative-mind-cli 2.4.0 → 2.5.0

package/README.md

@@ -93,6 +93,11 @@ Hot-swap during a session using `/models`:
 | **Gemini 3.1 Pro**        | Complex architectural changes                       |
 | **Gemini 3.5 Flash Lite** | Best for speed and cost efficiency                  |
 
+### BYOK (Bring Your Own Key)
+If you prefer to use your own Gemini API key, you can configure it via the settings.
+*   **Configuration:** Set `useByok: true` and `geminiApiKey: "YOUR_KEY"` in your credentials storage.
+*   **Error Handling:** If your key is invalid, expired, or you hit rate limits, the CLI will report a `BYOK AI Error`. Please check your API key status in the Google AI Studio dashboard.
+
 > Background tasks (routing, compression, commits) always use lightweight
 > models automatically. You pay for those lightweight model
 > background ai models and for your selected model

package/dist/commands/chat.js

@@ -30,6 +30,7 @@ Inside the chat session, you can use the following commands in the slash menu:
   /auto-approve  - Toggle automatic approval of tool/command runs
   /sub-agents    - Toggle the MMAAK Engine for parallel investigation and execution
   /workspaces    - Manage external workspaces for cross-project development
+  /config-key    - BYOK (Bring Your Own Key) Configuration
   /stats         - View current session statistics and configuration
   /commit        - Commit current workspace changes to Git
   /revert        - Revert the last file modification made by the agent

package/dist/services/agent/slashCommands.js

@@ -11,8 +11,11 @@ import { chatHistoryService } from '../chatHistoryService.js';
 import { printLogo, brandBg, brandFg } from '../../utils/logo.js';
 import { readPaste } from '../../utils/paste.js';
 import { setApprovalMode, getApprovalMode, isSubAgentsEnabled, setSubAgentsEnabled } from '../agent-tools.js';
-import { ProxyChatSession, setGlobalActiveModel, getGlobalActiveModel } from '../ai.js';
-import { GEMINI_MODELS } from '../../utils/config.js';
+import { ProxyClient, getAndResetTurnUsage } from '../proxyClient.js';
+import { getAuthorizedIdToken } from '../auth.js';
+import { GEMINI_MODELS, isByokEnabled } from '../../utils/config.js';
+import { loadCredentials, updateCredentialField } from '../../utils/credentialStore.js';
+import { getGlobalActiveModel, setGlobalActiveModel, ProxyChatSession } from '../ai.js';
 const execAsync = promisify(exec);
 /**
  * Handles all slash command operations (/paste, /clear, /models, /debug, /auto-approve, /revert, /commit).
@@ -21,6 +24,44 @@ const execAsync = promisify(exec);
 export async function handleSlashCommand(command, context) {
     const { chat, inputHandler, workspaceRoot, version, chatSessionState } = context;
     const lowerCommand = command.toLowerCase();
+    if (lowerCommand === '/config-key') {
+        const creds = await loadCredentials();
+        const action = await p['select']({
+            message: 'BYOK (Bring Your Own Key) Configuration',
+            options: [
+                { value: 'status', label: 'Status' },
+                { value: 'toggle', label: creds.useByok ? 'Disable BYOK' : 'Enable BYOK' },
+                { value: 'set', label: 'Set API Key' },
+                { value: 'clear', label: 'Clear API Key' },
+                { value: 'cancel', label: 'Cancel' },
+            ],
+        });
+        if (action === 'status') {
+            const enabled = await isByokEnabled();
+            p.log.info(`BYOK Status: ${enabled ? pc.green('Enabled') : pc.red('Disabled')}\n` +
+                `API Key: ${creds.geminiApiKey ? pc.green('Set') : pc.red('Not Set')}`);
+        }
+        else if (action === 'toggle') {
+            await updateCredentialField('useByok', !creds.useByok);
+            p.log.success(`BYOK ${!creds.useByok ? 'enabled' : 'disabled'}.`);
+        }
+        else if (action === 'set') {
+            const key = await p['text']({
+                message: 'Enter your Gemini API Key:',
+                validate: (value) => (value ? undefined : 'API Key is required'),
+            });
+            if (key && typeof key === 'string') {
+                await updateCredentialField('geminiApiKey', key);
+                p.log.success('API Key updated.');
+            }
+        }
+        else if (action === 'clear') {
+            await updateCredentialField('geminiApiKey', '');
+            await updateCredentialField('useByok', false);
+            p.log.success('API Key cleared and BYOK disabled.');
+        }
+        return { shouldContinue: true };
+    }
     if (lowerCommand === '/paste') {
         p.log.info(pc.cyan('Paste mode activated. Paste your text below, then press Ctrl+D on an empty line to submit. (Ctrl+C to cancel)'));
         try {
@@ -155,12 +196,14 @@ export async function handleSlashCommand(command, context) {
         const autoApprove = getApprovalMode() === 'skip-all' ? 'Enabled' : 'Disabled';
         const subAgents = isSubAgentsEnabled() ? 'Enabled' : 'Disabled';
         const planMode = context.isPlanMode ? 'Enabled' : 'Disabled';
+        const byokEnabled = await isByokEnabled() ? 'Enabled' : 'Disabled';
         p.log.step(pc.magenta('📊 Session Statistics & Status'));
         console.log(pc.dim('----------------------------------------'));
         console.log(`${pc.bold('AI Model:')}         ${pc.cyan(displayModel)}`);
         console.log(`${pc.bold('Auto-Approve:')}     ${autoApprove === 'Enabled' ? pc.green(autoApprove) : pc.yellow(autoApprove)}`);
         console.log(`${pc.bold('Sub-Agents:')}       ${subAgents === 'Enabled' ? pc.green(subAgents) : pc.yellow(subAgents)}`);
         console.log(`${pc.bold('Plan Mode:')}        ${planMode === 'Enabled' ? pc.green(planMode) : pc.yellow(planMode)}`);
+        console.log(`${pc.bold('BYOK:')}             ${byokEnabled === 'Enabled' ? pc.green(byokEnabled) : pc.yellow(byokEnabled)}`);
         const debugMode = isDebugOn() ? 'Enabled' : 'Disabled';
         console.log(`${pc.bold('Debug Log:')}        ${debugMode === 'Enabled' ? pc.green(debugMode) : pc.yellow(debugMode)}`);
         try {
@@ -835,5 +878,66 @@ ${diffOut}
         }
         return { shouldContinue: true };
     }
+    if (lowerCommand === '/config-key') {
+        const creds = await loadCredentials();
+        const byokEnabled = !!(creds.useByok && creds.geminiApiKey);
+        const action = await p['select']({
+            message: `API Key Configuration (Current Mode: ${byokEnabled ? pc.green('BYOK') : pc.yellow('Credits')})`,
+            options: [
+                { value: 'toggle', label: byokEnabled ? 'Disable BYOK (Use Credits)' : 'Enable BYOK (Use API Key)' },
+                { value: 'set', label: 'Set/Update API Key' },
+                { value: 'clear', label: 'Clear API Key' },
+                { value: 'status', label: 'Check Status' },
+                { value: 'cancel', label: 'Cancel' },
+            ],
+        });
+        if (p.isCancel(action) || action === 'cancel')
+            return { shouldContinue: true };
+        if (action === 'toggle') {
+            if (!byokEnabled && !creds.geminiApiKey) {
+                p.log.error('You must set an API key before enabling BYOK mode.');
+            }
+            else {
+                await updateCredentialField('useByok', !byokEnabled);
+                p.log.success(`BYOK mode is now ${!byokEnabled ? pc.green('Enabled') : pc.yellow('Disabled')}`);
+            }
+        }
+        else if (action === 'set') {
+            const key = await p['password']({
+                message: 'Enter your Google AI Studio API Key:',
+                validate: (v) => (!v ? 'API key is required' : undefined),
+            });
+            if (p.isCancel(key))
+                return { shouldContinue: true };
+            const spinner = p.spinner();
+            spinner.start('Validating API Key...');
+            try {
+                // Test call to verify key
+                const client = new ProxyClient();
+                const idToken = (await getAuthorizedIdToken()) || '';
+                // We use a simple prompt to test the key
+                await client.generateFunctionCallViaProxy(idToken, 'gemini-3.5-flash-lite', [{ role: 'user', parts: [{ text: 'ping' }] }], undefined, undefined, 'You are a validator. Respond with "pong".', { maxOutputTokens: 10 });
+                // Reset metrics after validation
+                getAndResetTurnUsage();
+                await updateCredentialField('geminiApiKey', key);
+                spinner.stop('API Key validated and updated.');
+                p.log.success('API key saved.');
+            }
+            catch (err) {
+                spinner.stop('Validation failed.');
+                p.log.error(`Invalid API Key: ${err.message}`);
+            }
+        }
+        else if (action === 'clear') {
+            await updateCredentialField('geminiApiKey', undefined);
+            await updateCredentialField('useByok', false);
+            p.log.success('API key cleared and BYOK mode disabled.');
+        }
+        else if (action === 'status') {
+            p.log.info(`Mode: ${byokEnabled ? pc.green('BYOK') : pc.yellow('Credits')}\n` +
+                `Key Set: ${creds.geminiApiKey ? pc.green('Yes') : pc.red('No')}`);
+        }
+        return { shouldContinue: true };
+    }
     return { shouldContinue: true };
 }

package/dist/services/agent/toolLoop.js

@@ -115,8 +115,7 @@ export async function processResponse(chat, result, workspaceRoot, inputHandler,
     const MAX_TURNS = Infinity;
     // Recovery thresholds for handling unexpected empty API payloads
     let emptyRetryCount = 0;
-    const MAX_EMPTY_RETRIES = 3;
-    const visitedToolCalls = new Set();
+    const MAX_EMPTY_RETRIES = 5;
     // Loop while the model keeps requesting tool calls
     while (true) {
         turnCount++;
@@ -179,7 +178,7 @@ export async function processResponse(chat, result, workspaceRoot, inputHandler,
         const collector = getMetricCollector();
         if (collector)
             collector.recordToolTurn();
-        const execRes = await executeToolCalls(functionCalls, workspaceRoot, inputHandler, abortSignal, visitedToolCalls);
+        const execRes = await executeToolCalls(functionCalls, workspaceRoot, inputHandler, abortSignal);
         if (execRes.aborted) {
             return '[Generation stopped by user]';
         }
@@ -222,7 +221,7 @@ export async function processResponse(chat, result, workspaceRoot, inputHandler,
         response = followUp.response;
     }
 }
-async function executeToolCalls(functionCalls, workspaceRoot, inputHandler, abortSignal, visitedToolCalls) {
+async function executeToolCalls(functionCalls, workspaceRoot, inputHandler, abortSignal) {
     const toolResponses = [];
     for (const fc of functionCalls) {
         await inputHandler.waitForPrompt();
@@ -232,19 +231,6 @@ async function executeToolCalls(functionCalls, workspaceRoot, inputHandler, abor
         }
         const toolName = fc.name;
         const toolArgs = (fc.args ?? {});
-        const callSignature = `${toolName}:${JSON.stringify(toolArgs)}`;
-        if (visitedToolCalls.has(callSignature)) {
-            toolResponses.push({
-                functionResponse: {
-                    name: toolName,
-                    response: {
-                        error: 'You have already made this exact tool call previously. Please review your context history or try a different action.'
-                    }
-                }
-            });
-            continue;
-        }
-        visitedToolCalls.add(callSignature);
         // Log the ongoing tool action to the console
         p.log.step(formatToolCall(toolName, toolArgs));
         // If executing a CLI/shell command, wait for approval
@@ -281,6 +267,8 @@ async function executeToolCalls(functionCalls, workspaceRoot, inputHandler, abor
                 p.log.warn(`${pc.red('Tool error:')} [${displayError}]`);
             }
         }
+        if (!toolResult.error && (toolName === 'write_file' || toolName === 'modify_file' || toolName === 'delete_file')) {
+        }
         toolResponses.push({
             functionResponse: {
                 name: toolName,

package/dist/services/agent-tools.js

@@ -330,8 +330,20 @@ const DEFAULT_IGNORED_DIRS = new Set([
     '.cache',
     'coverage',
     '.turbo',
+    '.tmp',
+    'temp',
+    'tmp',
+    '.minovativemind',
+]);
+const DEFAULT_IGNORED_FILES = new Set([
+    'package-lock.json',
+    'yarn.lock',
+    'pnpm-lock.yaml',
+    '.DS_Store',
+    '.minovative-scratch.js',
+    'testExtractor.ts',
+    'testExtractor.js',
 ]);
-const DEFAULT_IGNORED_FILES = new Set(['package-lock.json', 'yarn.lock', 'pnpm-lock.yaml', '.DS_Store']);
 /**
  * Parses .gitignore and .minovativemindignore to supplement the default ignore lists.
  */
@@ -339,7 +351,7 @@ async function getIgnoredPaths(workspaceRoot) {
     const ignoredDirs = new Set(DEFAULT_IGNORED_DIRS);
     const ignoredFiles = new Set(DEFAULT_IGNORED_FILES);
     const ig = ignore();
-    ig.add(Array.from(DEFAULT_IGNORED_DIRS).map(d => d + '/'));
+    ig.add(Array.from(DEFAULT_IGNORED_DIRS).map((d) => d + '/'));
     ig.add(Array.from(DEFAULT_IGNORED_FILES));
     const filesToRead = ['.gitignore', '.minovativemindignore'];
     for (const ignoreFile of filesToRead) {
@@ -582,7 +594,7 @@ export async function writeFile(workspaceRoot, filePath, content) {
         if (!validation.valid) {
             return {
                 output: '',
-                error: `Syntax validation failed for "${filePath}":\\n- ${validation.errors.join('\\n- ')}\\n\\nPlease fix the syntax and try again.`,
+                error: `Syntax validation failed for "${filePath}":\n- ${validation.errors.join('\n- ')}\n\nPlease fix the syntax and try again.`,
             };
         }
         await fs.mkdir(path.dirname(absPath), { recursive: true });
@@ -594,7 +606,7 @@ export async function writeFile(workspaceRoot, filePath, content) {
         const message = err instanceof Error ? err.message : String(err);
         const collector = getMetricCollector();
         if (collector)
-            collector.recordWriteFailure();
+            collector.recordWriteFailure?.();
         return {
             output: '',
             error: `Failed to write file "${filePath}": ${message}`,
@@ -645,7 +657,7 @@ export async function renameFile(workspaceRoot, sourcePath, targetPath) {
     }
 }
 export async function modifyFile(workspaceRoot, filePath, edits) {
-    const MAX_MODIFY_RETRIES = 2;
+    const MAX_MODIFY_RETRIES = 4;
     const absPath = resolveAndValidatePath(workspaceRoot, filePath);
     for (let attempt = 1; attempt <= MAX_MODIFY_RETRIES; attempt++) {
         try {
@@ -658,17 +670,17 @@ export async function modifyFile(workspaceRoot, filePath, edits) {
                 if (!match) {
                     const collector = getMetricCollector();
                     if (collector)
-                        collector.recordModifyFailure();
+                        collector.recordModifyFailure?.();
                     if (attempt < MAX_MODIFY_RETRIES) {
                         // Break out of inner loop, triggering a retry in outer loop
                         modified = existing; // reset
                         break;
                     }
                     // Provide a preview of the file to help the AI self-correct
-                    const preview = modified.split('\\n').slice(0, 20).join('\\n');
+                    const preview = modified.split('\n').slice(0, 30).join('\n');
                     return {
                         output: '',
-                        error: `Edit #${i + 1} failed: Search content not found in "${filePath}".\\nFile start preview:\\n${preview}\\n...`,
+                        error: `Edit #${i + 1} failed: Search content not found in "${filePath}". Please call 'read_file' to check the exact lines of code before retrying modify_file.\n\nFile start preview:\n${preview}\n...`,
                     };
                 }
                 modified = applyMatch(modified, match, edit.replaceContent);
@@ -776,27 +788,27 @@ export async function runCommand(workspaceRoot, command, abortSignal) {
     try {
         const { stdout, stderr } = await execAsync(command, {
             cwd: workspaceRoot,
-            timeout: 60_000, // 60 second timeout
+            timeout: 120_000, // 120 second timeout
             maxBuffer: 1024 * 1024 * 2, // 2 MB buffer
             signal: abortSignal,
         });
         let output = [stdout, stderr].filter(Boolean).join('\n');
         // Truncate command output to prevent memory blowout from massive build logs
-        const MAX_CMD_OUTPUT = 15_000;
+        const MAX_CMD_OUTPUT = 30_000;
         if (output.length > MAX_CMD_OUTPUT) {
             output =
                 output.substring(0, MAX_CMD_OUTPUT) +
-                    `\n\n... (Output truncated: ${output.length} bytes exceeded 15KB limit. To view the rest, pipe the command to a file and read it in chunks, or use grep.)`;
+                    `\n\n... (Output truncated: ${output.length} bytes exceeded 30KB limit. To view the rest, pipe the command to a file and read it in chunks, or use grep.)`;
         }
         return { output: output || '(command produced no output)' };
     }
     catch (err) {
         const message = err instanceof Error ? err.message : String(err);
         // Also truncate error output
-        const MAX_ERR_OUTPUT = 15_000;
+        const MAX_ERR_OUTPUT = 30_000;
         const truncatedMsg = message.length > MAX_ERR_OUTPUT
             ? message.substring(0, MAX_ERR_OUTPUT) +
-                `\n\n... (Error output truncated: ${message.length} bytes exceeded 15KB limit. Pipe to a file if you need full logs.)`
+                `\n\n... (Error output truncated: ${message.length} bytes exceeded 30KB limit. Pipe to a file if you need full logs.)`
             : message;
         return { output: '', error: `Command failed: ${truncatedMsg}` };
     }
@@ -1281,7 +1293,7 @@ export async function executeTool(workspaceRoot, toolName, args, abortSignal) {
     if (result.error) {
         const collector = getMetricCollector();
         if (collector)
-            collector.recordToolFailure(toolName);
+            collector.recordToolFailure?.(toolName);
     }
     return result;
 }

package/dist/services/agent.js

@@ -171,6 +171,7 @@ export async function startAgentLoop(workspaceRoot, version) {
                         label: '/workspaces',
                         hint: 'Manage external workspaces for cross-project development',
                     },
+                    { value: '/config-key', label: '/config-key', hint: 'BYOK (Bring Your Own Key) Configuration' },
                     { value: '/stats', label: '/stats', hint: 'View current session statistics and configuration' },
                     { value: '/commit', label: '/commit', hint: 'Auto-commit changes with AI message' },
                     { value: '/revert', label: '/revert', hint: 'Undo last change' },

package/dist/services/ai.d.ts

@@ -1,4 +1,4 @@
-import type { Content, FunctionCall } from '@google/generative-ai';
+import { type Content, type FunctionCall } from '@google/generative-ai';
 export declare function setModelOverride(agent: 'context' | 'execution', overrideStr: string): void;
 export declare function clearModelOverrides(): void;
 export declare function setGlobalActiveModel(model: string): void;

package/dist/services/ai.js

@@ -1,12 +1,14 @@
-import { GEMINI_MODELS, DEFAULT_MODEL, MAX_OUTPUT_TOKENS } from '../utils/config.js';
+import { GoogleGenerativeAI } from '@google/generative-ai';
+import { GEMINI_MODELS, DEFAULT_MODEL, MAX_OUTPUT_TOKENS, isByokEnabled } from '../utils/config.js';
 import { getToolDeclarations } from './agent-tools.js';
-import { ProxyClient } from './proxyClient.js';
+import { getMetricCollector } from './metrics.js';
 import { getAuthorizedIdToken } from './auth.js';
 import { debugLog } from '../utils/logger.js';
 import { readCache, writeCache } from '../utils/projectStorage.js';
 import { GENERAL_CHAT_INSTRUCTION, PLAN_EXECUTION_INSTRUCTION, PLAN_MODE_INSTRUCTION, CONTEXT_SYSTEM_INSTRUCTION, INTENT_ROUTER_SYSTEM_INSTRUCTION, WEB_SEARCH_SYSTEM_INSTRUCTION, EXECUTION_COMPLEXITY_SYSTEM_INSTRUCTION, INVESTIGATION_COMPLEXITY_SYSTEM_INSTRUCTION, } from '../utils/systemPrompts.js';
-import { getMetricCollector } from './metrics.js';
 import { workspaceRegistry } from './workspaceRegistry.js';
+import { loadCredentials } from '../utils/credentialStore.js';
+import { ProxyClient, accumulateTurnUsage } from './proxyClient.js';
 function getMultiWorkspaceBlock() {
     const summary = workspaceRegistry.buildPromptSummary();
     if (!summary)
@@ -206,15 +208,57 @@ export class ProxyChatSession {
         // Prune old history before sending to keep payload bounded
         await this.pruneHistory();
         const effectiveGenerationConfig = { ...this.generationConfig };
-        const result = await proxyClient.generateFunctionCallViaProxy(idToken, this.modelName, this.history, this.tools, undefined, // toolConfig
-        this.systemInstruction, effectiveGenerationConfig, onChunk ? { onChunk } : undefined, // streamCallbacks
-        abortSignal);
+        const byokEnabled = await isByokEnabled();
+        let result;
+        if (byokEnabled) {
+            const creds = await loadCredentials();
+            const genAI = new GoogleGenerativeAI(creds.geminiApiKey);
+            const model = genAI.getGenerativeModel({
+                model: this.modelName,
+                systemInstruction: this.systemInstruction,
+                tools: this.tools,
+            });
+            const chat = model.startChat({
+                history: this.history.slice(0, -1),
+                generationConfig: effectiveGenerationConfig,
+            });
+            const lastMessage = this.history[this.history.length - 1];
+            try {
+                const response = await chat.sendMessage(lastMessage.parts);
+                const responseObj = await response.response;
+                result = {
+                    functionCalls: responseObj.functionCalls(),
+                    parts: responseObj.candidates?.[0]?.content?.parts,
+                    usageMetadata: responseObj.usageMetadata,
+                };
+                if (responseObj.usageMetadata) {
+                    const collector = getMetricCollector();
+                    collector?.accumulateUsage(responseObj.usageMetadata);
+                }
+            }
+            catch (error) {
+                debugLog(`Failed to send message via BYOK: ${error}`);
+                const errorMessage = error?.message || '';
+                if (error?.status === 401 ||
+                    error?.status === 403 ||
+                    errorMessage.includes('API_KEY_INVALID') ||
+                    errorMessage.includes('quota') ||
+                    errorMessage.includes('PERMISSION_DENIED')) {
+                    throw new Error('AI_BYOK_ERROR: Your API key or quota is invalid. Please run /config-key to update your settings.');
+                }
+                throw error;
+            }
+        }
+        else {
+            result = await proxyClient.generateFunctionCallViaProxy(idToken, this.modelName, this.history, this.tools, undefined, // toolConfig
+            this.systemInstruction, effectiveGenerationConfig, onChunk ? { onChunk } : undefined, // streamCallbacks
+            abortSignal);
+        }
         this.latestUsageMetadata = result.usageMetadata;
         // Track token usage metrics
         if (result.usageMetadata) {
-            const { accumulateUsage } = await import('./metrics.js');
-            accumulateUsage(result.usageMetadata);
             const collector = getMetricCollector();
+            collector?.accumulateUsage(result.usageMetadata);
             if (collector) {
                 collector.recordTokenUsage(result.usageMetadata.promptTokens || 0, result.usageMetadata.candidatesTokens || 0, result.usageMetadata.cachedTokens || 0);
             }
@@ -323,8 +367,38 @@ export async function compressTextUsingFlashLite(text, instruction = "<directive
             parts.push({ inlineData });
         }
         const contents = [{ role: 'user', parts }];
-        const result = await proxyClient.generateFunctionCallViaProxy(idToken, model, contents, [], // no tools
-        undefined, instruction, { temperature: 0.2 });
+        const byokEnabled = await isByokEnabled();
+        let result;
+        if (byokEnabled) {
+            try {
+                const creds = await loadCredentials();
+                const genAI = new GoogleGenerativeAI(creds.geminiApiKey);
+                const modelObj = genAI.getGenerativeModel({
+                    model,
+                    systemInstruction: instruction,
+                });
+                const response = await modelObj.generateContent({
+                    contents: [{ role: 'user', parts }],
+                    generationConfig: { temperature: 0.2 },
+                });
+                const responseObj = await response.response;
+                result = {
+                    parts: responseObj.candidates?.[0]?.content?.parts,
+                    usageMetadata: responseObj.usageMetadata,
+                };
+                if (responseObj.usageMetadata) {
+                    accumulateTurnUsage(responseObj.usageMetadata, model);
+                }
+            }
+            catch (error) {
+                console.error('BYOK Error:', error.message);
+                throw new Error(`BYOK AI Error: ${error.message}`);
+            }
+        }
+        else {
+            result = await proxyClient.generateFunctionCallViaProxy(idToken, model, contents, [], // no tools
+            undefined, instruction, { temperature: 0.2 });
+        }
         let textPart = '';
         if (result.parts) {
             // Use highly optimized local loop instead of array search to avoid callback allocation and naive database regex flags
@@ -340,6 +414,9 @@ export async function compressTextUsingFlashLite(text, instruction = "<directive
     }
     catch (error) {
         debugLog(`Failed to compress text using flash-lite: ${error}`);
+        if (error?.status === 401 || error?.status === 403 || error?.message?.includes('API_KEY_INVALID') || error?.message?.includes('quota')) {
+            throw new Error('AI_AUTH_ERROR: Your API key or quota is invalid. Please run /config-key or re-login.');
+        }
         return text; // fallback to raw text if compression fails
     }
 }
@@ -583,8 +660,38 @@ export async function generateChatTitle(firstMessage) {
         let model = getGlobalActiveModel();
         if (model === 'auto')
             model = GEMINI_MODELS.FLASH_LITE;
-        const result = await proxyClient.generateFunctionCallViaProxy(idToken, model, contents, [], // no tools
-        undefined, instruction, { temperature: 0.2 });
+        const byokEnabled = await isByokEnabled();
+        let result;
+        if (byokEnabled) {
+            try {
+                const creds = await loadCredentials();
+                const genAI = new GoogleGenerativeAI(creds.geminiApiKey);
+                const modelObj = genAI.getGenerativeModel({
+                    model,
+                    systemInstruction: instruction,
+                });
+                const response = await modelObj.generateContent({
+                    contents,
+                    generationConfig: { temperature: 0.2 },
+                });
+                const responseObj = await response.response;
+                result = {
+                    parts: responseObj.candidates?.[0]?.content?.parts,
+                    usageMetadata: responseObj.usageMetadata,
+                };
+                if (responseObj.usageMetadata) {
+                    accumulateTurnUsage(responseObj.usageMetadata, model);
+                }
+            }
+            catch (error) {
+                console.error('BYOK Error:', error.message);
+                throw new Error(`BYOK AI Error: ${error.message}`);
+            }
+        }
+        else {
+            result = await proxyClient.generateFunctionCallViaProxy(idToken, model, contents, [], // no tools
+            undefined, instruction, { temperature: 0.2 });
+        }
         let title = '';
         if (result.parts) {
             for (const p of result.parts) {
@@ -599,7 +706,15 @@ export async function generateChatTitle(firstMessage) {
         return title ? title : firstMessage.substring(0, maxLength);
     }
     catch (error) {
-        debugLog(`Failed to generate chat title: ${error}`);
+        debugLog(`Failed to generate chat title via BYOK: ${error}`);
+        const errorMessage = error?.message || '';
+        if (error?.status === 401 ||
+            error?.status === 403 ||
+            errorMessage.includes('API_KEY_INVALID') ||
+            errorMessage.includes('quota') ||
+            errorMessage.includes('PERMISSION_DENIED')) {
+            throw new Error('AI_BYOK_ERROR: Your API key or quota is invalid. Please run /config-key to update your settings.');
+        }
         return firstMessage.substring(0, maxLength);
     }
 }

package/dist/services/changeLogger.js

@@ -21,7 +21,7 @@ class ChangeLogger {
      * Maximum number of historical changesets retained in memory and on disk.
      * Older changesets are discarded on save once this limit is exceeded.
      */
-    MAX_HISTORY = 10;
+    MAX_HISTORY = 20;
     /**
      * Whether the change logger is currently enabled.
      */
@@ -66,7 +66,7 @@ class ChangeLogger {
         }
         writeCache(this.workspaceRoot, 'revert_state.json', {
             history: this.changeStack,
-            isEnabled: this.isEnabled
+            isEnabled: this.isEnabled,
         });
     }
     /**

package/dist/services/contextAgent.js

@@ -222,7 +222,7 @@ export async function gatherContext(workspaceRoot, userRequest, chatHistory = ''
                 cachedFiles.set(filePath, { text: readResult.output, inlineData: readResult.inlineData });
             }
         }
-        const MAX_TOTAL_FILES = 15;
+        const MAX_TOTAL_FILES = 30;
         try {
             const { resolveAndValidateMultiWorkspacePath } = await import('../utils/pathSecurity.js');
             const autoDiscovered = new Set();
@@ -255,10 +255,10 @@ export async function gatherContext(workspaceRoot, userRequest, chatHistory = ''
                 projectType,
                 summary: cacheHit.entry.summary,
                 relevantFiles: cachedFiles,
-                fromMemoryBank: true
+                fromMemoryBank: true,
             },
             targetAgent,
-            chainedMessages: []
+            chainedMessages: [],
         };
     }
     // ─── Parallel Investigation Gate ─────────────────────────────
@@ -282,9 +282,6 @@ export async function gatherContext(workspaceRoot, userRequest, chatHistory = ''
     const relevantFiles = new Map();
     let summary = 'No relevant context found.';
     let isInvestigationFinished = false;
-    const visitedToolCalls = new Set();
-    let consecutiveDuplicates = 0;
-    const MAX_CONSECUTIVE_DUPLICATES = 3;
     let chainedMessages = [];
     let webSearchSummary = '';
     // Initial prompt
@@ -336,33 +333,6 @@ export async function gatherContext(workspaceRoot, userRequest, chatHistory = ''
             if (abortSignal.aborted)
                 break;
             const args = call.args;
-            // Deduplicate identical tool calls
-            const callSignature = `${call.name}:${JSON.stringify(args)}`;
-            if (call.name !== 'finish_investigation' && visitedToolCalls.has(callSignature)) {
-                consecutiveDuplicates++;
-                if (consecutiveDuplicates >= MAX_CONSECUTIVE_DUPLICATES) {
-                    // Force-finish: the model is stuck in a loop, finalize with whatever context we have
-                    const forceMsg = `Investigation auto-completed: the model repeated the same tool call ${MAX_CONSECUTIVE_DUPLICATES} times consecutively.`;
-                    debugLog(`[Context Agent] ${forceMsg}`);
-                    if (onProgress)
-                        onProgress(forceMsg);
-                    if (!summary || summary === 'No relevant context found.') {
-                        summary = 'Investigation was auto-completed due to repeated duplicate tool calls. Review the gathered files for context.';
-                    }
-                    isFinished = true;
-                    isInvestigationFinished = relevantFiles.size > 0;
-                    break;
-                }
-                functionResponses.push({
-                    functionResponse: {
-                        name: call.name,
-                        response: { error: `DUPLICATE CALL BLOCKED (attempt ${consecutiveDuplicates}/${MAX_CONSECUTIVE_DUPLICATES}): You already executed this exact tool call. Do NOT retry it. Use the results you already have and call finish_investigation now, or try a DIFFERENT tool call with different parameters.` }
-                    }
-                });
-                continue;
-            }
-            consecutiveDuplicates = 0;
-            visitedToolCalls.add(callSignature);
             let logMsg = `  [Context Agent] Executing ${call.name}`;
             if (call.name === 'finish_investigation') {
                 const filesToRead = args.relevantFiles || [];
@@ -420,7 +390,7 @@ export async function gatherContext(workspaceRoot, userRequest, chatHistory = ''
                 // When the Context Agent finalizes its investigation, we automatically
                 // discover files that DEPEND ON the selected files. This ensures the
                 // Execution Agent won't break imports when modifying/deleting/renaming.
-                const MAX_TOTAL_FILES = 15;
+                const MAX_TOTAL_FILES = 30;
                 try {
                     const { resolveAndValidateMultiWorkspacePath } = await import('../utils/pathSecurity.js');
                     const autoDiscovered = new Set();
@@ -599,7 +569,7 @@ export async function gatherContext(workspaceRoot, userRequest, chatHistory = ''
     if (collector) {
         collector.recordContextSelectedFiles(Array.from(relevantFiles.keys()));
         if (!isInvestigationFinished || relevantFiles.size === 0) {
-            collector.recordInvestigationFailure();
+            collector?.recordInvestigationFailure?.();
         }
     }
     if (isInvestigationFinished && relevantFiles.size > 0) {