minovative-mind-cli 2.13.5 → 2.14.1

package/dist/services/ai.d.ts

@@ -1,9 +1,23 @@
 import { type Content, type FunctionCall } from '@google/generative-ai';
+import { type ThinkingLevel } from '../utils/config.js';
 export declare function getMultiWorkspaceBlock(): string;
 export declare function setModelOverride(agent: 'context' | 'execution', overrideStr: string): void;
 export declare function clearModelOverrides(): void;
 export declare function setGlobalActiveModel(model: string): void;
 export declare function getGlobalActiveModel(): string;
+/**
+ * Gets the thinking reasoning level configured for a specific model or active model.
+ * Falls back to default model thinking levels or 'MEDIUM' if not explicitly configured.
+ */
+export declare function getModelThinkingLevel(model?: string): ThinkingLevel;
+/**
+ * Sets the user-configured thinking reasoning level for a specific model.
+ */
+export declare function setModelThinkingLevel(model: string, level: ThinkingLevel): void;
+/**
+ * Resets user-configured thinking levels back to default model presets.
+ */
+export declare function resetModelThinkingLevels(): void;
 export declare class ProxyChatSession {
     private history;
     private fullHistory;
@@ -12,6 +26,7 @@ export declare class ProxyChatSession {
     private tools;
     private toolConfig?;
     private generationConfig;
+    private configuredThinkingLevel?;
     private latestUsageMetadata;
     constructor(modelName: string, systemInstruction: string, tools: any[], generationConfig: any, toolConfig?: any);
     getLatestUsageMetadata(): any;
@@ -20,6 +35,10 @@ export declare class ProxyChatSession {
     getToolConfig(): any;
     setModel(modelName: string): void;
     getModel(): string;
+    setThinkingLevel(level: ThinkingLevel): void;
+    getThinkingLevel(): ThinkingLevel | undefined;
+    setGenerationConfig(generationConfig: any): void;
+    getGenerationConfig(): any;
     clearHistory(): void;
     getRawHistory(): Content[];
     getFullHistory(): Content[];

package/dist/services/ai.js

@@ -1,5 +1,5 @@
 import { SchemaType } from '@google/generative-ai';
-import { GEMINI_MODELS, DEFAULT_MODEL, MAX_OUTPUT_TOKENS, isByokEnabled } from '../utils/config.js';
+import { GEMINI_MODELS, DEFAULT_MODEL, MAX_OUTPUT_TOKENS, isByokEnabled, DEFAULT_MODEL_THINKING_LEVELS, } from '../utils/config.js';
 import { getToolDeclarations } from './agent-tools.js';
 import { getMetricCollector } from './metrics.js';
 import { getAuthorizedIdToken, checkByokSubscription } from './auth.js';
@@ -56,12 +56,40 @@ export function clearModelOverrides() {
 }
 // ─── AI Service ──────────────────────────────────────────────────────
 let globalActiveModel = DEFAULT_MODEL;
+const userModelThinkingLevels = new Map();
 export function setGlobalActiveModel(model) {
     globalActiveModel = model;
 }
 export function getGlobalActiveModel() {
     return globalActiveModel;
 }
+/**
+ * Gets the thinking reasoning level configured for a specific model or active model.
+ * Falls back to default model thinking levels or 'MEDIUM' if not explicitly configured.
+ */
+export function getModelThinkingLevel(model) {
+    const targetModel = model && model !== 'auto'
+        ? model
+        : globalActiveModel === 'auto'
+            ? GEMINI_MODELS.FLASH
+            : globalActiveModel;
+    if (userModelThinkingLevels.has(targetModel)) {
+        return userModelThinkingLevels.get(targetModel);
+    }
+    return DEFAULT_MODEL_THINKING_LEVELS[targetModel] || 'MEDIUM';
+}
+/**
+ * Sets the user-configured thinking reasoning level for a specific model.
+ */
+export function setModelThinkingLevel(model, level) {
+    userModelThinkingLevels.set(model, level);
+}
+/**
+ * Resets user-configured thinking levels back to default model presets.
+ */
+export function resetModelThinkingLevels() {
+    userModelThinkingLevels.clear();
+}
 const proxyClient = new ProxyClient();
 // ─── History Limits ──────────────────────────────────────────────────
 /** Maximum number of Content entries to keep in the sliding history window. */
@@ -101,6 +129,7 @@ export class ProxyChatSession {
     tools;
     toolConfig;
     generationConfig;
+    configuredThinkingLevel;
     latestUsageMetadata = undefined;
     constructor(modelName, systemInstruction, tools, generationConfig, toolConfig) {
         this.modelName = modelName;
@@ -108,6 +137,9 @@ export class ProxyChatSession {
         this.tools = tools;
         this.generationConfig = generationConfig;
         this.toolConfig = toolConfig;
+        if (generationConfig?.thinkingConfig?.thinkingLevel) {
+            this.configuredThinkingLevel = generationConfig.thinkingConfig.thinkingLevel;
+        }
     }
     getLatestUsageMetadata() {
         return this.latestUsageMetadata;
@@ -129,6 +161,28 @@ export class ProxyChatSession {
     getModel() {
         return this.modelName;
     }
+    setThinkingLevel(level) {
+        this.configuredThinkingLevel = level;
+        this.generationConfig = {
+            ...(this.generationConfig || {}),
+            thinkingConfig: {
+                ...(this.generationConfig?.thinkingConfig || {}),
+                thinkingLevel: level,
+            },
+        };
+    }
+    getThinkingLevel() {
+        return this.configuredThinkingLevel || this.generationConfig?.thinkingConfig?.thinkingLevel;
+    }
+    setGenerationConfig(generationConfig) {
+        this.generationConfig = generationConfig;
+        if (generationConfig?.thinkingConfig?.thinkingLevel) {
+            this.configuredThinkingLevel = generationConfig.thinkingConfig.thinkingLevel;
+        }
+    }
+    getGenerationConfig() {
+        return this.generationConfig;
+    }
     clearHistory() {
         this.history = [];
         this.fullHistory = [];
@@ -309,6 +363,12 @@ export class ProxyChatSession {
                             if (typeof respObj.result === 'string') {
                                 respObj.result = collapseHistoricalOutput(respObj.result, threshold);
                             }
+                            if (typeof respObj.stdout === 'string') {
+                                respObj.stdout = collapseHistoricalOutput(respObj.stdout, threshold);
+                            }
+                            if (typeof respObj.stderr === 'string') {
+                                respObj.stderr = collapseHistoricalOutput(respObj.stderr, threshold);
+                            }
                         }
                     }
                 }
@@ -461,11 +521,15 @@ export function createSharedChatSession() {
     let model = executionModelOverride || getGlobalActiveModel();
     if (model === 'auto')
         model = GEMINI_MODELS.FLASH; // Will be overridden per-turn in executeSingleTurn
+    const thinkingLevel = getModelThinkingLevel(model);
     return new ProxyChatSession(model, GENERAL_CHAT_INSTRUCTION.replace('{{MULTI_WORKSPACE_BLOCK}}', getMultiWorkspaceBlock()), [], {
         maxOutputTokens: MAX_OUTPUT_TOKENS,
         temperature: executionTempOverride !== null ? executionTempOverride : 1,
         topP: 0.95,
         topK: 40,
+        thinkingConfig: {
+            thinkingLevel,
+        },
     });
 }
 export function getGeneralChatConfig() {
@@ -509,11 +573,11 @@ export async function compressTextUsingFlashLite(text, instruction = "<directive
             }
             const creds = await loadCredentials();
             result = await proxyClient.generateViaBYOK(creds.geminiApiKey, model, contents, [], // no tools
-            undefined, instruction, { temperature: 0.2 }, undefined, abortSignal);
+            undefined, instruction, { temperature: 0.2, thinkingConfig: { thinkingLevel: 'MINIMAL' } }, undefined, abortSignal);
         }
         else {
             result = await proxyClient.generateFunctionCallViaProxy(idToken, model, contents, [], // no tools
-            undefined, instruction, { temperature: 0.2 }, // low temp for factual summary
+            undefined, instruction, { temperature: 0.2, thinkingConfig: { thinkingLevel: 'MINIMAL' } }, // low temp for factual summary
             undefined, abortSignal);
         }
         let textPart = '';
@@ -693,11 +757,15 @@ export function createContextAgentSession() {
     let model = contextModelOverride || getGlobalActiveModel();
     if (model === 'auto' || model.includes('claude'))
         model = GEMINI_MODELS.FLASH;
+    const thinkingLevel = getModelThinkingLevel(model);
     return new ProxyChatSession(model, CONTEXT_SYSTEM_INSTRUCTION.replace('{{MULTI_WORKSPACE_BLOCK}}', getMultiWorkspaceBlock()), contextTools, {
         maxOutputTokens: MAX_OUTPUT_TOKENS,
         temperature: contextTempOverride !== null ? contextTempOverride : 1,
         topP: 0.95,
         topK: 40,
+        thinkingConfig: {
+            thinkingLevel,
+        },
     }, {
         functionCallingConfig: {
             mode: 'ANY',
@@ -712,6 +780,9 @@ export function createIntentRouterSession() {
     return new ProxyChatSession(model, INTENT_ROUTER_SYSTEM_INSTRUCTION, [], // no tools
     {
         temperature: 0,
+        thinkingConfig: {
+            thinkingLevel: 'MINIMAL',
+        },
         responseMimeType: 'application/json',
         responseSchema: {
             type: SchemaType.OBJECT,
@@ -739,6 +810,9 @@ export function createExecutionComplexitySession() {
     return new ProxyChatSession(model, EXECUTION_COMPLEXITY_SYSTEM_INSTRUCTION, [], // no tools
     {
         temperature: 0,
+        thinkingConfig: {
+            thinkingLevel: 'MINIMAL',
+        },
         responseMimeType: 'application/json',
         responseSchema: {
             type: SchemaType.OBJECT,
@@ -761,6 +835,9 @@ export function createInvestigationComplexitySession() {
     return new ProxyChatSession(model, INVESTIGATION_COMPLEXITY_SYSTEM_INSTRUCTION, [], // no tools
     {
         temperature: 0,
+        thinkingConfig: {
+            thinkingLevel: 'MEDIUM',
+        },
         responseMimeType: 'application/json',
         responseSchema: {
             type: SchemaType.OBJECT,
@@ -824,6 +901,9 @@ export function createInvestigationSemanticSession() {
     return new ProxyChatSession(model, INVESTIGATION_SEMANTIC_SYSTEM_INSTRUCTION, [], // no tools
     {
         temperature: 0,
+        thinkingConfig: {
+            thinkingLevel: 'MINIMAL',
+        },
         responseMimeType: 'application/json',
         responseSchema: {
             type: SchemaType.OBJECT,
@@ -865,6 +945,9 @@ export function createWebSearchAgentSession() {
         temperature: 1,
         topP: 0.95,
         topK: 40,
+        thinkingConfig: {
+            thinkingLevel: 'MEDIUM',
+        },
     });
 }
 // ─── History Summarizer Agent Service ─────────────────────────────────
@@ -875,6 +958,9 @@ export function createHistorySummarizerSession() {
     return new ProxyChatSession(model, HISTORY_SUMMARIZER_SYSTEM_INSTRUCTION, [], {
         temperature: 0.2,
         maxOutputTokens: MAX_OUTPUT_TOKENS,
+        thinkingConfig: {
+            thinkingLevel: 'MINIMAL',
+        },
     });
 }
 /**
@@ -974,6 +1060,9 @@ export function createUserProfileExtractorSession() {
     return new ProxyChatSession(model, USER_PROFILE_EXTRACTOR_SYSTEM_INSTRUCTION, [], // no tools
     {
         temperature: 0,
+        thinkingConfig: {
+            thinkingLevel: 'MINIMAL',
+        },
         responseMimeType: 'application/json',
         responseSchema: {
             type: SchemaType.OBJECT,
@@ -1094,6 +1183,9 @@ export function createTrivialMessageClassifierSession() {
     return new ProxyChatSession(model, TRIVIAL_MESSAGE_CLASSIFIER_SYSTEM_INSTRUCTION, [], // no tools
     {
         temperature: 0,
+        thinkingConfig: {
+            thinkingLevel: 'MINIMAL',
+        },
         responseMimeType: 'application/json',
         responseSchema: {
             type: SchemaType.OBJECT,
@@ -1138,11 +1230,11 @@ export async function generateChatTitle(firstMessage, abortSignal) {
             }
             const creds = await loadCredentials();
             result = await proxyClient.generateViaBYOK(creds.geminiApiKey, model, contents, [], // no tools
-            undefined, instruction, { temperature: 0.2 }, undefined, abortSignal);
+            undefined, instruction, { temperature: 0.2, thinkingConfig: { thinkingLevel: 'MINIMAL' } }, undefined, abortSignal);
         }
         else {
             result = await proxyClient.generateFunctionCallViaProxy(idToken, model, contents, [], // no tools
-            undefined, instruction, { temperature: 0.2 }, undefined, abortSignal);
+            undefined, instruction, { temperature: 0.2, thinkingConfig: { thinkingLevel: 'MINIMAL' } }, undefined, abortSignal);
         }
         let title = '';
         if (result.parts) {

package/dist/services/contextAgent.js

@@ -209,6 +209,7 @@ export async function routeIntent(userRequest, chatHistory = '', abortSignal) {
     }
     try {
         const session = createIntentRouterSession();
+        debugLog(`Intent Router evaluating intent [Model: ${session.getModel()}, Thinking: ${session.getThinkingLevel() || 'MINIMAL'}]`);
         let prompt = `User Request: "${userRequest}"`;
         if (chatHistory) {
             const prunedHistory = pruneTextToTokenBudget(chatHistory, MAX_CHAT_HISTORY_ROUTER_TOKENS, { fromStart: true });
@@ -242,6 +243,7 @@ export async function evaluateExecutionComplexity(userRequest, investigationSumm
     }
     try {
         const session = createExecutionComplexitySession();
+        debugLog(`Execution Complexity evaluating [Model: ${session.getModel()}, Thinking: ${session.getThinkingLevel() || 'MINIMAL'}]`);
         let prompt = `User Request: "${userRequest}"
 Investigation Summary: ${investigationSummary || 'None (0 files needed)'}
 Number of Relevant Files: ${numRelevantFiles}`;
@@ -418,6 +420,7 @@ export async function gatherContext(workspaceRoot, userRequest, chatHistory = ''
     }
     // ─── Single Context Agent (Unified Reconnaissance) ───────────
     const session = createContextAgentSession();
+    debugLog(`[Context Agent] Starting reconnaissance [Model: ${session.getModel()}, Thinking: ${session.getThinkingLevel() || 'MEDIUM'}]`);
     const relevantFiles = new Map();
     let summary = 'No relevant context found.';
     let isInvestigationFinished = false;
@@ -430,6 +433,26 @@ export async function gatherContext(workspaceRoot, userRequest, chatHistory = ''
         const prunedHistory = pruneTextToTokenBudget(chatHistory, MAX_CHAT_HISTORY_INVESTIGATION_TOKENS, { fromStart: true });
         currentMessage = `Previous Conversation Context:\n${prunedHistory}\n\n` + currentMessage;
     }
+    // Parse explicit context mentions from user request to prioritize referenced files
+    try {
+        const { mentionEngine } = await import('./mentionEngine.js');
+        const parsedMentions = mentionEngine.parseMentions(userRequest, workspaceRoot);
+        const explicitMentionedFiles = parsedMentions
+            .filter((m) => m.type === 'file' && m.valid)
+            .map((m) => m.target);
+        if (parsedMentions.length > 0) {
+            const validMentions = parsedMentions.filter((m) => m.valid);
+            if (validMentions.length > 0 && onProgress) {
+                const mentionLabels = validMentions.map((m) => m.raw).slice(0, 4).join(', ');
+                const overflow = validMentions.length > 4 ? ` (+${validMentions.length - 4} more)` : '';
+                onProgress(`Found explicit context: ${mentionLabels}${overflow}`);
+            }
+        }
+        if (explicitMentionedFiles.length > 0) {
+            currentMessage += `\n\nExplicit Mentioned Files from User Request:\n${explicitMentionedFiles.map((f) => `- ${f}`).join('\n')}`;
+        }
+    }
+    catch { }
     currentMessage += `\n\nStart investigating to find relevant files.`;
     const MAX_TURNS = Infinity;
     let textRetryCount = 0;

package/dist/services/investigationComplexity.js

@@ -235,7 +235,7 @@ Approximate File Count: ${approximateFileCount}`;
         if (chatHistory.trim()) {
             prompt += `\n\nRecent Conversation:\n${chatHistory.trim()}`;
         }
-        debugLog(`[InvestigationComplexity] Evaluating prompt complexity (autoFocus: ${activeSubPath || 'none'}, override: ${explicitOverride || 'none'})`);
+        debugLog(`[InvestigationComplexity] Evaluating prompt complexity (autoFocus: ${activeSubPath || 'none'}, override: ${explicitOverride || 'none'}) [Model: ${session.getModel()}, Thinking: ${session.getThinkingLevel() || 'MEDIUM'}]`);
         const response = await session.sendMessage(prompt, undefined, abortSignal);
         const rawText = typeof response?.response?.text === 'function'
             ? response.response.text()