minovative-mind-cli 1.5.1 → 2.0.0

package/dist/services/orchestration/readCache.d.ts

@@ -0,0 +1,79 @@
+/**
+ * @fileoverview Shared Read Cache for Parallel Investigation.
+ *
+ * A lightweight in-memory cache that investigation sub-agents use to avoid
+ * redundant file reads. When multiple agents are investigating different
+ * domains simultaneously, they frequently encounter overlapping files
+ * (e.g., shared types, config files, package.json). The ReadCache ensures
+ * each file is read from disk exactly once.
+ *
+ * Design decisions:
+ * - **Separate from MessageBus**: The full message bus provides semantic
+ *   signals, activity logs, and disk persistence — all overkill for read-only
+ *   agents. ReadCache is a simple `Map<string, string>` with LRU eviction.
+ * - **Thread-safe by default**: Node.js is single-threaded, so `Map` ops
+ *   are atomic. No locking needed.
+ * - **Memory-bounded**: Total cached content is capped at MAX_CACHE_BYTES
+ *   to prevent OOM on very large monorepos.
+ */
+/**
+ * In-memory file content cache shared across parallel investigation agents.
+ *
+ * Usage:
+ * ```ts
+ * const cache = new ReadCache()
+ * // In tool wrapper:
+ * if (cache.has(filePath)) return cache.get(filePath)!
+ * const content = await fs.readFile(absPath, 'utf-8')
+ * cache.set(filePath, content)
+ * ```
+ */
+export declare class ReadCache {
+    private cache;
+    private insertionOrder;
+    private totalBytes;
+    private hitCount;
+    private missCount;
+    /**
+     * Checks whether a file's content is already cached.
+     * @param filePath - Relative file path from workspace root.
+     */
+    has(filePath: string): boolean;
+    /**
+     * Retrieves cached content for a file.
+     * @param filePath - Relative file path from workspace root.
+     * @returns The file content, or undefined if not cached.
+     */
+    get(filePath: string): {
+        text: string;
+        inlineData?: any;
+    } | undefined;
+    /**
+     * Stores file content in the cache. If adding this entry would exceed
+     * the memory cap, older entries are evicted in insertion order (LRU).
+     *
+     * @param filePath - Relative file path from workspace root.
+     * @param content - The file's text content.
+     */
+    set(filePath: string, content: {
+        text: string;
+        inlineData?: any;
+    }): void;
+    /**
+     * Returns all cached file entries. Used by the Reducer to assemble
+     * the merged file set without re-reading from disk.
+     */
+    getAll(): Map<string, {
+        text: string;
+        inlineData?: any;
+    }>;
+    /**
+     * Returns diagnostic statistics for terminal display.
+     */
+    getStats(): {
+        hitCount: number;
+        missCount: number;
+        fileCount: number;
+        totalBytes: number;
+    };
+}

package/dist/services/orchestration/readCache.js

@@ -0,0 +1,108 @@
+/**
+ * @fileoverview Shared Read Cache for Parallel Investigation.
+ *
+ * A lightweight in-memory cache that investigation sub-agents use to avoid
+ * redundant file reads. When multiple agents are investigating different
+ * domains simultaneously, they frequently encounter overlapping files
+ * (e.g., shared types, config files, package.json). The ReadCache ensures
+ * each file is read from disk exactly once.
+ *
+ * Design decisions:
+ * - **Separate from MessageBus**: The full message bus provides semantic
+ *   signals, activity logs, and disk persistence — all overkill for read-only
+ *   agents. ReadCache is a simple `Map<string, string>` with LRU eviction.
+ * - **Thread-safe by default**: Node.js is single-threaded, so `Map` ops
+ *   are atomic. No locking needed.
+ * - **Memory-bounded**: Total cached content is capped at MAX_CACHE_BYTES
+ *   to prevent OOM on very large monorepos.
+ */
+import { debugLog } from '../../utils/logger.js';
+// ─── Constants ───────────────────────────────────────────────────────
+/** Maximum total bytes of cached file content before LRU eviction kicks in. */
+const MAX_CACHE_BYTES = 5 * 1024 * 1024; // 5 MB
+// ─── Read Cache Implementation ───────────────────────────────────────
+/**
+ * In-memory file content cache shared across parallel investigation agents.
+ *
+ * Usage:
+ * ```ts
+ * const cache = new ReadCache()
+ * // In tool wrapper:
+ * if (cache.has(filePath)) return cache.get(filePath)!
+ * const content = await fs.readFile(absPath, 'utf-8')
+ * cache.set(filePath, content)
+ * ```
+ */
+export class ReadCache {
+    cache = new Map();
+    insertionOrder = [];
+    totalBytes = 0;
+    hitCount = 0;
+    missCount = 0;
+    /**
+     * Checks whether a file's content is already cached.
+     * @param filePath - Relative file path from workspace root.
+     */
+    has(filePath) {
+        const found = this.cache.has(filePath);
+        if (found) {
+            this.hitCount++;
+        }
+        else {
+            this.missCount++;
+        }
+        return found;
+    }
+    /**
+     * Retrieves cached content for a file.
+     * @param filePath - Relative file path from workspace root.
+     * @returns The file content, or undefined if not cached.
+     */
+    get(filePath) {
+        return this.cache.get(filePath);
+    }
+    /**
+     * Stores file content in the cache. If adding this entry would exceed
+     * the memory cap, older entries are evicted in insertion order (LRU).
+     *
+     * @param filePath - Relative file path from workspace root.
+     * @param content - The file's text content.
+     */
+    set(filePath, content) {
+        // Don't re-insert if already cached
+        if (this.cache.has(filePath))
+            return;
+        const entryBytes = Buffer.byteLength(content.text, 'utf-8');
+        // Evict oldest entries until there is room
+        while (this.totalBytes + entryBytes > MAX_CACHE_BYTES && this.insertionOrder.length > 0) {
+            const oldest = this.insertionOrder.shift();
+            const evicted = this.cache.get(oldest);
+            if (evicted !== undefined) {
+                this.totalBytes -= Buffer.byteLength(evicted.text, 'utf-8');
+                this.cache.delete(oldest);
+                debugLog(`ReadCache: Evicted "${oldest}" to stay under ${MAX_CACHE_BYTES} byte cap.`);
+            }
+        }
+        this.cache.set(filePath, content);
+        this.insertionOrder.push(filePath);
+        this.totalBytes += entryBytes;
+    }
+    /**
+     * Returns all cached file entries. Used by the Reducer to assemble
+     * the merged file set without re-reading from disk.
+     */
+    getAll() {
+        return new Map(this.cache);
+    }
+    /**
+     * Returns diagnostic statistics for terminal display.
+     */
+    getStats() {
+        return {
+            hitCount: this.hitCount,
+            missCount: this.missCount,
+            fileCount: this.cache.size,
+            totalBytes: this.totalBytes,
+        };
+    }
+}

package/dist/services/orchestration/scopedTools.d.ts

@@ -0,0 +1,57 @@
+import { MessageBus } from './messageBus.js';
+import { FileLockRegistry } from './fileLockRegistry.js';
+/**
+ * Extended tool declarations for sub-agents, merging the standard tools
+ * with orchestration-specific ones (e.g., post_message, read_messages).
+ */
+export declare function getScopedToolDeclarations(): (import("@google/generative-ai").FunctionDeclaration | {
+    name: string;
+    description: string;
+    parameters: {
+        type: string;
+        properties: {
+            type: {
+                type: string;
+                description: string;
+            };
+            content: {
+                type: string;
+                description: string;
+            };
+            toAgent: {
+                type: string;
+                description: string;
+            };
+            affectedFiles: {
+                type: string;
+                items: {
+                    type: string;
+                };
+                description: string;
+            };
+        };
+        required: string[];
+    };
+} | {
+    name: string;
+    description: string;
+    parameters: {
+        type: string;
+        properties: {
+            type?: undefined;
+            content?: undefined;
+            toAgent?: undefined;
+            affectedFiles?: undefined;
+        };
+        required?: undefined;
+    };
+})[];
+/**
+ * Wraps the global executeTool to provide sub-agent context.
+ *
+ * 1. Captures tool execution into the MessageBus (Layer 1: zero-cost logs).
+ * 2. Implements FileLocks for write/modify operations to prevent race conditions.
+ * 3. Handles `post_message` and `read_messages` directly.
+ * 4. Calls a heartbeat callback to notify the orchestrator this agent is alive.
+ */
+export declare function executeScopedTool(name: string, args: Record<string, any>, workspaceRoot: string, agentId: string, bus: MessageBus, locks: FileLockRegistry, onHeartbeat: () => void): Promise<any>;

package/dist/services/orchestration/scopedTools.js

@@ -0,0 +1,172 @@
+import { executeTool, getToolDeclarations as getBaseToolDeclarations } from '../agent-tools.js';
+import { MessageBus } from './messageBus.js';
+import { debugLog } from '../../utils/logger.js';
+/**
+ * Extended tool declarations for sub-agents, merging the standard tools
+ * with orchestration-specific ones (e.g., post_message, read_messages).
+ */
+export function getScopedToolDeclarations() {
+    return [
+        ...getBaseToolDeclarations(),
+        {
+            name: 'post_message',
+            description: 'Post a semantic message to the orchestration bus to coordinate with other agents.',
+            parameters: {
+                type: 'OBJECT',
+                properties: {
+                    type: {
+                        type: 'STRING',
+                        description: 'Type of signal: "discovery", "warning", "request", "completion"',
+                    },
+                    content: {
+                        type: 'STRING',
+                        description: 'The semantic intent or message content',
+                    },
+                    toAgent: {
+                        type: 'STRING',
+                        description: 'Optional target agent ID (required for "request")',
+                    },
+                    affectedFiles: {
+                        type: 'ARRAY',
+                        items: { type: 'STRING' },
+                        description: 'Files involved (required for "discovery")',
+                    },
+                },
+                required: ['type', 'content'],
+            },
+        },
+        {
+            name: 'read_messages',
+            description: 'Fetch any new messages or activity from other agents on the bus.',
+            parameters: {
+                type: 'OBJECT',
+                properties: {},
+            },
+        },
+    ];
+}
+/**
+ * Wraps the global executeTool to provide sub-agent context.
+ *
+ * 1. Captures tool execution into the MessageBus (Layer 1: zero-cost logs).
+ * 2. Implements FileLocks for write/modify operations to prevent race conditions.
+ * 3. Handles `post_message` and `read_messages` directly.
+ * 4. Calls a heartbeat callback to notify the orchestrator this agent is alive.
+ */
+export async function executeScopedTool(name, args, workspaceRoot, agentId, bus, locks, onHeartbeat) {
+    // Update heartbeat so the orchestrator knows we are making progress
+    onHeartbeat();
+    const timestamp = Date.now();
+    let actionDesc = 'Executed';
+    let targetDesc = 'workspace';
+    let status = 'success';
+    let result = null;
+    let resultSummary = undefined;
+    try {
+        // ─── Orchestration-Specific Tools ────────────────────────────────
+        if (name === 'post_message') {
+            const type = args.type;
+            const signal = {
+                type,
+                timestamp,
+                fromAgent: agentId,
+                content: args.content,
+            };
+            if (type === 'discovery')
+                signal.affectedFiles = args.affectedFiles || [];
+            if (type === 'request')
+                signal.toAgent = args.toAgent || 'all';
+            if (type === 'completion')
+                signal.summary = args.content; // map completion summary
+            const accepted = bus.postSignal(signal);
+            if (!accepted) {
+                return { error: `Message bus rejected signal. You have hit the max signal cap (${MessageBus.MAX_SIGNALS_PER_AGENT}). Stop sending signals.` };
+            }
+            return { success: true, message: 'Message posted to bus.' };
+        }
+        if (name === 'read_messages') {
+            const unread = bus.getUnread(agentId);
+            return {
+                activityLogs: MessageBus.formatActivityEntries(unread.activities),
+                semanticSignals: MessageBus.formatSignals(unread.signals),
+            };
+        }
+        // ─── Standard Tool Execution with Locking ────────────────────────
+        // Handle lock acquisition for write-oriented tools
+        let lockedFile = null;
+        let diffContext = null;
+        if (name === 'write_file' || name === 'modify_file' || name === 'delete_file') {
+            lockedFile = args.filePath;
+            if (lockedFile) {
+                debugLog(`Agent "${agentId}" requesting lock for "${lockedFile}" (tool: ${name})`);
+                const lockRes = await locks.acquire(lockedFile, agentId);
+                diffContext = lockRes.previousDiff;
+                if (lockRes.forceReleased) {
+                    debugLog(`Agent "${agentId}" got forced lock on "${lockedFile}" (previous owner stalled)`);
+                }
+            }
+        }
+        // Execute the underlying standard tool
+        try {
+            result = await executeTool(workspaceRoot, name, args);
+            // If we got a file lock and had context from a previous writer, we should 
+            // inject that diff info back into the agent's tool return payload so it 
+            // knows someone else changed the file while it was queued.
+            if (diffContext && typeof result === 'object') {
+                result._orchestrationWarning = `NOTICE: Another agent modified this file while you were waiting. Diff context: ${diffContext}`;
+            }
+        }
+        finally {
+            // Release the lock if we grabbed one
+            if (lockedFile) {
+                // We do a simple release. The actual diff context extraction happens at the orchestrator 
+                // layer during verification, but we release immediately to unblock others.
+                locks.release(lockedFile, agentId, `Action: ${name} completed`);
+            }
+        }
+        // ─── Formatting Log Outputs ──────────────────────────────────────
+        if (name === 'write_file' || name === 'modify_file') {
+            targetDesc = args.filePath;
+            actionDesc = name === 'write_file' ? 'Created/Replaced' : 'Modified';
+            resultSummary = typeof result === 'string' ? `${result.length} chars` : 'Success';
+        }
+        else if (name === 'read_file') {
+            targetDesc = args.filePath;
+            actionDesc = 'Read';
+            const len = typeof result === 'string' ? result.length : (result.fileContents?.length || 0);
+            resultSummary = `${len} chars`;
+        }
+        else if (name === 'run_command') {
+            targetDesc = args.command;
+            actionDesc = 'Ran command';
+        }
+        else if (name === 'grep_search') {
+            targetDesc = args.pattern;
+            actionDesc = 'Searched';
+            const matchCount = Array.isArray(result) ? result.length : 0;
+            resultSummary = `${matchCount} matches`;
+        }
+        return result;
+    }
+    catch (error) {
+        status = 'error';
+        resultSummary = error.message;
+        throw error;
+    }
+    finally {
+        // ─── Logging to Bus ──────────────────────────────────────────────
+        // We only log standard tools, not orchestration tools
+        if (name !== 'post_message' && name !== 'read_messages') {
+            bus.logActivity({
+                type: 'activity',
+                timestamp,
+                agentId,
+                tool: name,
+                target: targetDesc,
+                action: actionDesc,
+                status,
+                resultSummary,
+            });
+        }
+    }
+}

package/dist/services/orchestration/subAgent.d.ts

@@ -0,0 +1,58 @@
+/**
+ * @fileoverview Sub-Agent Runner for Orchestration.
+ *
+ * Implements the lifecycle, health monitoring, and tool-loop execution for a single
+ * parallelized sub-agent.
+ */
+import { MessageBus } from './messageBus.js';
+import { FileLockRegistry } from './fileLockRegistry.js';
+/**
+ * Result returned when a sub-agent completes its execution.
+ */
+export interface SubAgentResult {
+    /** Whether the agent successfully completed its intent */
+    success: boolean;
+    /** Output or summary produced by the agent */
+    summary: string;
+    /** Total credits (tokens) consumed by this agent */
+    creditsUsed: number;
+    /** Did the agent hit a stall timeout or crash? */
+    crashed: boolean;
+}
+/**
+ * Executes a sub-agent task with full health monitoring, tool wrapping,
+ * and orchestration integration.
+ */
+export declare class SubAgentRunner {
+    private readonly taskId;
+    private readonly intent;
+    private readonly workspaceRoot;
+    private readonly bus;
+    private readonly locks;
+    private readonly globalContext;
+    private chat;
+    private lastHeartbeat;
+    private creditsUsed;
+    /** Max time without a tool call or response before the agent is considered stalled */
+    static readonly STALL_TIMEOUT_MS = 60000;
+    constructor(taskId: string, intent: string, workspaceRoot: string, bus: MessageBus, locks: FileLockRegistry, globalContext: string);
+    /**
+     * Constructs the base system instruction for this specific agent.
+     */
+    private buildSystemInstruction;
+    /**
+     * Updates the heartbeat. Passed to `executeScopedTool` to ensure the agent
+     * isn't marked as stalled while performing long-running commands.
+     */
+    private pingHeartbeat;
+    /**
+     * Executes the sub-agent with a health monitor harness.
+     * Runs the tool loop until the model stops returning function calls,
+     * an error occurs, or the stall timeout is hit.
+     */
+    execute(signal: AbortSignal): Promise<SubAgentResult>;
+    /**
+     * Accumulates token usage from the chat session.
+     */
+    private updateUsage;
+}

package/dist/services/orchestration/subAgent.js

@@ -0,0 +1,187 @@
+/**
+ * @fileoverview Sub-Agent Runner for Orchestration.
+ *
+ * Implements the lifecycle, health monitoring, and tool-loop execution for a single
+ * parallelized sub-agent.
+ */
+import { ProxyChatSession } from '../ai.js';
+import { GEMINI_MODELS, MAX_OUTPUT_TOKENS } from '../../utils/config.js';
+import { executeScopedTool, getScopedToolDeclarations } from './scopedTools.js';
+import { debugLog } from '../../utils/logger.js';
+import { runWithAgentId } from '../../utils/asyncContext.js';
+/**
+ * Executes a sub-agent task with full health monitoring, tool wrapping,
+ * and orchestration integration.
+ */
+export class SubAgentRunner {
+    taskId;
+    intent;
+    workspaceRoot;
+    bus;
+    locks;
+    globalContext;
+    chat;
+    lastHeartbeat = Date.now();
+    creditsUsed = 0;
+    /** Max time without a tool call or response before the agent is considered stalled */
+    static STALL_TIMEOUT_MS = 60_000;
+    constructor(taskId, intent, workspaceRoot, bus, locks, globalContext) {
+        this.taskId = taskId;
+        this.intent = intent;
+        this.workspaceRoot = workspaceRoot;
+        this.bus = bus;
+        this.locks = locks;
+        this.globalContext = globalContext;
+        // Sub-agents default to flash-3.5 for better reasoning capabilities
+        this.chat = new ProxyChatSession(GEMINI_MODELS.FLASH_3_5, this.buildSystemInstruction(), [{ functionDeclarations: getScopedToolDeclarations() }], {
+            maxOutputTokens: MAX_OUTPUT_TOKENS,
+            temperature: 0.3, // Lower temperature for more focused execution
+            topP: 0.95,
+            topK: 40,
+        });
+    }
+    /**
+     * Constructs the base system instruction for this specific agent.
+     */
+    buildSystemInstruction() {
+        return (`You are an autonomous sub-agent executing a specific portion of a larger task.\n` +
+            `Your task ID is: ${this.taskId}\n` +
+            `Your objective: ${this.intent}\n\n` +
+            `=== GLOBAL CONTEXT & ORIGINAL USER REQUEST ===\n` +
+            `${this.globalContext}\n` +
+            `==============================================\n\n` +
+            `Guidelines:\n` +
+            `1. Focus ONLY on your assigned objective. Do not stray into other files or tasks.\n` +
+            `2. You are part of a parallelized system. Use 'post_message' to coordinate if you discover breaking changes.\n` +
+            `3. When you have completed your objective, stop using tools and provide a final summary of your work.\n` +
+            `4. If you encounter an insurmountable error, provide a summary of what went wrong so the orchestrator can re-assign or fix it.`);
+    }
+    /**
+     * Updates the heartbeat. Passed to `executeScopedTool` to ensure the agent
+     * isn't marked as stalled while performing long-running commands.
+     */
+    pingHeartbeat = () => {
+        this.lastHeartbeat = Date.now();
+    };
+    /**
+     * Executes the sub-agent with a health monitor harness.
+     * Runs the tool loop until the model stops returning function calls,
+     * an error occurs, or the stall timeout is hit.
+     */
+    async execute(signal) {
+        return runWithAgentId(this.taskId, async () => {
+            debugLog(`SubAgent [${this.taskId}]: Starting execution.`);
+            this.lastHeartbeat = Date.now();
+            let success = false;
+            let finalSummary = '';
+            let crashed = false;
+            // Health Monitor Timer
+            const healthMonitor = setInterval(() => {
+                if (Date.now() - this.lastHeartbeat > SubAgentRunner.STALL_TIMEOUT_MS) {
+                    debugLog(`SubAgent [${this.taskId}]: STALL DETECTED. No heartbeat for ${SubAgentRunner.STALL_TIMEOUT_MS}ms.`);
+                    crashed = true;
+                    // Note: the orchestrator will handle the actual force-releasing of locks
+                    // when this promise resolves/rejects, based on the `crashed` flag.
+                }
+            }, 5000);
+            try {
+                // Send initial prompt
+                const prompt = `Begin execution for task: ${this.taskId}\nObjective: ${this.intent}\n\nYou must use tools to achieve this objective. Do not stop until the objective is fully complete.`;
+                let turnResult = await this.chat.sendMessage(prompt, undefined, signal);
+                this.updateUsage(turnResult);
+                // Tool Loop
+                const MAX_TURNS = Infinity;
+                let turns = 0;
+                // Anti-loop tracking
+                const recentCalls = [];
+                while (turns < MAX_TURNS && !crashed && !signal.aborted) {
+                    this.pingHeartbeat();
+                    const calls = turnResult.response.functionCalls();
+                    // If the model stopped calling tools, it is done
+                    if (!calls || calls.length === 0) {
+                        success = true;
+                        finalSummary = turnResult.response.text() || 'Task completed without text summary.';
+                        break;
+                    }
+                    const toolResponses = [];
+                    // Execute all requested tools sequentially (to avoid parallel lock contention from the same agent)
+                    for (const call of calls) {
+                        if (crashed || signal.aborted)
+                            break;
+                        // Anti-loop check: Hash the call to detect exact repetitions
+                        const callHash = JSON.stringify({ name: call.name, args: call.args });
+                        recentCalls.push(callHash);
+                        if (recentCalls.length > 5)
+                            recentCalls.shift();
+                        if (recentCalls.length === 5 && recentCalls.every((c) => c === callHash)) {
+                            debugLog(`SubAgent [${this.taskId}]: Infinite loop detected on tool ${call.name}. Aborting.`);
+                            crashed = true;
+                            finalSummary = `Agent got stuck in an infinite loop repeating the exact same call to ${call.name}.`;
+                            break;
+                        }
+                        this.pingHeartbeat();
+                        debugLog(`SubAgent [${this.taskId}]: Executing tool ${call.name}`);
+                        let responseData;
+                        try {
+                            responseData = await executeScopedTool(call.name, call.args, this.workspaceRoot, this.taskId, this.bus, this.locks, this.pingHeartbeat);
+                        }
+                        catch (err) {
+                            responseData = { error: err.message || String(err) };
+                        }
+                        toolResponses.push({
+                            functionResponse: {
+                                name: call.name,
+                                response: {
+                                    output: responseData.output !== undefined ? responseData.output : responseData,
+                                    ...(responseData.error ? { error: responseData.error } : {}),
+                                    ...(responseData.inlineData ? { inlineData: responseData.inlineData } : {}),
+                                    ...(responseData._orchestrationWarning ? { _orchestrationWarning: responseData._orchestrationWarning } : {}),
+                                },
+                            },
+                        });
+                    }
+                    if (crashed || signal.aborted)
+                        break;
+                    this.pingHeartbeat();
+                    // Feed tool results back to the model
+                    turnResult = await this.chat.sendMessage(toolResponses, undefined, signal);
+                    this.updateUsage(turnResult);
+                    turns++;
+                }
+                if (turns >= MAX_TURNS) {
+                    debugLog(`SubAgent [${this.taskId}]: Hit max turns (${MAX_TURNS}).`);
+                    success = false;
+                    finalSummary = 'Agent reached maximum tool turns without completing the objective.';
+                }
+            }
+            catch (err) {
+                debugLog(`SubAgent [${this.taskId}]: Execution error: ${err.message}`);
+                crashed = true;
+                finalSummary = `Crashed: ${err.message}`;
+            }
+            finally {
+                clearInterval(healthMonitor);
+            }
+            if (signal.aborted) {
+                crashed = true;
+                finalSummary = 'Aborted by orchestrator.';
+            }
+            debugLog(`SubAgent [${this.taskId}]: Finished. Success=${success}, Crashed=${crashed}, Tokens=${this.creditsUsed}`);
+            return {
+                success: success && !crashed,
+                summary: finalSummary,
+                creditsUsed: this.creditsUsed,
+                crashed,
+            };
+        });
+    }
+    /**
+     * Accumulates token usage from the chat session.
+     */
+    updateUsage(result) {
+        const usage = result.response.usageMetadata?.();
+        if (usage && usage.totalTokenCount) {
+            this.creditsUsed += usage.totalTokenCount;
+        }
+    }
+}