@pheem49/mint 1.5.2 → 1.5.4

package/src/CLI/interactive_chat.js

@@ -1,5 +1,6 @@
 'use strict';
 
+const crypto = require('crypto');
 const { colors, exitWithGoodbye } = require('./cli_colors');
 const { splitResponseSentences }  = require('./cli_formatters');
 const {
@@ -28,9 +29,109 @@ const systemMonitor     = require('../Plugins/system_monitor');
 const workspaceManager  = require('./workspace_manager');
 const { executeCodeTask } = require('./code_agent');
 const { resetChat }       = require('../AI_Brain/Gemini_API');
+const { saveChatImages }  = require('../System/picture_store');
 
 const sleep = (ms) => new Promise(resolve => setTimeout(resolve, ms));
 
+function createSessionStats() {
+    return {
+        sessionId: crypto.randomUUID(),
+        startedAt: Date.now(),
+        activeStartedAt: null,
+        agentActiveMs: 0,
+        toolCalls: { total: 0, success: 0, failed: 0 },
+        modelUsage: {}
+    };
+}
+
+function addUsageRow(stats, row = {}) {
+    const provider = row.provider || 'unknown';
+    const model = row.model || 'unknown';
+    const key = `${provider}:${model}`;
+    if (!stats.modelUsage[key]) {
+        stats.modelUsage[key] = {
+            provider,
+            model,
+            requests: 0,
+            inputTokens: 0,
+            cacheReads: 0,
+            outputTokens: 0,
+            reasoningTokens: 0,
+            totalTokens: 0
+        };
+    }
+
+    const target = stats.modelUsage[key];
+    target.requests += Number(row.requests) || 1;
+    target.inputTokens += Number(row.inputTokens) || 0;
+    target.cacheReads += Number(row.cacheReads) || 0;
+    target.outputTokens += Number(row.outputTokens) || 0;
+    target.reasoningTokens += Number(row.reasoningTokens) || 0;
+    target.totalTokens += Number(row.totalTokens) || 0;
+}
+
+function normalizeProviderUsage(providerInfo = {}) {
+    const usage = providerInfo.usage;
+    if (Array.isArray(usage)) return usage;
+    if (!usage || typeof usage !== 'object') {
+        return [{
+            provider: providerInfo.provider,
+            model: providerInfo.model,
+            requests: 1
+        }];
+    }
+
+    return [{
+        provider: providerInfo.provider,
+        model: providerInfo.model,
+        requests: 1,
+        inputTokens: usage.promptTokenCount || usage.prompt_tokens || usage.input_tokens,
+        cacheReads: usage.cachedContentTokenCount ||
+            (usage.prompt_tokens_details && usage.prompt_tokens_details.cached_tokens) ||
+            usage.cache_read_input_tokens,
+        outputTokens: usage.candidatesTokenCount || usage.completion_tokens || usage.output_tokens,
+        reasoningTokens: usage.thoughtsTokenCount ||
+            (usage.completion_tokens_details && usage.completion_tokens_details.reasoning_tokens),
+        totalTokens: usage.totalTokenCount || usage.total_tokens
+    }];
+}
+
+function recordProviderInfo(stats, providerInfo) {
+    if (!providerInfo) return;
+    for (const row of normalizeProviderUsage(providerInfo)) {
+        addUsageRow(stats, row);
+    }
+}
+
+function markAgentActive(stats, active) {
+    const now = Date.now();
+    if (active && !stats.activeStartedAt) {
+        stats.activeStartedAt = now;
+        return;
+    }
+    if (!active && stats.activeStartedAt) {
+        stats.agentActiveMs += now - stats.activeStartedAt;
+        stats.activeStartedAt = null;
+    }
+}
+
+function buildExitSummary(stats) {
+    const activeMs = stats.agentActiveMs + (stats.activeStartedAt ? Date.now() - stats.activeStartedAt : 0);
+    const total = stats.toolCalls.total;
+    return {
+        message: 'Agent powering down. Goodbye!',
+        sessionId: stats.sessionId,
+        toolCalls: {
+            ...stats.toolCalls,
+            successRate: total ? (stats.toolCalls.success / total) * 100 : 0
+        },
+        wallMs: Date.now() - stats.startedAt,
+        agentActiveMs: activeMs,
+        modelUsage: Object.values(stats.modelUsage),
+        quotaHint: 'Use /models to view model quota information'
+    };
+}
+
 // ---------------------------------------------------------------------------
 // Internal helpers
 // ---------------------------------------------------------------------------
@@ -143,12 +244,25 @@ async function sendSemanticCodeMessage({ rawArgs = '', appendMessage, streamMess
     }
 }
 
-async function sendImageMessage({ images, image, prompt, appendMessage, streamMessage, setThinking, appendCodeStep }) {
+function hasAllImageLabels(message = '', imageCount = 0) {
+    const text = String(message || '');
+    for (let index = 1; index <= imageCount; index++) {
+        if (!text.includes(`[Image #${index}]`)) return false;
+    }
+    return imageCount > 0;
+}
+
+function formatImageDisplayMessage(message = '', labels = '', imageCount = 0) {
+    if (!labels) return message;
+    return hasAllImageLabels(message, imageCount) ? message : `${message}\n${labels}`;
+}
+
+async function sendImageMessage({ images, image, prompt, appendMessage, streamMessage, setThinking, appendCodeStep, stats }) {
     const formatErr = (err) => err && err.message ? err.message : String(err || 'Unknown error');
     const imageList = images || (image ? [image] : []);
     const message   = prompt || 'Analyze this image.';
     const labels    = imageList.map((_, i) => `[Image #${i + 1}]`).join(' ');
-    const displayMessage = labels && message.includes(labels) ? message : `${message}\n${labels}`;
+    const displayMessage = formatImageDisplayMessage(message, labels, imageList.length);
 
     appendMessage('user', displayMessage);
     if (appendCodeStep) {
@@ -160,17 +274,27 @@ async function sendImageMessage({ images, image, prompt, appendMessage, streamMe
     }
 
     const cancelTimer = startThinkingTimer(setThinking);
+    if (stats) markAgentActive(stats, true);
     try {
-        const result      = await handleChat(message, imageList.map(item => item.dataUri), null);
+        const imageDataUris = imageList.map(item => item.dataUri);
+        const result        = await handleChat(message, imageDataUris, null);
+        try {
+            saveChatImages(imageDataUris, { source: 'cli', message });
+        } catch (saveError) {
+            console.error('[Pictures] Failed to save CLI image:', saveError.message);
+        }
         cancelTimer();
         setThinking(false);
+        if (stats) markAgentActive(stats, false);
 
         const responseText = result.response || '';
+        if (stats) recordProviderInfo(stats, result.providerInfo);
         await streamAssistantSentences(responseText, appendMessage, { providerInfo: result.providerInfo }, streamMessage);
         return { responseText, labels, imageList };
     } catch (err) {
         cancelTimer();
         setThinking(false);
+        if (stats) markAgentActive(stats, false);
         appendMessage('error', formatErr(err));
         return { responseText: '', labels, imageList };
     }
@@ -189,6 +313,7 @@ async function runAgentTask(text, { appendMessage, streamMessage, setThinking, r
 
     if (setMode) setMode('Agent');
     const cancelTimer = startThinkingTimer(setThinking);
+    markAgentActive(sharedState.stats, true);
 
     try {
         const config             = require('../System/config_manager').readConfig();
@@ -202,10 +327,19 @@ async function runAgentTask(text, { appendMessage, streamMessage, setThinking, r
             askUser,
             provider: preferredProvider,
             history:  contextualHistory,
-            onProgress: (info) => { if (appendCodeStep) appendCodeStep(info); },
+            onProgress: (info) => {
+                if (info && info.phase === 'tool_call') {
+                    sharedState.stats.toolCalls.total += 1;
+                    if (info.status === 'success') sharedState.stats.toolCalls.success += 1;
+                    else sharedState.stats.toolCalls.failed += 1;
+                }
+                if (appendCodeStep) appendCodeStep(info);
+            },
             onFinalSummary: async (info) => {
                 cancelTimer();
                 setThinking(false);
+                markAgentActive(sharedState.stats, false);
+                recordProviderInfo(sharedState.stats, info.providerInfo);
                 streamedFinalSummary = true;
                 await streamAssistantSentences(info.summary, appendMessage, { providerInfo: info.providerInfo }, streamMessage);
             }
@@ -213,13 +347,16 @@ async function runAgentTask(text, { appendMessage, streamMessage, setThinking, r
 
         cancelTimer();
         setThinking(false);
+        markAgentActive(sharedState.stats, false);
         sharedState.lastResponseText = result.summary;
         if (!streamedFinalSummary) {
+            recordProviderInfo(sharedState.stats, result.providerInfo);
             await streamAssistantSentences(result.summary, appendMessage, { providerInfo: result.providerInfo }, streamMessage);
         }
     } catch (err) {
         cancelTimer();
         setThinking(false);
+        markAgentActive(sharedState.stats, false);
         appendMessage('error', formatErr(err));
     } finally {
         if (setMode) setMode('Agent');
@@ -242,11 +379,14 @@ async function startInteractiveChat(initialMessage = null, options = {}) {
     // Shared mutable state between onSubmit closures
     const sharedState = {
         lastResponseText:        '',
-        recentImageContextText:  ''
+        recentImageContextText:  '',
+        isBusy:                  false,
+        stats:                   createSessionStats()
     };
 
     // -----------------------------------------------------------------------
-    const ui = await createChatUI({
+    let ui;
+    ui = await createChatUI({
         onPasteImage: async () => {
             try {
                 const image = loadClipboardImageAsDataUri();
@@ -257,6 +397,12 @@ async function startInteractiveChat(initialMessage = null, options = {}) {
         },
 
         onSubmit: async (text, submitOptions = {}) => {
+            if (sharedState.isBusy) {
+                ui.appendMessage('system', 'Mint is still working on the previous request. Please wait for it to finish before sending another command.');
+                return;
+            }
+            sharedState.isBusy = true;
+
             const {
                 appendMessage, streamMessage, setThinking, updateStatusModel,
                 copyLastResponse, requestApproval, setMode, appendCodeStep,
@@ -264,168 +410,177 @@ async function startInteractiveChat(initialMessage = null, options = {}) {
                 setPendingPasteText, setFastMode, toggleFastMode, getFastMode
             } = ui;
 
-            // ── Image submission ────────────────────────────────────────────
-            if (submitOptions.images && submitOptions.images.length > 0) {
-                const images = submitOptions.images.map(item => item.image || item);
-                const { responseText, labels, imageList } = await sendImageMessage({
-                    images,
-                    prompt: text.trim() || 'Analyze this image.',
-                    appendMessage, streamMessage, setThinking, appendCodeStep
-                });
-                sharedState.lastResponseText = responseText;
-                if (responseText) {
-                    sharedState.recentImageContextText = [
-                        `Recent image context: the user attached ${imageList.length} image(s) labelled ${labels || '[Image #1]'}.`,
-                        'The terminal UI displays image attachments as labels only; it does not render thumbnails inside the chat.',
-                        `Assistant response to those image(s): ${responseText}`
-                    ].join('\n');
-                }
-                return;
-            }
-
-            // ── Slash commands ──────────────────────────────────────────────
-            if (text.startsWith('/')) {
-                if (text.startsWith('/agent')) {
-                    const aArgs = text.split(' ');
-                    if (aArgs[1] === 'list') {
-                        appendMessage('system', `Available Agents: ${agentOrchestrator.listAgents().join(', ')}`);
-                    } else if (aArgs[1]) {
-                        const success = agentOrchestrator.setAgent(aArgs[1]);
-                        if (success) {
-                            const agent = agentOrchestrator.getCurrentAgent();
-                            appendMessage('system', `Switched to Agent: ${agent.icon} ${agent.name}`);
-                            updateStatusModel(agent.name);
-                            resetChat();
-                        } else {
-                            appendMessage('error', `Agent "${aArgs[1]}" not found. Try /agent list`);
-                        }
-                    } else {
-                        const agent = agentOrchestrator.getCurrentAgent();
-                        appendMessage('system', `Current Agent: ${agent.icon} ${agent.name}\nUsage: /agent <type> or /agent list`);
+            try {
+                // ── Image submission ────────────────────────────────────────
+                if (submitOptions.images && submitOptions.images.length > 0) {
+                    const images = submitOptions.images.map(item => item.image || item);
+                    const { responseText, labels, imageList } = await sendImageMessage({
+                        images,
+                        prompt: text.trim() || 'Analyze this image.',
+                        appendMessage, streamMessage, setThinking, appendCodeStep,
+                        stats: sharedState.stats
+                    });
+                    sharedState.lastResponseText = responseText;
+                    if (responseText) {
+                        sharedState.recentImageContextText = [
+                            `Recent image context: the user attached ${imageList.length} image(s) labelled ${labels || '[Image #1]'}.`,
+                            'The terminal UI displays image attachments as labels only; it does not render thumbnails inside the chat.',
+                            `Assistant response to those image(s): ${responseText}`
+                        ].join('\n');
                     }
                     return;
                 }
 
-                if (text.startsWith('/stats')) {
-                    appendMessage('system', '📊 Fetching system statistics...');
-                    const stats = await systemMonitor.execute('stats');
-                    appendMessage('system', stats);
-                    return;
-                }
-
-                if (text.startsWith('/workspace')) {
-                    const wArgs  = text.split(' ');
-                    const subCmd = wArgs[1];
-                    if (subCmd === 'add') {
-                        const name         = wArgs[2];
-                        const wsPath       = wArgs[3] || '.';
-                        const instructions = wArgs.slice(4).join(' ');
-                        if (!name) {
-                            appendMessage('error', 'Usage: /workspace add <name> [path] [instructions]');
-                        } else {
-                            workspaceManager.addWorkspace(name, wsPath, instructions);
-                            appendMessage('system', `Workspace "${name}" registered at ${require('path').resolve(wsPath)}`);
-                            resetChat();
-                        }
-                    } else if (subCmd === 'list') {
-                        const all = workspaceManager.listWorkspaces();
-                        let listMsg = 'Registered Workspaces:\n';
-                        for (const n in all) listMsg += `- ${n}: ${all[n].path}\n`;
-                        appendMessage('system', Object.keys(all).length ? listMsg : 'No workspaces registered.');
-                    } else if (subCmd === 'remove') {
-                        const name = wArgs[2];
-                        if (workspaceManager.removeWorkspace(name)) {
-                            appendMessage('system', `Removed workspace "${name}"`);
-                            resetChat();
-                        } else {
-                            appendMessage('error', `Workspace "${name}" not found.`);
-                        }
-                    } else if (subCmd === 'use' || subCmd === 'switch') {
-                        const name = wArgs[2];
-                        const all  = workspaceManager.listWorkspaces();
-                        if (all[name]) {
-                            const newPath = all[name].path;
-                            try {
-                                process.chdir(newPath);
-                                updateWorkspace(newPath);
-                                appendMessage('system', `✓ Switched to workspace "${name}" at ${newPath}`);
+                // ── Slash commands ──────────────────────────────────────────
+                if (text.startsWith('/')) {
+                    if (text.startsWith('/agent')) {
+                        const aArgs = text.split(' ');
+                        if (aArgs[1] === 'list') {
+                            appendMessage('system', `Available Agents: ${agentOrchestrator.listAgents().join(', ')}`);
+                        } else if (aArgs[1]) {
+                            const success = agentOrchestrator.setAgent(aArgs[1]);
+                            if (success) {
+                                const agent = agentOrchestrator.getCurrentAgent();
+                                appendMessage('system', `Switched to Agent: ${agent.icon} ${agent.name}`);
+                                updateStatusModel(agent.name);
                                 resetChat();
-                            } catch (e) {
-                                appendMessage('error', `Failed to change directory: ${e.message}`);
+                            } else {
+                                appendMessage('error', `Agent "${aArgs[1]}" not found. Try /agent list`);
                             }
                         } else {
-                            appendMessage('error', `Workspace "${name}" not found. Try /workspace list`);
+                            const agent = agentOrchestrator.getCurrentAgent();
+                            appendMessage('system', `Current Agent: ${agent.icon} ${agent.name}\nUsage: /agent <type> or /agent list`);
                         }
-                    } else {
-                        const ws = workspaceManager.getWorkspaceByPath(process.cwd());
-                        appendMessage('system', ws
-                            ? `Current Workspace: ${ws.name}\nPath: ${ws.path}`
-                            : `Not currently in a registered workspace.\nActive Path: ${process.cwd()}\nUsage: /workspace <add|use|list|remove>`);
+                        return;
                     }
-                    return;
-                }
 
-                if (text.startsWith('/review')) {
-                    if (!sharedState.lastResponseText) {
-                        appendMessage('error', 'Nothing to review yet. Get a response first.');
+                    if (text.startsWith('/stats')) {
+                        appendMessage('system', '📊 Fetching system statistics...');
+                        const stats = await systemMonitor.execute('stats');
+                        appendMessage('system', stats);
                         return;
                     }
-                    agentOrchestrator.setAgent('reviewer');
-                    appendMessage('system', '⚖️ Requesting second-pass review from Mint Reviewer...');
-                    text = `Please review this previous response and provide a critique:\n\n${sharedState.lastResponseText}`;
-                } else {
-                    if (!text.startsWith('/image') && !text.startsWith('/paste')) {
-                        appendMessage('user', text);
+
+                    if (text.startsWith('/workspace')) {
+                        const wArgs  = text.split(' ');
+                        const subCmd = wArgs[1];
+                        if (subCmd === 'add') {
+                            const name         = wArgs[2];
+                            const wsPath       = wArgs[3] || '.';
+                            const instructions = wArgs.slice(4).join(' ');
+                            if (!name) {
+                                appendMessage('error', 'Usage: /workspace add <name> [path] [instructions]');
+                            } else {
+                                workspaceManager.addWorkspace(name, wsPath, instructions);
+                                appendMessage('system', `Workspace "${name}" registered at ${require('path').resolve(wsPath)}`);
+                                resetChat();
+                            }
+                        } else if (subCmd === 'list') {
+                            const all = workspaceManager.listWorkspaces();
+                            let listMsg = 'Registered Workspaces:\n';
+                            for (const n in all) listMsg += `- ${n}: ${all[n].path}\n`;
+                            appendMessage('system', Object.keys(all).length ? listMsg : 'No workspaces registered.');
+                        } else if (subCmd === 'remove') {
+                            const name = wArgs[2];
+                            if (workspaceManager.removeWorkspace(name)) {
+                                appendMessage('system', `Removed workspace "${name}"`);
+                                resetChat();
+                            } else {
+                                appendMessage('error', `Workspace "${name}" not found.`);
+                            }
+                        } else if (subCmd === 'use' || subCmd === 'switch') {
+                            const name = wArgs[2];
+                            const all  = workspaceManager.listWorkspaces();
+                            if (all[name]) {
+                                const newPath = all[name].path;
+                                try {
+                                    process.chdir(newPath);
+                                    updateWorkspace(newPath);
+                                    appendMessage('system', `✓ Switched to workspace "${name}" at ${newPath}`);
+                                    resetChat();
+                                } catch (e) {
+                                    appendMessage('error', `Failed to change directory: ${e.message}`);
+                                }
+                            } else {
+                                appendMessage('error', `Workspace "${name}" not found. Try /workspace list`);
+                            }
+                        } else {
+                            const ws = workspaceManager.getWorkspaceByPath(process.cwd());
+                            appendMessage('system', ws
+                                ? `Current Workspace: ${ws.name}\nPath: ${ws.path}`
+                                : `Not currently in a registered workspace.\nActive Path: ${process.cwd()}\nUsage: /workspace <add|use|list|remove>`);
+                        }
+                        return;
                     }
-                    const slashResult = await handleSlashCommandUI(
-                        text, appendMessage, updateStatusModel, copyLastResponse,
-                        setThinking, requestApproval, setMode, appendCodeStep, updateWorkspace, {
-                            sendImageMessage, formatErrorMessage: formatErr,
-                            attachImage, setInputText, setPendingPasteText,
-                            setFastMode, toggleFastMode, getFastMode,
-                            sendRepoSummaryMessage, sendSymbolIndexMessage,
-                            sendSemanticCodeMessage, streamAssistantSentences,
-                            streamMessage
+
+                    if (text.startsWith('/review')) {
+                        if (!sharedState.lastResponseText) {
+                            appendMessage('error', 'Nothing to review yet. Get a response first.');
+                            return;
                         }
-                    );
-                    if (slashResult && slashResult.lastResponseText) {
-                        sharedState.lastResponseText = slashResult.lastResponseText;
+                        agentOrchestrator.setAgent('reviewer');
+                        appendMessage('system', '⚖️ Requesting second-pass review from Mint Reviewer...');
+                        text = `Please review this previous response and provide a critique:\n\n${sharedState.lastResponseText}`;
+                    } else {
+                        if (!text.startsWith('/image') && !text.startsWith('/paste')) {
+                            appendMessage('user', text);
+                        }
+                        const slashResult = await handleSlashCommandUI(
+                            text, appendMessage, updateStatusModel, copyLastResponse,
+                            setThinking, requestApproval, setMode, appendCodeStep, updateWorkspace, {
+                                sendImageMessage: (args) => sendImageMessage({ ...args, stats: sharedState.stats }),
+                                formatErrorMessage: formatErr,
+                                attachImage, setInputText, setPendingPasteText,
+                                setFastMode, toggleFastMode, getFastMode,
+                                sendRepoSummaryMessage, sendSymbolIndexMessage,
+                                sendSemanticCodeMessage, streamAssistantSentences,
+                                streamMessage
+                            }
+                        );
+                        if (slashResult && slashResult.lastResponseText) {
+                            sharedState.lastResponseText = slashResult.lastResponseText;
+                        }
+                        return;
                     }
-                    return;
                 }
-            }
 
-            appendMessage('user', text);
+                appendMessage('user', text);
 
-            // ── Local tool shortcuts (natural language) ─────────────────────
-            if (isRepoSummaryRequest(text)) {
-                const r = await sendRepoSummaryMessage({ appendMessage, streamMessage, setThinking });
-                sharedState.lastResponseText = r;
-                return;
-            }
-            if (isSymbolIndexRequest(text)) {
-                const r = await sendSymbolIndexMessage({ appendMessage, streamMessage, setThinking });
-                sharedState.lastResponseText = r;
-                return;
-            }
-            if (isSemanticCodeSearchRequest(text)) {
-                const query = extractSemanticCodeQuery(text);
-                const r = await sendSemanticCodeMessage({
-                    rawArgs: `search ${query}`,
-                    appendMessage, streamMessage, setThinking, appendCodeStep
-                });
-                sharedState.lastResponseText = r;
-                return;
-            }
+                // ── Local tool shortcuts (natural language) ─────────────────
+                if (isRepoSummaryRequest(text)) {
+                    const r = await sendRepoSummaryMessage({ appendMessage, streamMessage, setThinking });
+                    sharedState.lastResponseText = r;
+                    return;
+                }
+                if (isSymbolIndexRequest(text)) {
+                    const r = await sendSymbolIndexMessage({ appendMessage, streamMessage, setThinking });
+                    sharedState.lastResponseText = r;
+                    return;
+                }
+                if (isSemanticCodeSearchRequest(text)) {
+                    const query = extractSemanticCodeQuery(text);
+                    const r = await sendSemanticCodeMessage({
+                        rawArgs: `search ${query}`,
+                        appendMessage, streamMessage, setThinking, appendCodeStep
+                    });
+                    sharedState.lastResponseText = r;
+                    return;
+                }
 
-            // ── Normal agent task ───────────────────────────────────────────
-            await runAgentTask(text, {
-                appendMessage, streamMessage, setThinking,
-                requestApproval, askUser, setMode, appendCodeStep
-            }, sharedState);
+                // ── Default to guarded Code Agent ───────────────────────────
+                await runAgentTask(text, {
+                    appendMessage, streamMessage, setThinking,
+                    requestApproval, askUser, setMode, appendCodeStep
+                }, sharedState);
+            } finally {
+                sharedState.isBusy = false;
+            }
         },
 
-        onExit: () => exitWithGoodbye(0)
+        onExit: () => {
+            if (ui && typeof ui.unmount === 'function') ui.unmount();
+            exitWithGoodbye(0, buildExitSummary(sharedState.stats));
+        }
     });
 
     // ── Handle initial CLI --image option ───────────────────────────────────
@@ -434,7 +589,8 @@ async function startInteractiveChat(initialMessage = null, options = {}) {
         const image  = loadImageAsDataUri(options.imagePath);
         const prompt = initialMessage || 'Analyze this image.';
         const { responseText, labels, imageList } = await sendImageMessage({
-            images: [image], prompt, appendMessage, streamMessage, setThinking, appendCodeStep
+            images: [image], prompt, appendMessage, streamMessage, setThinking, appendCodeStep,
+            stats: sharedState.stats
         });
         sharedState.lastResponseText = responseText;
         if (responseText) {
@@ -476,4 +632,10 @@ async function startInteractiveChat(initialMessage = null, options = {}) {
     }
 }
 
-module.exports = { startInteractiveChat };
+module.exports = {
+    startInteractiveChat,
+    _helpers: {
+        hasAllImageLabels,
+        formatImageDisplayMessage
+    }
+};

package/src/CLI/slash_command_handler.js

@@ -169,8 +169,8 @@ async function handleSlashCommandUI(
             try {
                 const image = loadImageAsDataUri(imagePath);
                 if (helpers.attachImage) {
-                    helpers.attachImage({ label: image.path, image });
                     if (prompt && helpers.setInputText) helpers.setInputText(prompt);
+                    helpers.attachImage({ label: image.path, image });
                     appendMessage('system', 'Attached image. Press Enter to send.');
                 } else {
                     appendMessage('error', 'Image attachment is not available in this UI.');
@@ -186,9 +186,9 @@ async function handleSlashCommandUI(
             try {
                 const image = loadClipboardImageAsDataUri();
                 if (helpers.attachImage) {
-                    helpers.attachImage({ label: image.path, image });
                     const prompt = args.join(' ').trim();
                     if (prompt && helpers.setInputText) helpers.setInputText(prompt);
+                    helpers.attachImage({ label: image.path, image });
                     appendMessage('system', 'Attached clipboard image. Press Enter to send.');
                 } else {
                     appendMessage('error', 'Image attachment is not available in this UI.');

package/src/CLI/updater.js

@@ -112,6 +112,25 @@ function formatUpdateError(error) {
     return `Update failed: ${detail || 'Unknown npm error'}`;
 }
 
+function formatUpdateCheckError(error) {
+    const detail = [error.stderr, error.stdout, error.message].filter(Boolean).join('\n').trim();
+    if (/E404|404 Not Found|not in this registry/i.test(detail)) {
+        return [
+            `Update check unavailable: ${pkg.name} is not published on the npm registry.`,
+            'This does not mean your local Mint version is outdated.'
+        ].join('\n');
+    }
+
+    if (/ENOTFOUND|ETIMEDOUT|ECONNRESET|ECONNREFUSED|network|timeout/i.test(detail)) {
+        return [
+            'Update check unavailable: npm registry could not be reached.',
+            'This does not mean your local Mint version is outdated.'
+        ].join('\n');
+    }
+
+    return `Update check unavailable: ${detail || 'Unknown npm error'}`;
+}
+
 async function runUpdate(options = {}) {
     const currentVersion = pkg.version;
     let latestVersion = '';
@@ -123,7 +142,7 @@ async function runUpdate(options = {}) {
             status: 'error',
             currentVersion,
             latestVersion,
-            message: formatUpdateError(error)
+            message: formatUpdateCheckError(error)
         };
     }
 
@@ -205,6 +224,7 @@ module.exports = {
     _private: {
         parseVersion,
         formatUpdateError,
+        formatUpdateCheckError,
         getAutoUpdateIntervalMs
     }
 };