minovative-mind-cli 2.8.1 → 2.8.2

package/README.md

@@ -112,6 +112,7 @@ If you prefer to use your own API key instead of credits, you can configure it v
 
 | Command         | What it does                                                                                                                                    |
 | --------------- | ----------------------------------------------------------------------------------------------------------------------------------------------- |
+| `/config-key`   | Configure custom Google AI Studio API key (BYOK mode)                                                                                           |
 | `/models`       | Hot-swap the active model                                                                                                                       |
 | `/plan`         | Toggle plan mode to review implementation strategies                                                                                            |
 | `/paste`        | Multi-line input mode (cancel with Ctrl+C)                                                                                                      |

package/dist/commands/chat.d.ts

@@ -3,13 +3,15 @@ import { Command } from '@oclif/core';
 /**
  * @class DefaultCommand
  * @extends Command
- * @description The entry point for the "chat" CLI command. Manages user authentication,
- * environment initialization, and initializes the interactive agent loop session.
+ * @description Entry point for the "chat" CLI command. Manages user authentication,
+ * environment initialization, workspace setup, update notifications, and launches the interactive AI agent session.
  */
 export default class DefaultCommand extends Command {
     /**
      * The description displayed in the CLI help output.
-     * Details the available slash commands, chat controls, and functionality.
+     * Details all supported slash commands (/config-key, /paste, /plan, /clear, /models,
+     * /debug, /auto-approve, /sub-agents, /stats, /revert, /chats, /workspaces, /commit)
+     * along with interactive chat controls.
      */
     static description: string;
     /**

package/dist/commands/chat.js

@@ -11,31 +11,33 @@ import { updateWorkspaceStatus } from '../services/workspace.js';
 /**
  * @class DefaultCommand
  * @extends Command
- * @description The entry point for the "chat" CLI command. Manages user authentication,
- * environment initialization, and initializes the interactive agent loop session.
+ * @description Entry point for the "chat" CLI command. Manages user authentication,
+ * environment initialization, workspace setup, update notifications, and launches the interactive AI agent session.
  */
 export default class DefaultCommand extends Command {
     /**
      * The description displayed in the CLI help output.
-     * Details the available slash commands, chat controls, and functionality.
+     * Details all supported slash commands (/config-key, /paste, /plan, /clear, /models,
+     * /debug, /auto-approve, /sub-agents, /stats, /revert, /chats, /workspaces, /commit)
+     * along with interactive chat controls.
      */
     static description = `Start an interactive AI coding agent session powered by Vertex AI.
 
 Inside the chat session, you can use the following commands in the slash menu:
-  /models        - Select the active model
-  /plan          - Toggle plan mode to review implementation strategies
-  /paste         - Enter multi-line paste mode for long snippets
-  /clear         - Clear conversation history
-  /debug         - Debug tests or command execution in a sandbox loop
-  /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 — Use your own Google AI Studio API key
-  /stats         - View current session statistics and configuration
-  /commit        - Commit current workspace changes to Git
-  /revert        - Revert the last file modification made by the agent
-  /chats         - View, resume, edit titles, or delete previous chat sessions (includes bulk delete)
- 
+  /config-key    - BYOK — Configure, clear, or view status of custom Google AI Studio API key
+  /paste         - Enter multi-line paste mode for long code snippets and prompts
+  /plan          - Toggle plan mode to review step-by-step implementation strategies
+  /clear         - Clear conversation history, reset terminal screen, and display logo
+  /models        - Select or hot-swap the active Gemini model for the session
+  /debug         - Toggle internal agent telemetry, diagnostic logging, and execution state
+  /auto-approve  - Toggle automatic execution approval for shell commands and tools
+  /sub-agents    - Toggle the MMAAK Engine for parallel sub-agent task orchestration
+  /stats         - View session token usage, credits, active settings, and configurations
+  /revert        - Undo recent file modifications made by the agent or toggle change logging
+  /chats         - Resume, list, search, rename, or delete saved chat sessions
+  /workspaces    - Register and manage cross-repository aliases and active workspace paths
+  /commit        - Auto-generate Conventional Commit messages from git diff and commit
+
 Chat Controls:
   - Multi-line Input: End a line with \\ to continue on the next line
   - Stop/Abort: Type "stop" to immediately interrupt agent generation

package/dist/services/agent/inputHandler.js

@@ -190,6 +190,7 @@ export class AsyncInputHandler {
         if (process.stdin.isTTY) {
             process.stdin.setRawMode(this.originalRawMode);
         }
+        process.stdin.resume();
         this.spinner = null;
     }
     /**

package/dist/services/agent/slashCommands.d.ts

@@ -1,6 +1,9 @@
 import type { SlashCommandContext, SlashCommandResult } from './types.js';
 /**
- * Handles all slash command operations (/paste, /clear, /models, /debug, /auto-approve, /revert, /commit).
- * Returns control state to the caller loop (such as whether to continue/skip, or if a text-override occurred).
+ * Handles all interactive agent slash commands and updates session control state.
+ *
+ * @param command - The slash command string entered by the user (e.g. `/paste`, `/clear`, `/models`, `/config-key`).
+ * @param context - The execution context containing session state, active chat, input handler, and workspace paths.
+ * @returns Promise resolving to a {@link SlashCommandResult} indicating loop continuation, input overrides, or mode toggles.
  */
 export declare function handleSlashCommand(command: string, context: SlashCommandContext): Promise<SlashCommandResult>;

package/dist/services/agent/slashCommands.js

@@ -12,56 +12,42 @@ import { printLogo, brandBg, brandFg } from '../../utils/logo.js';
 import { readPaste } from '../../utils/paste.js';
 import { setApprovalMode, getApprovalMode, isSubAgentsEnabled, setSubAgentsEnabled } from '../agent-tools.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';
+/**
+ * @file slashCommands.ts
+ * @description Interactive slash command handler module for Minovative Mind CLI.
+ *
+ * Supported slash commands:
+ * - `/config-key`  : Configure, validate, toggle, or clear Bring Your Own Key (BYOK) Google AI Studio API credentials.
+ * - `/paste`       : Enter multi-line paste mode using EOF tracking (`Ctrl+D` submission).
+ * - `/plan`        : Toggle AI step-by-step implementation planning mode.
+ * - `/clear`       : Clear conversation history, wipe terminal screen, and reset CLI header.
+ * - `/models`      : Hot-swap the active generative AI model (Gemini 3.1 Pro, Gemini 3.6 Flash, Gemini 3.5 Flash-Lite, Auto routing).
+ * - `/debug`       : Toggle internal agent telemetry and diagnostic logging.
+ * - `/auto-approve`: Toggle automatic confirmation skipping for terminal shell execution commands.
+ * - `/sub-agents`  : Toggle MMAAK Engine for parallel investigation sub-agent orchestration.
+ * - `/stats`       : Display session and all-time token usage, credit balances, memory bank stats, and active configurations.
+ * - `/revert`      : Interactively inspect, revert, or toggle tracking of session file modifications via `changeLogger`.
+ * - `/chats`       : Interactive management menu to view, resume, rename, delete, or bulk-delete saved chat sessions.
+ * - `/workspaces`  : Manage primary profiles, external sub-workspaces, and `@alias/` cross-repository path mapping.
+ * - `/commit`      : Automate Conventional Commit generation using `git diff` analysis via Gemini 3.5 Flash-Lite.
+ */
 const execAsync = promisify(exec);
 /**
- * Handles all slash command operations (/paste, /clear, /models, /debug, /auto-approve, /revert, /commit).
- * Returns control state to the caller loop (such as whether to continue/skip, or if a text-override occurred).
+ * Handles all interactive agent slash commands and updates session control state.
+ *
+ * @param command - The slash command string entered by the user (e.g. `/paste`, `/clear`, `/models`, `/config-key`).
+ * @param context - The execution context containing session state, active chat, input handler, and workspace paths.
+ * @returns Promise resolving to a {@link SlashCommandResult} indicating loop continuation, input overrides, or mode toggles.
  */
 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 — Google AI Studio keys only',
-            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 Google AI Studio API Key (aistudio.google.com):',
-                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 };
-    }
+    /**
+     * `/paste` - Activates multi-line text capture using readline EOF tracking (`Ctrl+D` on an empty line).
+     */
     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)'));
         // Add space at the bottom to prevent terminal UI flickering when the cursor is at the absolute bottom
@@ -84,6 +70,9 @@ export async function handleSlashCommand(command, context) {
             return { shouldContinue: true, isRawPasteMode: false };
         }
     }
+    /**
+     * `/plan` - Toggles step-by-step AI implementation planning mode.
+     */
     if (lowerCommand === '/plan') {
         const newPlanMode = !context.isPlanMode;
         if (newPlanMode) {
@@ -94,6 +83,9 @@ export async function handleSlashCommand(command, context) {
         }
         return { shouldContinue: true, isPlanModeOverride: newPlanMode };
     }
+    /**
+     * `/clear` - Resets chat conversation history, clears the terminal screen, and reprints CLI header.
+     */
     if (lowerCommand === '/clear') {
         chat.clearHistory();
         process.stdout.write('\x1B[2J\x1B[3J\x1B[H'); // Hard clear screen and scrollback
@@ -105,6 +97,9 @@ export async function handleSlashCommand(command, context) {
         console.log(pc.dim('\nType your coding request below. Type "exit" or "quit" to leave.\n'));
         return { shouldContinue: true };
     }
+    /**
+     * `/models` - Hot-swaps the active generative AI model or enables dynamic auto-routing.
+     */
     if (lowerCommand === '/models') {
         const currentModel = getGlobalActiveModel();
         const byokEnabled = await isByokEnabled();
@@ -152,6 +147,9 @@ export async function handleSlashCommand(command, context) {
         }
         return { shouldContinue: true };
     }
+    /**
+     * `/debug` - Toggles diagnostic logging and verbose agent telemetry.
+     */
     if (lowerCommand === '/debug') {
         const debugMode = toggleDebugMode();
         if (debugMode) {
@@ -162,6 +160,9 @@ export async function handleSlashCommand(command, context) {
         }
         return { shouldContinue: true };
     }
+    /**
+     * `/auto-approve` - Toggles automatic confirmation for tool shell command execution.
+     */
     if (lowerCommand === '/auto-approve') {
         if (getApprovalMode() === 'skip-all') {
             setApprovalMode('ask');
@@ -173,6 +174,9 @@ export async function handleSlashCommand(command, context) {
         }
         return { shouldContinue: true };
     }
+    /**
+     * `/sub-agents` - Toggles the MMAAK parallel sub-agent orchestration engine.
+     */
     if (lowerCommand === '/sub-agents') {
         if (isSubAgentsEnabled()) {
             setSubAgentsEnabled(false);
@@ -184,6 +188,9 @@ export async function handleSlashCommand(command, context) {
         }
         return { shouldContinue: true };
     }
+    /**
+     * `/stats` - Displays token metrics, credit balances, session history, memory bank stats, and configuration status.
+     */
     if (lowerCommand === '/stats') {
         const latestUsage = context.chatSessionState?.latestUsageMetadata;
         const prevUsage = context.chatSessionState?.previousUsageMetadata;
@@ -331,6 +338,9 @@ export async function handleSlashCommand(command, context) {
         console.log(pc.dim('----------------------------------------\n'));
         return { shouldContinue: true };
     }
+    /**
+     * `/revert` - Interactively restores disk file snapshots or toggles change logging.
+     */
     if (lowerCommand === '/revert') {
         const isEnabled = changeLogger.getIsEnabled();
         const history = changeLogger.getHistory();
@@ -434,6 +444,9 @@ export async function handleSlashCommand(command, context) {
         }
         return { shouldContinue: true };
     }
+    /**
+     * `/chats` - Opens an interactive session manager to view, resume, rename, delete, or bulk-delete chat histories.
+     */
     if (lowerCommand === '/chats') {
         const sessions = chatHistoryService.getSessions() || [];
         const hasSessions = sessions.length > 0;
@@ -724,6 +737,9 @@ export async function handleSlashCommand(command, context) {
         }
         return { shouldContinue: true };
     }
+    /**
+     * `/workspaces` - Manages master profiles and linked external workspaces with cross-repo `@alias/` references.
+     */
     if (lowerCommand === '/workspaces') {
         const { workspaceRegistry } = await import('../workspaceRegistry.js');
         while (true) {
@@ -967,6 +983,9 @@ export async function handleSlashCommand(command, context) {
         }
         return { shouldContinue: true };
     }
+    /**
+     * `/commit` - Stages changes, generates a Conventional Commit message from `git diff`, and commits.
+     */
     if (lowerCommand === '/commit') {
         const commitSpinner = p.spinner();
         commitSpinner.start('Staging changes and analyzing diff...');
@@ -1006,6 +1025,9 @@ ${diffOut}
         }
         return { shouldContinue: true };
     }
+    /**
+     * `/config-key` - Manages Bring Your Own Key (BYOK) settings, allowing users to set, validate, toggle, or clear API keys.
+     */
     if (lowerCommand === '/config-key') {
         const creds = await loadCredentials();
         const byokEnabled = !!(creds.useByok && creds.geminiApiKey);
@@ -1040,11 +1062,9 @@ ${diffOut}
             const spinner = p.spinner();
             spinner.start('Validating API Key...');
             try {
-                // Test call to verify key
+                // Test call directly with the entered API key to verify it
                 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 });
+                await client.generateViaBYOK(key, '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);

package/dist/services/agent/types.d.ts

@@ -1,15 +1,29 @@
 import type { ProxyChatSession } from '../ai.js';
 import type { AsyncInputHandler } from './inputHandler.js';
+/**
+ * State tracking container for the active agent operational mode.
+ */
 export interface AgentState {
+    /** The target agent mode: 'CHAT' for conversational interactions or 'EXECUTE' for tool/command execution. */
     targetAgent: 'CHAT' | 'EXECUTE';
 }
+/**
+ * Context object provided to slash command handlers containing session handles, terminal state, and metadata.
+ */
 export interface SlashCommandContext {
+    /** Active AI session handle supporting message sending and model switching. */
     chat: ProxyChatSession;
+    /** Terminal input handler for async non-blocking user prompts. */
     inputHandler: AsyncInputHandler;
+    /** Absolute file system path to the active workspace root directory. */
     workspaceRoot: string;
+    /** Version string of the running CLI application. */
     version: string;
+    /** Flag indicating whether raw paste mode is currently enabled. */
     isRawPasteMode: boolean;
+    /** Flag indicating whether step-by-step implementation planning mode is currently active. */
     isPlanMode: boolean;
+    /** Session state tracking tokens, credits, usage metadata, and model turn counts. */
     chatSessionState: {
         id: string;
         title: string;
@@ -22,9 +36,16 @@ export interface SlashCommandContext {
         modelUsageCounts?: Record<string, number>;
     };
 }
+/**
+ * Result structure returned by slash command handlers to direct the main event loop.
+ */
 export interface SlashCommandResult {
+    /** Indicates whether the main agent loop should continue prompting for user input. */
     shouldContinue: boolean;
+    /** Optional input override string to submit directly to the agent (e.g., from `/paste`). */
     userInputOverride?: string;
+    /** Optional override flag to enable or disable raw paste mode. */
     isRawPasteMode?: boolean;
+    /** Optional override flag to enable or disable implementation planning mode. */
     isPlanModeOverride?: boolean;
 }

package/dist/services/agent-tools.d.ts

@@ -3,6 +3,13 @@
  * @description Implements tool declarations, approval state management, ignore rule parser,
  * atomic file operations, search/grep engines, dependency tracer, scratchpad script runner,
  * and central tool dispatcher used by the Minovative Mind AI agents.
+ *
+ * @module AgentTools
+ * @exports toolDeclarations, getToolDeclarations, getApprovalMode, setApprovalMode,
+ *          isSubAgentsEnabled, setSubAgentsEnabled, consumeSkipOnce, readFile,
+ *          writeFile, deleteFile, renameFile, modifyFile, listDirectory, runCommand,
+ *          grepSearch, traceDependencies, findRecentChanges, runDebugScript,
+ *          executeFuzzProbe, executeHeapDelta, executeBehavioralDrift, executeTool
  */
 import { type FunctionDeclaration } from '@google/generative-ai';
 /**
@@ -185,6 +192,13 @@ export declare function findRecentChanges(workspaceRoot: string, dirPath?: strin
 export declare function runDebugScript(workspaceRoot: string, language: string, code: string, abortSignal?: AbortSignal): Promise<ToolResult>;
 /**
  * Executes a fuzz probing analysis script and formats the resulting pass/fail and crash statistics.
+ *
+ * @param workspaceRoot - Absolute path to the workspace root directory.
+ * @param code - The fuzz test script or probe code to execute.
+ * @param language - Runtime environment language (defaults to `'node'`).
+ * @param config - Optional configuration parameters including iterations, maxInputLength, seed, and timeoutMs.
+ * @param abortSignal - Optional AbortSignal to cancel execution.
+ * @returns A promise resolving to a {@link ToolResult} containing fuzz run statistics and error summaries.
  */
 export declare function executeFuzzProbe(workspaceRoot: string, code: string, language?: string, config?: {
     iterations?: number;
@@ -194,6 +208,13 @@ export declare function executeFuzzProbe(workspaceRoot: string, code: string, la
 }, abortSignal?: AbortSignal): Promise<ToolResult>;
 /**
  * Executes a heap memory inspection script and formats memory consumption and growth delta metrics.
+ *
+ * @param workspaceRoot - Absolute path to the workspace root directory.
+ * @param code - The memory inspection script or code snippet to execute.
+ * @param language - Runtime environment language (defaults to `'node'`).
+ * @param config - Optional configuration parameters including warmupIterations, testIterations, samplingIntervalMs, and timeoutMs.
+ * @param abortSignal - Optional AbortSignal to cancel execution.
+ * @returns A promise resolving to a {@link ToolResult} containing memory delta statistics and leak analysis.
  */
 export declare function executeHeapDelta(workspaceRoot: string, code: string, language?: string, config?: {
     warmupIterations?: number;
@@ -203,6 +224,14 @@ export declare function executeHeapDelta(workspaceRoot: string, code: string, la
 }, abortSignal?: AbortSignal): Promise<ToolResult>;
 /**
  * Executes baseline and candidate scripts, returning output diffs and behavioral drift findings.
+ *
+ * @param workspaceRoot - Absolute path to the workspace root directory.
+ * @param baselineCode - The baseline implementation script source code.
+ * @param candidateCode - The candidate implementation script source code.
+ * @param language - Runtime environment language (defaults to `'node'`).
+ * @param config - Optional configuration parameters including tolerance, compareKeys, and timeoutMs.
+ * @param abortSignal - Optional AbortSignal to cancel execution.
+ * @returns A promise resolving to a {@link ToolResult} containing behavioral drift and diff summaries.
  */
 export declare function executeBehavioralDrift(workspaceRoot: string, baselineCode: string, candidateCode: string, language?: string, config?: {
     tolerance?: number;

package/dist/services/agent-tools.js

@@ -3,6 +3,13 @@
  * @description Implements tool declarations, approval state management, ignore rule parser,
  * atomic file operations, search/grep engines, dependency tracer, scratchpad script runner,
  * and central tool dispatcher used by the Minovative Mind AI agents.
+ *
+ * @module AgentTools
+ * @exports toolDeclarations, getToolDeclarations, getApprovalMode, setApprovalMode,
+ *          isSubAgentsEnabled, setSubAgentsEnabled, consumeSkipOnce, readFile,
+ *          writeFile, deleteFile, renameFile, modifyFile, listDirectory, runCommand,
+ *          grepSearch, traceDependencies, findRecentChanges, runDebugScript,
+ *          executeFuzzProbe, executeHeapDelta, executeBehavioralDrift, executeTool
  */
 import { exec } from 'node:child_process';
 import { promises as fs } from 'node:fs';
@@ -330,7 +337,7 @@ export const toolDeclarations = [
     },
     {
         name: 'finish_task',
-        description: 'Marks your execution as fully complete. You MUST call this tool when you have finished all tasks on your todo list and completely satisfied the user\'s request.',
+        description: "Marks your execution as fully complete. You MUST call this tool when you have finished all tasks on your todo list and completely satisfied the user's request.",
         parameters: {
             type: SchemaType.OBJECT,
             properties: {
@@ -933,7 +940,11 @@ export async function modifyFile(workspaceRoot, filePath, edits) {
                     // Provide a preview of the file to help the AI self-correct
                     const preview = modified.split('\n').slice(0, 30).join('\n');
                     const priorEditsSummary = appliedEdits.length > 0
-                        ? `\nPrior applied edits before failure:\n` + appliedEdits.map((e) => `  - Edit #${e.index}: Line ${e.line === -1 ? 'N/A' : e.line} (${e.strategy})`).join('\n') + '\n'
+                        ? `\nPrior applied edits before failure:\n` +
+                            appliedEdits
+                                .map((e) => `  - Edit #${e.index}: Line ${e.line === -1 ? 'N/A' : e.line} (${e.strategy})`)
+                                .join('\n') +
+                            '\n'
                         : '';
                     return {
                         output: '',
@@ -991,7 +1002,10 @@ export async function modifyFile(workspaceRoot, filePath, edits) {
                 }
                 if (!success) {
                     const appliedSummary = appliedEdits.length > 0
-                        ? `\nApplied edit details:\n` + appliedEdits.map((e) => `  - Edit #${e.index}: Line ${e.line === -1 ? 'N/A' : e.line} (${e.strategy})`).join('\n')
+                        ? `\nApplied edit details:\n` +
+                            appliedEdits
+                                .map((e) => `  - Edit #${e.index}: Line ${e.line === -1 ? 'N/A' : e.line} (${e.strategy})`)
+                                .join('\n')
                         : '';
                     return {
                         output: '',
@@ -1033,6 +1047,13 @@ export async function listDirectory(workspaceRoot, dirPath, maxDepth = 3) {
         const absPath = resolveAndValidatePath(workspaceRoot, dirPath);
         const lines = [];
         const { ig } = await getIgnoredPaths(workspaceRoot);
+        /**
+         * Recursively walks directory entries to construct an ASCII tree structure.
+         *
+         * @param currentPath - Absolute path to the current directory being traversed.
+         * @param prefix - Current tree branch indentation prefix.
+         * @param depth - Current recursion depth.
+         */
         async function walk(currentPath, prefix, depth) {
             if (depth > maxDepth)
                 return;
@@ -1146,6 +1167,11 @@ export async function grepSearch(workspaceRoot, pattern, fileGlob, fixedStrings,
         // Use ignore package to evaluate path globs (e.g. src/**/*.ts)
         const globMatcher = fileGlob ? ignore().add(fileGlob) : null;
         const results = [];
+        /**
+         * Recursively walks directory entries to search for pattern matches.
+         *
+         * @param dir - Absolute path to the current directory being searched.
+         */
         async function walk(dir) {
             if (results.length >= 50)
                 return;
@@ -1255,6 +1281,12 @@ export async function findRecentChanges(workspaceRoot, dirPath = '.', minutes =
         const { ig } = await getIgnoredPaths(workspaceRoot);
         const thresholdMs = Date.now() - minutes * 60 * 1000;
         const recentFiles = [];
+        /**
+         * Recursively walks directory entries to identify recently modified files.
+         *
+         * @param currentPath - Absolute path to the current directory being checked.
+         * @param depth - Current recursion depth.
+         */
         async function walk(currentPath, depth) {
             if (depth > maxDepth)
                 return;
@@ -1418,6 +1450,13 @@ export async function runDebugScript(workspaceRoot, language, code, abortSignal)
 }
 /**
  * Executes a fuzz probing analysis script and formats the resulting pass/fail and crash statistics.
+ *
+ * @param workspaceRoot - Absolute path to the workspace root directory.
+ * @param code - The fuzz test script or probe code to execute.
+ * @param language - Runtime environment language (defaults to `'node'`).
+ * @param config - Optional configuration parameters including iterations, maxInputLength, seed, and timeoutMs.
+ * @param abortSignal - Optional AbortSignal to cancel execution.
+ * @returns A promise resolving to a {@link ToolResult} containing fuzz run statistics and error summaries.
  */
 export async function executeFuzzProbe(workspaceRoot, code, language = 'node', config, abortSignal) {
     try {
@@ -1451,6 +1490,13 @@ export async function executeFuzzProbe(workspaceRoot, code, language = 'node', c
 }
 /**
  * Executes a heap memory inspection script and formats memory consumption and growth delta metrics.
+ *
+ * @param workspaceRoot - Absolute path to the workspace root directory.
+ * @param code - The memory inspection script or code snippet to execute.
+ * @param language - Runtime environment language (defaults to `'node'`).
+ * @param config - Optional configuration parameters including warmupIterations, testIterations, samplingIntervalMs, and timeoutMs.
+ * @param abortSignal - Optional AbortSignal to cancel execution.
+ * @returns A promise resolving to a {@link ToolResult} containing memory delta statistics and leak analysis.
  */
 export async function executeHeapDelta(workspaceRoot, code, language = 'node', config, abortSignal) {
     try {
@@ -1487,6 +1533,14 @@ export async function executeHeapDelta(workspaceRoot, code, language = 'node', c
 }
 /**
  * Executes baseline and candidate scripts, returning output diffs and behavioral drift findings.
+ *
+ * @param workspaceRoot - Absolute path to the workspace root directory.
+ * @param baselineCode - The baseline implementation script source code.
+ * @param candidateCode - The candidate implementation script source code.
+ * @param language - Runtime environment language (defaults to `'node'`).
+ * @param config - Optional configuration parameters including tolerance, compareKeys, and timeoutMs.
+ * @param abortSignal - Optional AbortSignal to cancel execution.
+ * @returns A promise resolving to a {@link ToolResult} containing behavioral drift and diff summaries.
  */
 export async function executeBehavioralDrift(workspaceRoot, baselineCode, candidateCode, language = 'node', config, abortSignal) {
     try {
@@ -1626,7 +1680,7 @@ export async function executeTool(workspaceRoot, toolName, args, abortSignal) {
     // Normalize common LLM tool alias hallucinations to registered tool names
     let normalizedToolName = toolName;
     if (normalizedToolName === 'search' || normalizedToolName === 'web_search') {
-        normalizedToolName = (args.query || args.searchQuery || args.url) ? 'perform_web_search' : 'grep_search';
+        normalizedToolName = args.query || args.searchQuery || args.url ? 'perform_web_search' : 'grep_search';
     }
     else if (normalizedToolName === 'grep' || normalizedToolName === 'search_codebase') {
         normalizedToolName = 'grep_search';

package/dist/services/ai.js

@@ -1,4 +1,4 @@
-import { GoogleGenerativeAI, SchemaType, } from '@google/generative-ai';
+import { SchemaType, } from '@google/generative-ai';
 import { GEMINI_MODELS, DEFAULT_MODEL, MAX_OUTPUT_TOKENS, isByokEnabled } from '../utils/config.js';
 import { getToolDeclarations } from './agent-tools.js';
 import { getMetricCollector } from './metrics.js';
@@ -8,7 +8,7 @@ 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, HISTORY_SUMMARIZER_SYSTEM_INSTRUCTION, } from '../utils/systemPrompts.js';
 import { workspaceRegistry } from './workspaceRegistry.js';
 import { loadCredentials } from '../utils/credentialStore.js';
-import { ProxyClient, accumulateTurnUsage } from './proxyClient.js';
+import { ProxyClient } from './proxyClient.js';
 function getMultiWorkspaceBlock() {
     const summary = workspaceRegistry.buildPromptSummary();
     const primaryRoot = process.cwd();
@@ -232,42 +232,9 @@ export class ProxyChatSession {
         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;
-            }
+            result = await proxyClient.generateViaBYOK(creds.geminiApiKey, this.modelName, this.history, this.tools, undefined, // toolConfig
+            this.systemInstruction, effectiveGenerationConfig, onChunk ? { onChunk } : undefined, // streamCallbacks
+            abortSignal);
         }
         else {
             result = await proxyClient.generateFunctionCallViaProxy(idToken, this.modelName, this.history, this.tools, undefined, // toolConfig
@@ -390,30 +357,9 @@ export async function compressTextUsingFlashLite(text, instruction = "<directive
         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}`);
-            }
+            const creds = await loadCredentials();
+            result = await proxyClient.generateViaBYOK(creds.geminiApiKey, model, contents, [], // no tools
+            undefined, instruction, { temperature: 0.2 });
         }
         else {
             result = await proxyClient.generateFunctionCallViaProxy(idToken, model, contents, [], // no tools
@@ -680,30 +626,9 @@ export async function generateChatTitle(firstMessage) {
         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}`);
-            }
+            const creds = await loadCredentials();
+            result = await proxyClient.generateViaBYOK(creds.geminiApiKey, model, contents, [], // no tools
+            undefined, instruction, { temperature: 0.2 });
         }
         else {
             result = await proxyClient.generateFunctionCallViaProxy(idToken, model, contents, [], // no tools

package/dist/services/orchestration/orchestrator.js

@@ -83,7 +83,7 @@ export class Orchestrator {
      *          was too simple and should be handled by the main agent loop.
      */
     async runOrchestration(objective, contextInjection, signal) {
-        p.log.step(pc.cyan('Orchestrator: Planning task execution...'));
+        p.log.step(pc.cyan('Orchestrator: Planning task execution'));
         // 1. Task Decomposition
         const graph = await this.decomposeTask(objective, contextInjection, signal);
         if (!graph)
@@ -110,13 +110,13 @@ export class Orchestrator {
             p.log.step(pc.magenta(`Starting Wave ${wave.depth + 1} (${wave.taskIds.length} tasks):\n${taskDescriptions}`));
             const s = p.spinner();
             this.inputHandler.setSpinner(s);
-            s.start(`Executing Wave ${wave.depth + 1}...`);
+            s.start(`Executing Wave ${wave.depth + 1}`);
             const agentStatuses = new Map();
             const updateSpinner = () => {
                 const statuses = Array.from(agentStatuses.entries())
                     .map(([id, status]) => `${pc.cyan(id)}: ${pc.dim(status)}`)
                     .join(' │ ');
-                s.message(statuses || `Executing Wave ${wave.depth + 1}...`);
+                s.message(statuses || `Executing Wave ${wave.depth + 1}`);
             };
             // Limit to 2 concurrent sub-agents to avoid Vertex AI RESOURCE_EXHAUSTED
             const results = [];
@@ -127,7 +127,7 @@ export class Orchestrator {
                 const wavePromises = chunk.map((taskId) => {
                     const taskDef = graph.tasks.find((t) => t.id === taskId);
                     const globalContext = `Objective:\n${objective}\n\nContext:\n${contextInjection}`;
-                    agentStatuses.set(taskDef.id, 'Starting...');
+                    agentStatuses.set(taskDef.id, 'Starting');
                     updateSpinner();
                     const onToolCall = (msg) => {
                         const formattedLog = `${pc.dim(`[${taskDef.id}]`)} ${msg}`;
@@ -151,7 +151,7 @@ export class Orchestrator {
             const successful = results.filter((r) => r.success).length;
             s.stop(`Wave ${wave.depth + 1} completed: ${successful}/${wave.taskIds.length} tasks succeeded`);
             if (toolLogs.length > 0) {
-                toolLogs.forEach(log => p.log.step(log));
+                toolLogs.forEach((log) => p.log.step(log));
             }
             // Post-wave evaluation
             const failedCount = results.filter((r) => !r.success).length;
@@ -200,7 +200,7 @@ export class Orchestrator {
                     }
                     else {
                         // JSON parsing error or InvalidDependencyError
-                        debugLog(`PM Agent generated invalid graph: ${err.message}. Retrying...`);
+                        debugLog(`PM Agent generated invalid graph: ${err.message}. Retrying`);
                         result = await this.pmChat.sendMessage(`Invalid JSON or missing dependency ID: ${err.message}. Please fix.`, undefined, signal);
                         if (signal.aborted)
                             return null;
@@ -246,7 +246,7 @@ export class Orchestrator {
      * Final reconciliation phase after all waves complete.
      */
     async reconcile(graph) {
-        p.log.step(pc.cyan('Orchestrator: Reconciling results...'));
+        p.log.step(pc.cyan('Orchestrator: Reconciling results'));
         const stats = this.bus.getStats();
         let totalTokens = 0;
         let inputTokens = 0;
@@ -259,10 +259,10 @@ export class Orchestrator {
             outputTokens += res.outputTokens || 0;
             if (!res.success)
                 failedTasks++;
-            debugLog(`Task ${taskId} summary: ${res.summary.substring(0, 100)}...`);
+            debugLog(`Task ${taskId} summary: ${res.summary.substring(0, 100)}`);
             rawSummaryData += `Task: ${taskId} | Status: ${res.success ? 'Success' : 'Failed'}\nChanges:\n${res.summary}\n\n`;
         }
-        p.log.step(pc.cyan('Orchestrator: Synthesizing final changes overview...'));
+        p.log.step(pc.cyan('Orchestrator: Synthesizing final changes overview'));
         let finalSummary = '';
         try {
             const payloadWithContext = `<original_request>\n${graph.objective}\n</original_request>\n\n<task_summaries>\n${rawSummaryData}\n</task_summaries>`;

package/dist/services/proxyClient.d.ts

@@ -72,4 +72,18 @@ export declare class ProxyClient {
         usageMetadata?: ProxyUsageMetadata;
         groundingMetadata?: any;
     }>;
+    /**
+     * Generates text, thoughts, or function calls directly via Google's official Gemini REST API (BYOK mode).
+     * Ensures identical return structure and standard role mapping parity with proxy mode.
+     */
+    generateViaBYOK(apiKey: string, modelName: string, contents: Content[], tools?: Tool[], toolConfig?: ToolConfig, systemInstruction?: string | Content, generationConfig?: any, streamCallbacks?: {
+        onChunk: (chunk: string) => void;
+    }, abortSignal?: AbortSignal): Promise<{
+        functionCall: FunctionCall | null;
+        functionCalls: FunctionCall[];
+        thought?: string;
+        parts?: any[];
+        usageMetadata?: ProxyUsageMetadata;
+        groundingMetadata?: any;
+    }>;
 }

package/dist/services/proxyClient.js

@@ -114,11 +114,11 @@ export class ProxyClient {
                 signal: abortSignal,
             });
             debugLog(`Proxy Request to ${modelName} complete. Status: ${response.status} ${response.statusText}`);
-            if ((response.status === 429 || response.status === 503) && attempt < MAX_RETRIES) {
+            if ((response.status === 429 || response.status === 503 || response.status === 502 || response.status === 500 || response.status === 504) && attempt < MAX_RETRIES) {
                 const exponentialDelay = Math.min(MAX_DELAY_MS, BASE_DELAY_MS * Math.pow(2, attempt));
-                const delayTime = Math.round(exponentialDelay * (0.5 + Math.random() * 0.5));
+                const delayTime = Math.round(exponentialDelay * (1.0 + Math.random() * 0.5));
                 process.stdout.write('\n');
-                console.warn(`Rate limit or service unavailable hit (${response.status}). Retrying in ${(delayTime / 1000).toFixed(1)}s... (Attempt ${attempt + 1}/${MAX_RETRIES})`);
+                console.warn(`Server error or rate limit hit (${response.status}). Retrying in ${(delayTime / 1000).toFixed(1)}s... (Attempt ${attempt + 1}/${MAX_RETRIES})`);
                 await delay(delayTime, abortSignal);
                 attempt++;
                 continue;
@@ -232,14 +232,18 @@ export class ProxyClient {
             }
             catch (streamError) {
                 if (streamError.message?.includes('429') ||
+                    streamError.message?.includes('502') ||
                     streamError.message?.includes('503') ||
+                    streamError.message?.includes('500') ||
+                    streamError.message?.includes('504') ||
+                    streamError.message?.includes('Bad Gateway') ||
                     streamError.message?.includes('RESOURCE_EXHAUSTED') ||
                     streamError.message?.includes('Too Many Requests')) {
                     if (attempt < MAX_RETRIES) {
                         const exponentialDelay = Math.min(MAX_DELAY_MS, BASE_DELAY_MS * Math.pow(2, attempt));
-                        const delayTime = Math.round(exponentialDelay * (0.5 + Math.random() * 0.5));
+                        const delayTime = Math.round(exponentialDelay * (1.0 + Math.random() * 0.5));
                         process.stdout.write('\n');
-                        console.warn(`Rate limit or service unavailable hit during stream. Retrying in ${(delayTime / 1000).toFixed(1)}s... (Attempt ${attempt + 1}/${MAX_RETRIES})`);
+                        console.warn(`Server error or rate limit hit during stream. Retrying in ${(delayTime / 1000).toFixed(1)}s... (Attempt ${attempt + 1}/${MAX_RETRIES})`);
                         await delay(delayTime, abortSignal);
                         attempt++;
                         continue retryLoop;
@@ -260,4 +264,179 @@ export class ProxyClient {
             };
         }
     }
+    /**
+     * Generates text, thoughts, or function calls directly via Google's official Gemini REST API (BYOK mode).
+     * Ensures identical return structure and standard role mapping parity with proxy mode.
+     */
+    async generateViaBYOK(apiKey, modelName, contents, tools, toolConfig, systemInstruction, generationConfig, streamCallbacks, abortSignal) {
+        const isStreaming = Boolean(streamCallbacks?.onChunk);
+        const endpoint = isStreaming ? 'streamGenerateContent?alt=sse&key=' : 'generateContent?key=';
+        const url = `https://generativelanguage.googleapis.com/v1beta/models/${encodeURIComponent(modelName)}:${endpoint}${encodeURIComponent(apiKey)}`;
+        const formattedSystemInstruction = typeof systemInstruction === 'string' ? { parts: [{ text: systemInstruction }] } : systemInstruction;
+        const payload = { contents };
+        if (tools && tools.length > 0)
+            payload.tools = tools;
+        if (toolConfig)
+            payload.toolConfig = toolConfig;
+        if (formattedSystemInstruction)
+            payload.systemInstruction = formattedSystemInstruction;
+        if (generationConfig)
+            payload.generationConfig = generationConfig;
+        const MAX_RETRIES = 5;
+        const BASE_DELAY_MS = 2000;
+        const MAX_DELAY_MS = 30000;
+        let attempt = 0;
+        while (true) {
+            const response = await fetch(url, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify(payload),
+                signal: abortSignal,
+            });
+            debugLog(`BYOK Request to ${modelName} complete. Status: ${response.status} ${response.statusText}`);
+            if ((response.status === 429 ||
+                response.status === 503 ||
+                response.status === 502 ||
+                response.status === 500 ||
+                response.status === 504) &&
+                attempt < MAX_RETRIES) {
+                const exponentialDelay = Math.min(MAX_DELAY_MS, BASE_DELAY_MS * Math.pow(2, attempt));
+                const delayTime = Math.round(exponentialDelay * (1.0 + Math.random() * 0.5));
+                process.stdout.write('\n');
+                console.warn(`Server error or rate limit hit (${response.status}). Retrying in ${(delayTime / 1000).toFixed(1)}s... (Attempt ${attempt + 1}/${MAX_RETRIES})`);
+                await delay(delayTime, abortSignal);
+                attempt++;
+                continue;
+            }
+            if (!response.ok) {
+                let errorData = {};
+                try {
+                    errorData = await response.json();
+                }
+                catch {
+                    // ignore parsing error
+                }
+                const errorMsg = errorData.error?.message || response.statusText;
+                if (response.status === 400 ||
+                    response.status === 401 ||
+                    response.status === 403 ||
+                    errorMsg.includes('API_KEY_INVALID') ||
+                    errorMsg.includes('quota') ||
+                    errorMsg.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 new Error(`BYOK API Error ${response.status}: ${errorMsg}`);
+            }
+            let functionCall = null;
+            const functionCalls = [];
+            let thought = '';
+            let parts = undefined;
+            let usageMetadata = undefined;
+            let groundingMetadata = undefined;
+            if (isStreaming) {
+                if (!response.body)
+                    throw new Error('No response body received from BYOK API endpoint');
+                const reader = response.body.getReader();
+                const decoder = new TextDecoder();
+                let buffer = '';
+                try {
+                    while (true) {
+                        const { done, value } = await reader.read();
+                        if (done)
+                            break;
+                        buffer += decoder.decode(value, { stream: true });
+                        const lines = buffer.split('\n\n');
+                        buffer = lines.pop() || '';
+                        for (const line of lines) {
+                            if (!line.startsWith('data: '))
+                                continue;
+                            const dataStr = line.slice(6).trim();
+                            if (!dataStr)
+                                continue;
+                            try {
+                                const data = JSON.parse(dataStr);
+                                const candidate = data.candidates?.[0];
+                                if (candidate?.content?.parts) {
+                                    parts = candidate.content.parts;
+                                    for (const part of candidate.content.parts) {
+                                        if (part.text) {
+                                            thought += part.text;
+                                            if (streamCallbacks?.onChunk)
+                                                streamCallbacks.onChunk(part.text);
+                                        }
+                                        if (part.functionCall) {
+                                            functionCall = part.functionCall;
+                                            functionCalls.push(part.functionCall);
+                                        }
+                                    }
+                                }
+                                if (candidate?.groundingMetadata) {
+                                    groundingMetadata = candidate.groundingMetadata;
+                                }
+                                if (data.usageMetadata) {
+                                    const pTokens = data.usageMetadata.promptTokenCount || 0;
+                                    const cTokens = data.usageMetadata.candidatesTokenCount || 0;
+                                    const cachedTokens = data.usageMetadata.cachedContentTokenCount || 0;
+                                    usageMetadata = {
+                                        promptTokens: pTokens,
+                                        candidatesTokens: cTokens,
+                                        cachedTokens: cachedTokens,
+                                        creditsUsed: 0,
+                                        remainingBalance: 0,
+                                    };
+                                    accumulateTurnUsage(data.usageMetadata, modelName);
+                                }
+                            }
+                            catch (parseError) {
+                                debugLog(`Failed to parse BYOK SSE data: ${dataStr} - Error: ${parseError.message || parseError}`);
+                            }
+                        }
+                    }
+                }
+                finally {
+                    reader.releaseLock();
+                }
+            }
+            else {
+                const data = await response.json();
+                const candidate = data.candidates?.[0];
+                if (candidate?.content?.parts) {
+                    parts = candidate.content.parts;
+                    for (const part of candidate.content.parts) {
+                        if (part.text) {
+                            thought += part.text;
+                        }
+                        if (part.functionCall) {
+                            functionCall = part.functionCall;
+                            functionCalls.push(part.functionCall);
+                        }
+                    }
+                }
+                if (candidate?.groundingMetadata) {
+                    groundingMetadata = candidate.groundingMetadata;
+                }
+                if (data.usageMetadata) {
+                    const pTokens = data.usageMetadata.promptTokenCount || 0;
+                    const cTokens = data.usageMetadata.candidatesTokenCount || 0;
+                    const cachedTokens = data.usageMetadata.cachedContentTokenCount || 0;
+                    usageMetadata = {
+                        promptTokens: pTokens,
+                        candidatesTokens: cTokens,
+                        cachedTokens: cachedTokens,
+                        creditsUsed: 0,
+                        remainingBalance: 0,
+                    };
+                    accumulateTurnUsage(data.usageMetadata, modelName);
+                }
+            }
+            return {
+                functionCall,
+                functionCalls,
+                thought: thought.trim(),
+                parts,
+                usageMetadata,
+                groundingMetadata,
+            };
+        }
+    }
 }

package/dist/utils/config.d.ts

@@ -32,9 +32,9 @@ export declare const MAX_OUTPUT_TOKENS = 60000;
  */
 export declare const TPM_COOLING_DELAYS: {
     /** Pause before running initial intent routing between turns */
-    readonly INTER_TURN_MS: 1000;
+    readonly INTER_TURN_MS: 3000;
     /** Pause before dispatching parallel sub-agent investigations simultaneously */
-    readonly PARALLEL_DISPATCH_MS: 1000;
+    readonly PARALLEL_DISPATCH_MS: 3000;
     /** Pause after context gathering completes before starting the execution stream */
     readonly POST_INVESTIGATION_MS: 3000;
 };

package/dist/utils/config.js

@@ -32,9 +32,9 @@ export const MAX_OUTPUT_TOKENS = 60_000;
  */
 export const TPM_COOLING_DELAYS = {
     /** Pause before running initial intent routing between turns */
-    INTER_TURN_MS: 1000,
+    INTER_TURN_MS: 3000,
     /** Pause before dispatching parallel sub-agent investigations simultaneously */
-    PARALLEL_DISPATCH_MS: 1000,
+    PARALLEL_DISPATCH_MS: 3000,
     /** Pause after context gathering completes before starting the execution stream */
     POST_INVESTIGATION_MS: 3000,
 };

package/dist/utils/localSyntaxValidator.js

@@ -115,7 +115,6 @@ export function localValidate(filePath, content) {
         '?',
         ':',
         '<',
-        '>',
         '/',
         '=>',
         '${',
@@ -227,10 +226,13 @@ export function localValidate(filePath, content) {
             continue;
         }
         // Check for regex literal start
-        if (isJsTs && char === '/') {
+        if (isJsTs && char === '/' && nextChar !== '>') {
             // Determine if '/' starts a regex or is a division operator
             const prevToken = currentWord || lastToken;
-            const isExpr = !prevToken || EXPR_KEYWORDS.has(prevToken) || EXPR_PUNCT.has(prevToken);
+            const isExpr = prevToken !== '<' &&
+                prevToken !== '}' &&
+                prevToken !== '>' &&
+                (!prevToken || EXPR_KEYWORDS.has(prevToken) || EXPR_PUNCT.has(prevToken));
             if (isExpr) {
                 inRegex = true;
                 inRegexCharClass = false;

package/dist/utils/paste.js

@@ -22,24 +22,42 @@ import * as readline from 'node:readline';
  */
 export async function readPaste() {
     return new Promise((resolve) => {
+        if (process.stdin.isTTY) {
+            process.stdin.setRawMode(false);
+        }
+        process.stdin.resume();
         const rl = readline.createInterface({
             input: process.stdin,
             output: process.stdout,
             terminal: true,
         });
+        rl.setPrompt('');
+        rl.prompt();
         const content = [];
         let isCanceled = false;
+        let cleanedUp = false;
+        const cleanup = () => {
+            if (cleanedUp)
+                return;
+            cleanedUp = true;
+            rl.close();
+            if (process.stdin.isTTY) {
+                process.stdin.setRawMode(false);
+            }
+        };
         rl.on('line', (line) => {
             content.push(line);
+            rl.prompt();
         });
         rl.on('close', () => {
+            cleanup();
             if (!isCanceled) {
                 resolve(content.join('\n').trim());
             }
         });
         rl.on('SIGINT', () => {
             isCanceled = true;
-            rl.close();
+            cleanup();
             resolve(null);
         });
     });

package/oclif.manifest.json

@@ -3,7 +3,7 @@
     "chat": {
       "aliases": [],
       "args": {},
-      "description": "Start an interactive AI coding agent session powered by Vertex AI.\n\nInside the chat session, you can use the following commands in the slash menu:\n  /models        - Select the active model\n  /plan          - Toggle plan mode to review implementation strategies\n  /paste         - Enter multi-line paste mode for long snippets\n  /clear         - Clear conversation history\n  /debug         - Debug tests or command execution in a sandbox loop\n  /auto-approve  - Toggle automatic approval of tool/command runs\n  /sub-agents    - Toggle the MMAAK Engine for parallel investigation and execution\n  /workspaces    - Manage external workspaces for cross-project development\n  /config-key    - BYOK — Use your own Google AI Studio API key\n  /stats         - View current session statistics and configuration\n  /commit        - Commit current workspace changes to Git\n  /revert        - Revert the last file modification made by the agent\n  /chats         - View, resume, edit titles, or delete previous chat sessions (includes bulk delete)\n \nChat Controls:\n  - Multi-line Input: End a line with \\ to continue on the next line\n  - Stop/Abort: Type \"stop\" to immediately interrupt agent generation\n  - Exit Session: Type \"exit\" or \"quit\" to end the agent session",
+      "description": "Start an interactive AI coding agent session powered by Vertex AI.\n\nInside the chat session, you can use the following commands in the slash menu:\n  /config-key    - BYOK — Configure, clear, or view status of custom Google AI Studio API key\n  /paste         - Enter multi-line paste mode for long code snippets and prompts\n  /plan          - Toggle plan mode to review step-by-step implementation strategies\n  /clear         - Clear conversation history, reset terminal screen, and display logo\n  /models        - Select or hot-swap the active Gemini model for the session\n  /debug         - Toggle internal agent telemetry, diagnostic logging, and execution state\n  /auto-approve  - Toggle automatic execution approval for shell commands and tools\n  /sub-agents    - Toggle the MMAAK Engine for parallel sub-agent task orchestration\n  /stats         - View session token usage, credits, active settings, and configurations\n  /revert        - Undo recent file modifications made by the agent or toggle change logging\n  /chats         - Resume, list, search, rename, or delete saved chat sessions\n  /workspaces    - Register and manage cross-repository aliases and active workspace paths\n  /commit        - Auto-generate Conventional Commit messages from git diff and commit\n\nChat Controls:\n  - Multi-line Input: End a line with \\ to continue on the next line\n  - Stop/Abort: Type \"stop\" to immediately interrupt agent generation\n  - Exit Session: Type \"exit\" or \"quit\" to end the agent session",
       "examples": [
         "<%= config.bin %> chat",
         "<%= config.bin %> chat --help"
@@ -65,5 +65,5 @@
       ]
     }
   },
-  "version": "2.8.1"
+  "version": "2.8.2"
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "minovative-mind-cli",
   "description": "An automated AI agent powered by Vertex AI that helps you write software",
-  "version": "2.8.1",
+  "version": "2.8.2",
   "author": "Daniel Ward",
   "bin": {
     "minovative-mind-cli": "bin/run.js"