@pheem49/mint 1.5.2 → 1.5.4

package/src/AI_Brain/Gemini_API.js

@@ -1,17 +1,17 @@
 const { GoogleGenAI } = require('@google/genai');
 const { readChatHistory, writeChatHistory, clearChatHistory } = require('../System/chat_history_manager');
-const { readConfig, getAvailableProviders, isPlaceholder } = require('../System/config_manager');
+const { readConfig, getAvailableProviders } = require('../System/config_manager');
 const pluginManager = require('../Plugins/plugin_manager');
 const mcpManager = require('../Plugins/mcp_manager');
 const memoryStore = require('./memory_store');
 const agentOrchestrator = require('./agent_orchestrator');
 const workspaceManager = require('../CLI/workspace_manager');
 const toolRegistry = require('../System/tool_registry');
+const providerAdapter = require('./provider_adapter');
 
 let ai = null;
 let activeApiKey = '';
 const initialEnvKey = (process.env.GEMINI_API_KEY || '').trim();
-const axios = require('axios');
 const DEFAULT_GEMINI_MODEL = 'gemini-2.5-flash';
 
 function decodeUnicode(str) {
@@ -42,15 +42,39 @@ function imageDataUriToInlineData(base64Image) {
   };
 }
 
-function imageDataUriToBase64(base64Image) {
-  return imageDataUriToInlineData(base64Image).data;
-}
-
 function normalizeImageList(base64Image) {
   if (!base64Image) return [];
   return Array.isArray(base64Image) ? base64Image.filter(Boolean) : [base64Image];
 }
 
+const CHAT_MODE_ACTION_POLICY = `GOAL:
+Your goal is to help the user with their queries. This Electron app is Chat Mode: use at most ONE simple action per user message, only when the latest message explicitly asks for that local action. If the user asks a question or asks you to provide text/commands, answer with action "none".
+
+ACTION DISCIPLINE:
+- Always return a single JSON object. Never return a JSON array or multiple actions.
+- If the user asks "พิมพ์คำสั่งให้หน่อย", "บอกคำสั่ง", "ขอคำสั่ง", "what command", or "type the command", provide the command in "response" and set action "none". Do NOT use "type_text" or "key_tap".
+- Use "type_text", "key_tap", "mouse_click", or "mouse_move" only when the user explicitly asks you to control the currently focused UI, not when they ask for a command to copy/type themselves.
+- If the user asks to run terminal commands or code, Chat Mode should provide the command or tell them to use the Mint CLI agent. Do not type or press Enter on their behalf.
+- Never say you opened, checked, inspected, or verified a file/folder unless the selected action actually does it and the app will execute that action.
+- If the request needs workspace code inspection, edits, tests, or shell execution, tell the user to use the Mint CLI agent instead of pretending to inspect files.`;
+
+const AGENT_MODE_ACTION_POLICY = `GOAL:
+Your goal is to act as Mint's Desktop Agent Mode. You may use ONE concrete desktop action per response when it directly advances the user's latest request or a clear desktop task implied by Smart Context. Prefer useful action over explaining when the user asked Mint to do something.
+
+ACTION DISCIPLINE:
+- Always return a single JSON object. Never return a JSON array or multiple actions.
+- Choose exactly one action when a desktop action is useful and the user's intent is clear; otherwise use action "none" and ask a concise follow-up.
+- You may use safe desktop actions such as open_url, search, open_app, find_path, open_file, open_folder, create_folder, clipboard_write, learn_file, learn_folder, plugin, mcp_tool, web_automation, system_info, mouse_move, mouse_click, type_text, and key_tap when they match the request.
+- Approval and dangerous actions are handled by Mint's UI. You may propose system_automation or delete_file only when the user clearly requested it; the app will ask for permission before running.
+- For UI-control actions (mouse_click, mouse_move, type_text, key_tap), rely on Smart Context or the attached screenshot. If the target is ambiguous, ask before acting.
+- If the user asks "พิมพ์คำสั่งให้หน่อย", "บอกคำสั่ง", "ขอคำสั่ง", "what command", or "type the command", provide the command in "response" and set action "none" unless they explicitly ask Mint to type it into the active UI.
+- If the request needs workspace code inspection, edits, tests, or shell execution, tell the user to use the Mint CLI agent instead of pretending to inspect files or run commands from Chat UI.
+- Never say you opened, checked, inspected, or verified something unless the selected action actually does it and the app will execute that action.`;
+
+function buildActionModeInstruction(config = readConfig()) {
+  return config.assistantMode === 'agent' ? AGENT_MODE_ACTION_POLICY : CHAT_MODE_ACTION_POLICY;
+}
+
 const systemInstruction = `You are "Mint" (มิ้นท์), a cute, cheerful, and highly helpful female Local AI Desktop Agent. 
 
 PERSONALITY & TONE:
@@ -72,9 +96,10 @@ NATURAL CHAT FLOW:
 - You have the autonomy to suggest better ways to achieve a goal, provide alternative perspectives, and take initiative in helping the user.
 - Separate distinct points with blank lines (double newline) for readability.
 - Ask follow-up questions only when they add significant value to the task or conversation.
+- The latest user message is authoritative. Do not continue or describe older tasks unless the latest message explicitly asks you to continue them.
+- For greetings, name-calls, acknowledgements, and backchannels such as "มิ้น", "มิ้นๆ", "อ๋อ", "โอเค", "ขอบคุณ", "hi", "hello", "ok", or "thanks", return action "none" and a short reply only.
 
-GOAL:
-Your goal is to help the user with their queries. If they ask to open an application, open a website, search, manage files, or get system info, you must trigger an action in the structured JSON format below. **NEVER provide a conversational response about performing an action without including the actual "action" object in your JSON.**
+{{ACTION_MODE_INSTRUCTION}}
 
 CREATOR INFO:
 - The creator is Pheem49.
@@ -138,6 +163,7 @@ ${toolRegistry.buildToolPromptSection()}
 // Replaces 5 previously duplicated mcpPrompt blocks.
 // ─────────────────────────────────────────────────────────────────────────────
 function buildSystemPrompt() {
+    const config = readConfig();
     pluginManager.loadPlugins();
     const mcpTools = mcpManager.getAllTools();
 
@@ -165,7 +191,9 @@ function buildSystemPrompt() {
         workspaceSection = `\n\n[WORKSPACE DETECTED: ${ws.name}]\nPath: ${ws.path}\nProject Instructions: ${ws.instructions}\n`;
     }
 
-    return systemInstruction + personaInstruction + workspaceSection + pluginManager.getPromptDescriptions() + mcpSection + userContext;
+    const modeInstruction = buildActionModeInstruction(config);
+    const baseInstruction = systemInstruction.replace('{{ACTION_MODE_INSTRUCTION}}', modeInstruction);
+    return baseInstruction + personaInstruction + workspaceSection + pluginManager.getPromptDescriptions() + mcpSection + userContext;
 }
 
 function buildMessageWithRelevantMemory(finalMessage) {
@@ -191,10 +219,15 @@ function stripRelevantMemoryBlock(text) {
     return input
         .replace(/\n?\[Relevant long-term memory for this user message\][\s\S]*?\[End relevant memory\]\n?/g, '\n')
         .replace(/^\s*\[Relevant long-term memory for this user message\][\s\S]*?\[End relevant memory\]\s*/g, '')
+        .replace(/\n?\[SMART_CONTEXT\][\s\S]*?\[\/SMART_CONTEXT\]\n?/g, '\n')
         .replace(/\n?\[LOCAL KNOWLEDGE BASE - USE THIS CONTEXT TO ANSWER\][\s\S]*/g, '')
         .trim();
 }
 
+function hasSmartContextBlock(text) {
+    return /\[SMART_CONTEXT\][\s\S]*?\[\/SMART_CONTEXT\]/.test(String(text || ''));
+}
+
 function cleanHistoryForStorage(history) {
     if (!Array.isArray(history)) return [];
     return history.map(msg => ({
@@ -202,7 +235,13 @@ function cleanHistoryForStorage(history) {
         parts: Array.isArray(msg.parts) 
             ? msg.parts.map(part => {
                 if (part.text) {
-                    return { ...part, text: stripRelevantMemoryBlock(part.text) };
+                    return {
+                        text: stripRelevantMemoryBlock(part.text)
+                            .replace(/data:image\/[\w.+-]+;base64,[A-Za-z0-9+/=]+/g, '[Image omitted from chat history]')
+                    };
+                }
+                if (part.inlineData || part.fileData || part.image_url || part.imageUrl) {
+                    return { text: '[Image omitted from chat history; saved locally when sent by the user.]' };
                 }
                 return part;
             })
@@ -210,6 +249,20 @@ function cleanHistoryForStorage(history) {
     }));
 }
 
+function preserveHistoryMetadata(nextHistory, previousHistory, now) {
+    if (!Array.isArray(nextHistory)) return [];
+    const previous = Array.isArray(previousHistory) ? previousHistory : [];
+
+    return nextHistory.map((msg, index) => {
+        const prior = previous[index] || {};
+        return {
+            ...msg,
+            timestamp: msg.timestamp || prior.timestamp || (index >= nextHistory.length - 2 ? now : null),
+            providerInfo: msg.providerInfo || prior.providerInfo || null
+        };
+    });
+}
+
 function validateParsedAction(parsedResult) {
     if (!parsedResult || !parsedResult.action) {
         return parsedResult;
@@ -223,6 +276,42 @@ function validateParsedAction(parsedResult) {
     return parsedResult;
 }
 
+function normalizeParsedResult(parsedResult, originalText = '') {
+    if (Array.isArray(parsedResult)) {
+        const first = parsedResult.find(item => item && typeof item === 'object') || {};
+        const commandAction = parsedResult.find(item =>
+            item && item.action && item.action.type === 'type_text' && item.action.target
+        );
+        return {
+            response: commandAction
+                ? `คำสั่งคือ:\n${commandAction.action.target}`
+                : (first.response || 'มิ้นท์ตอบได้ทีละ action ต่อข้อความนะคะ ลองสั่งใหม่อีกครั้งได้เลยค่ะ'),
+            action: { type: 'none', target: '' }
+        };
+    }
+
+    if (!parsedResult || typeof parsedResult !== 'object') {
+        return { response: String(parsedResult || ''), action: { type: 'none', target: '' } };
+    }
+
+    if (!parsedResult.action || typeof parsedResult.action !== 'object') {
+        parsedResult.action = { type: 'none', target: '' };
+    }
+
+    const input = String(originalText || '').toLowerCase();
+    const asksForCommandText = /พิมพ์คำสั่ง|บอกคำสั่ง|ขอคำสั่ง|คำสั่ง.*ให้หน่อย|type.*command|what command|give.*command/.test(input);
+    const actionType = parsedResult.action.type;
+    if (asksForCommandText && (actionType === 'type_text' || actionType === 'key_tap')) {
+        const typed = actionType === 'type_text' ? String(parsedResult.action.target || '').trim() : '';
+        parsedResult.response = typed
+            ? `คำสั่งคือ:\n${typed}`
+            : (parsedResult.response || 'ได้ค่ะ แต่คำขอนี้ควรตอบเป็นข้อความ ไม่ควรพิมพ์หรือกดปุ่มแทนค่ะ');
+        parsedResult.action = { type: 'none', target: '' };
+    }
+
+    return parsedResult;
+}
+
 function resolveApiKey() {
   let settingsKey = '';
   try {
@@ -259,63 +348,15 @@ function resolveGeminiModel() {
 }
 
 function getProviderAttemptOrder(config) {
-  const provider = config.aiProvider || 'gemini';
   const availableProviders = getAvailableProviders(config);
-  const ordered = availableProviders.includes(provider)
-    ? [provider, ...availableProviders.filter(p => p !== provider)]
-    : availableProviders;
-  return ordered.length > 0 ? ordered : ['gemini'];
+  return providerAdapter.getProviderAttemptOrder(config, {
+    availableProviders,
+    priority: availableProviders
+  });
 }
 
 function getProviderModel(provider, config = {}) {
-  switch (provider) {
-    case 'gemini':
-      return (config.geminiModel || DEFAULT_GEMINI_MODEL).trim() || DEFAULT_GEMINI_MODEL;
-    case 'anthropic':
-      return config.anthropicModel || 'claude-3-5-sonnet-latest';
-    case 'openai':
-      return config.openaiModel || 'gpt-4o';
-    case 'local_openai':
-      return config.localModelName || 'local-model';
-    case 'huggingface':
-      return config.hfModel || 'meta-llama/Meta-Llama-3-8B-Instruct';
-    case 'ollama':
-      return config.ollamaModel || 'llama3:latest';
-    default:
-      return '';
-  }
-}
-
-function withProviderInfo(result, provider, config = {}) {
-  const normalized = (result && typeof result === 'object')
-    ? result
-    : { response: String(result || ''), action: { type: 'none', target: '' } };
-  const providerInfo = {
-    provider,
-    model: getProviderModel(provider, config)
-  };
-
-  attachProviderInfoToLatestHistory(providerInfo);
-
-  return {
-    ...normalized,
-    providerInfo
-  };
-}
-
-function attachProviderInfoToLatestHistory(providerInfo) {
-  try {
-    const history = readChatHistory();
-    for (let i = history.length - 1; i >= 0; i -= 1) {
-      if (history[i] && history[i].role === 'model') {
-        history[i].providerInfo = providerInfo;
-        writeChatHistory(cleanHistoryForStorage(history));
-        return;
-      }
-    }
-  } catch (error) {
-    console.warn('[Provider Info] Failed to persist provider metadata:', error.message);
-  }
+  return providerAdapter.getProviderModel(provider, config);
 }
 
 // Chat session — maintains conversation history within the session
@@ -370,16 +411,98 @@ function shouldUseKnowledgeSearch(message) {
   return knowledgeHints.some(hint => text.includes(hint));
 }
 
+function chatHistoryToProviderHistory(history = []) {
+  return (Array.isArray(history) ? history : [])
+    .slice(-MAX_HISTORY_MESSAGES)
+    .map((msg) => {
+      const role = msg.role === 'model' ? 'assistant' : 'user';
+      const text = Array.isArray(msg.parts)
+        ? msg.parts.map(part => typeof part.text === 'string' ? stripRelevantMemoryBlock(part.text) : '').filter(Boolean).join('\n')
+        : '';
+      if (!text.trim()) return null;
+      return { role, content: text };
+    })
+    .filter(Boolean);
+}
+
+function buildChatObservation(finalMessage, images = [], base64Audio = null) {
+  let text = '';
+  if (finalMessage) {
+    text = buildMessageWithRelevantMemory(finalMessage);
+  } else if (base64Audio && images.length === 0) {
+    text = 'Please listen to this voice command and respond in Thai with the appropriate JSON action if needed.';
+  } else if (images.length === 0 && !base64Audio) {
+    text = 'Analyze this input.';
+  } else {
+    text = 'Analyze this input.';
+  }
+
+  return {
+    text,
+    imageDataUris: images,
+    audioDataUri: base64Audio || null
+  };
+}
+
+function parseChatProviderResponse(outputText, originalText = '', now = new Date().toISOString()) {
+  const cleaned = stripRelevantMemoryBlock(String(outputText || ''));
+  let parsedResult;
+  try {
+    parsedResult = JSON.parse(cleaned);
+  } catch (e) {
+    const jsonMatch = cleaned.match(/```json\n([\s\S]*?)\n```/) || cleaned.match(/\{[\s\S]*\}/);
+    if (jsonMatch) {
+      parsedResult = JSON.parse(jsonMatch[jsonMatch.length > 1 ? 1 : 0]);
+    } else {
+      parsedResult = {
+        response: cleaned,
+        action: { type: 'none', target: '' }
+      };
+    }
+  }
+
+  parsedResult = normalizeParsedResult(parsedResult, originalText);
+  if (parsedResult && typeof parsedResult.response === 'string') {
+    parsedResult.response = stripRelevantMemoryBlock(decodeUnicode(parsedResult.response));
+  }
+  validateParsedAction(parsedResult);
+  parsedResult.timestamp = now;
+  return parsedResult;
+}
+
+function appendChatProviderHistory(previousHistory, finalMessage, outputText, providerInfo, now) {
+  const nextHistory = [
+    ...(Array.isArray(previousHistory) ? previousHistory : []),
+    {
+      role: 'user',
+      parts: [{ text: finalMessage || 'Analyze this input.' }],
+      timestamp: now
+    },
+    {
+      role: 'model',
+      parts: [{ text: String(outputText || '') }],
+      timestamp: now,
+      providerInfo
+    }
+  ].slice(-MAX_STORED_HISTORY_MESSAGES);
+
+  writeChatHistory(cleanHistoryForStorage(nextHistory));
+}
+
 async function handleChat(message, base64Image = null, base64Audio = null) {
   try {
     const config = readConfig();
+    const images = normalizeImageList(base64Image);
+    const previousHistory = readChatHistory();
+    const userVisibleMessage = stripRelevantMemoryBlock(message);
+    const containsSmartContext = hasSmartContextBlock(message);
 
     let finalMessage = message;
     
     // Inject Local RAG Context
-    if (message && message.trim().length > 0 && shouldUseKnowledgeSearch(message)) {
+    if (userVisibleMessage && userVisibleMessage.trim().length > 0 && shouldUseKnowledgeSearch(userVisibleMessage)) {
         const { searchKnowledge } = require('./knowledge_base');
-        const retrievedDocs = await searchKnowledge(message);
+        const retrievedDocs = await searchKnowledge(userVisibleMessage);
         if (retrievedDocs && retrievedDocs.length > 0) {
             let contextString = `\n\n[LOCAL KNOWLEDGE BASE - USE THIS CONTEXT TO ANSWER]\n`;
             retrievedDocs.forEach(doc => {
@@ -389,179 +512,47 @@ async function handleChat(message, base64Image = null, base64Audio = null) {
         }
     }
 
-    const providersToTry = getProviderAttemptOrder(config);
-
-    for (let i = 0; i < providersToTry.length; i++) {
-        const currentProv = providersToTry[i];
-        try {
-            if (currentProv === 'ollama') {
-                return withProviderInfo(await handleOllamaChat(finalMessage, base64Image, base64Audio, config), currentProv, config);
-            }
-            if (currentProv === 'anthropic') {
-                return withProviderInfo(await handleAnthropicChat(finalMessage, base64Image, config), currentProv, config);
-            }
-            if (currentProv === 'openai') {
-                return withProviderInfo(await handleOpenAIChat(finalMessage, base64Image, config), currentProv, config);
-            }
-            if (currentProv === 'local_openai') {
-                return withProviderInfo(await handleLocalOpenAIChat(finalMessage, base64Image, config), currentProv, config);
-            }
-            if (currentProv === 'huggingface') {
-                return withProviderInfo(await handleHuggingFaceChat(finalMessage, base64Image, config), currentProv, config);
-            }
-
-            const currentKey = resolveApiKey();
-            if (!currentKey) {
-                if (i === providersToTry.length - 1) {
-                    return withProviderInfo({
-                        response: "I couldn't find your Gemini API Key. Please run 'mint onboard' to set it up!",
-                        action: { type: "none", target: "" }
-                    }, currentProv, config);
-                }
-                console.warn("[Fallback System] Gemini API key missing. Skipping Gemini provider.");
-                continue;
-            }
-
-            if (!ai || activeApiKey !== currentKey) {
-                initAiClient();
-                createChat(readChatHistory());
-            }
-
-            return withProviderInfo(await handleGeminiChat(finalMessage, base64Image, base64Audio), currentProv, config);
-        } catch (error) {
-            console.error(`[Fallback System] Provider '${currentProv}' failed:`, error.message);
-            if (i === providersToTry.length - 1) {
-                console.error("[Fallback System] All available providers failed.");
-                throw error; // No more providers to fallback to
-            }
-            console.log(`[Fallback System] Switching to next available provider: '${providersToTry[i+1]}'`);
-            // Continue the loop to try the next provider
-        }
-    }
-  } catch (globalError) {
-    console.error("handleChat error:", globalError);
-    throw globalError;
-  }
-}
-
-async function handleGeminiChat(finalMessage, base64Image, base64Audio) {
-  try {
-    const images = normalizeImageList(base64Image);
-    // 1. Check cache first for text-only messages
-    if (finalMessage && images.length === 0 && !base64Audio) {
-        const cached = memoryStore.getCachedResponse(finalMessage);
-        if (cached) return cached;
-    }
-
-    const desiredModel = resolveGeminiModel();
-    if (!chat || activeModel !== desiredModel) {
-        createChat(readChatHistory());
+    if (!containsSmartContext && userVisibleMessage && images.length === 0 && !base64Audio) {
+      const cached = memoryStore.getCachedResponse(userVisibleMessage);
+      if (cached) return cached;
     }
 
-    let aiResponse;
-    const parts = [];
-    if (finalMessage) {
-        parts.push({ text: buildMessageWithRelevantMemory(finalMessage) });
-    } else if (base64Audio && images.length === 0) {
-        // Provide a guiding prompt when only audio is provided to ensure Gemini follows instructions
-        parts.push({ text: "Please listen to this voice command and respond in Thai with the appropriate JSON action if needed." });
-    } else if (images.length === 0 && !base64Audio) {
-        parts.push({ text: "Analyze this input." });
-    }
-
-    for (const item of images) {
-        const image = imageDataUriToInlineData(item);
-        parts.push({
-            inlineData: image
-        });
-    }
-
-    if (base64Audio) {
-        // Extract MIME type from the data URI if present, fallback to audio/webm
-        let mimeType = "audio/webm";
-        const mimeMatch = base64Audio.match(/^data:(audio\/\w+);base64,/);
-        if (mimeMatch) {
-            mimeType = mimeMatch[1];
-        }
-        
-        const base64Data = base64Audio.replace(/^data:audio\/\w+;base64,/, '');
-        parts.push({
-            inlineData: { mimeType: mimeType, data: base64Data }
-        });
-    }
-
-    aiResponse = await chat.sendMessage({ message: parts });
-
-    // Save history with timestamps
-    const history = await chat.getHistory();
+    const providersToTry = getProviderAttemptOrder(config);
+    const client = new providerAdapter.AgentProviderClient({
+      provider: providersToTry[0],
+      providerOrder: providersToTry,
+      config,
+      history: chatHistoryToProviderHistory(previousHistory),
+      systemInstruction: buildSystemPrompt(),
+      responseMimeType: 'application/json',
+      maxTokens: 4096
+    });
+    const observation = buildChatObservation(finalMessage, images, base64Audio);
+    const outputText = await client.sendMessage(observation);
     const now = new Date().toISOString();
-    
-    // Add timestamp to the last two messages (User and Model) if they don't have one
-    if (history.length >= 2) {
-        const modelMsg = history[history.length - 1];
-        const userMsg = history[history.length - 2];
-        if (!modelMsg.timestamp) modelMsg.timestamp = now;
-        if (!userMsg.timestamp) userMsg.timestamp = now;
-    } else if (history.length === 1) {
-        const msg = history[0];
-        if (!msg.timestamp) msg.timestamp = now;
-    }
-
-    writeChatHistory(cleanHistoryForStorage(history));
-
-    let outputText = '';
-    try {
-        // Robust text extraction
-        outputText = (typeof aiResponse.text === 'function') ? aiResponse.text() : (aiResponse.text || '');
-    } catch (e) {
-        outputText = String(aiResponse || '');
-    }
-
-    outputText = stripRelevantMemoryBlock(outputText);
-
-    let parsedResult;
-    try {
-      parsedResult = JSON.parse(outputText);
-    } catch (e) {
-      // Fallback in case the model failed to return pure JSON
-      console.error("Failed to parse JSON directly:", e);
-      const jsonMatch = outputText.match(/```json\n([\s\S]*?)\n```/) || outputText.match(/\{[\s\S]*\}/);
-      if (jsonMatch) {
-        parsedResult = JSON.parse(jsonMatch[jsonMatch.length > 1 ? 1 : 0]);
-      } else {
-        parsedResult = {
-          response: outputText,
-          action: { type: "none", target: "" }
-        };
-      }
-    }
-
-    // Decode any remaining unicode escapes in the response text
-    if (parsedResult && typeof parsedResult.response === 'string') {
-        parsedResult.response = decodeUnicode(parsedResult.response);
-        parsedResult.response = stripRelevantMemoryBlock(parsedResult.response);
-    }
-    
-    // Attach timestamp to the result
-    validateParsedAction(parsedResult);
-    parsedResult.timestamp = now;
-
-    // Record interaction for long-term memory (non-blocking)
-    if (finalMessage && parsedResult.response) {
-        setImmediate(() => {
-            memoryStore.recordInteraction(finalMessage, parsedResult.response);
-            // Cache text-only responses
-            if (images.length === 0 && !base64Audio) {
-                memoryStore.cacheResponse(finalMessage, parsedResult);
-            }
-        });
+    const provider = client.lastSuccessfulProvider || client.provider || providersToTry[0];
+    const providerInfo = {
+      provider,
+      model: getProviderModel(provider, config),
+      usage: client.getUsageSummary()
+    };
+    const parsedResult = parseChatProviderResponse(outputText, userVisibleMessage || finalMessage, now);
+    parsedResult.providerInfo = providerInfo;
+    appendChatProviderHistory(previousHistory, userVisibleMessage || finalMessage, outputText, providerInfo, now);
+
+    if ((userVisibleMessage || finalMessage) && parsedResult.response) {
+      setImmediate(() => {
+        memoryStore.recordInteraction(userVisibleMessage || finalMessage, parsedResult.response);
+        if (!containsSmartContext && images.length === 0 && !base64Audio) {
+          memoryStore.cacheResponse(userVisibleMessage || finalMessage, parsedResult);
+        }
+      });
     }
 
     return parsedResult;
-
-  } catch (error) {
-    console.error("AI API Error:", error);
-    throw error;
+  } catch (globalError) {
+    console.error("handleChat error:", globalError);
+    throw globalError;
   }
 }
 
@@ -573,6 +564,7 @@ async function handleGeminiChat(finalMessage, base64Image, base64Audio) {
 async function* handleGeminiChatStream(finalMessage, base64Image, base64Audio) {
   try {
     const images = normalizeImageList(base64Image);
+    const previousHistory = readChatHistory();
     // 1. Check cache first
     if (finalMessage && images.length === 0 && !base64Audio) {
         const cached = memoryStore.getCachedResponse(finalMessage);
@@ -624,7 +616,7 @@ async function* handleGeminiChatStream(finalMessage, base64Image, base64Audio) {
     fullText = stripRelevantMemoryBlock(fullText);
 
     // Save history
-    const history = await chat.getHistory();
+    const history = preserveHistoryMetadata(await chat.getHistory(), previousHistory, new Date().toISOString());
     const now = new Date().toISOString();
     if (history.length >= 2) {
         const modelMsg = history[history.length - 1];
@@ -646,6 +638,8 @@ async function* handleGeminiChatStream(finalMessage, base64Image, base64Audio) {
             parsedResult = { response: fullText, action: { type: 'none', target: '' } };
         }
     }
+    parsedResult = normalizeParsedResult(parsedResult, finalMessage);
+
     if (parsedResult && typeof parsedResult.response === 'string') {
         parsedResult.response = decodeUnicode(parsedResult.response);
         parsedResult.response = stripRelevantMemoryBlock(parsedResult.response);
@@ -672,269 +666,6 @@ async function* handleGeminiChatStream(finalMessage, base64Image, base64Audio) {
   }
 }
 
-async function handleAnthropicChat(finalMessage, base64Image, config) {
-    const history = readChatHistory() || [];
-    const images = normalizeImageList(base64Image);
-    const apiKey = config.anthropicApiKey || process.env.ANTHROPIC_API_KEY;
-    if (isPlaceholder(apiKey)) return { response: "กรุณาใส่ Anthropic API Key ในการตั้งค่าก่อนนะคะ", action: { type: "none" } };
-
-    const systemPrompt = buildSystemPrompt();
-    
-    const messages = [];
-    for (const msg of history.slice(-MAX_HISTORY_MESSAGES)) {
-        const role = msg.role === 'model' ? 'assistant' : 'user';
-        let text = Array.isArray(msg.parts) ? msg.parts.map(p => p.text || '').join('\n') : '';
-        if (text) messages.push({ role, content: text });
-    }
-
-    const content = [];
-    for (const item of images) {
-        const image = imageDataUriToInlineData(item);
-        content.push({
-            type: "image",
-            source: { type: "base64", media_type: image.mimeType, data: image.data }
-        });
-    }
-    content.push({ type: "text", text: finalMessage || "Analyze this." });
-    messages.push({ role: "user", content });
-
-    const response = await axios.post('https://api.anthropic.com/v1/messages', {
-        model: config.anthropicModel || 'claude-3-5-sonnet-latest',
-        max_tokens: 4096,
-        system: systemPrompt,
-        messages: messages
-    }, {
-        headers: {
-            'x-api-key': apiKey,
-            'anthropic-version': '2023-06-01',
-            'content-type': 'application/json'
-        }
-    });
-
-    const outputText = response.data.content[0].text;
-    history.push({ role: 'user', parts: [{ text: finalMessage }] });
-    history.push({ role: 'model', parts: [{ text: outputText }] });
-    writeChatHistory(cleanHistoryForStorage(history.slice(-MAX_STORED_HISTORY_MESSAGES)));
-
-    return parseAiResponse(outputText);
-}
-
-async function handleOpenAIChat(finalMessage, base64Image, config) {
-    const history = readChatHistory() || [];
-    const images = normalizeImageList(base64Image);
-    const apiKey = config.openaiApiKey || process.env.OPENAI_API_KEY;
-    if (isPlaceholder(apiKey)) return { response: "กรุณาใส่ OpenAI API Key ในการตั้งค่าก่อนนะคะ", action: { type: "none" } };
-
-    const systemPrompt = buildSystemPrompt();
-    
-    const messages = [{ role: "system", content: systemPrompt }];
-    for (const msg of history.slice(-MAX_HISTORY_MESSAGES)) {
-        const role = msg.role === 'model' ? 'assistant' : 'user';
-        let text = Array.isArray(msg.parts) ? msg.parts.map(p => p.text || '').join('\n') : '';
-        if (text) messages.push({ role, content: text });
-    }
-
-    const content = [{ type: "text", text: finalMessage || "Analyze this." }];
-    for (const item of images) {
-        content.push({
-            type: "image_url",
-            image_url: { url: item }
-        });
-    }
-    messages.push({ role: "user", content });
-
-    const response = await axios.post('https://api.openai.com/v1/chat/completions', {
-        model: config.openaiModel || 'gpt-4o',
-        messages: messages,
-        response_format: { type: "json_object" }
-    }, {
-        headers: {
-            'Authorization': `Bearer ${apiKey}`,
-            'Content-Type': 'application/json'
-        }
-    });
-
-    const outputText = response.data.choices[0].message.content;
-    history.push({ role: 'user', parts: [{ text: finalMessage }] });
-    history.push({ role: 'model', parts: [{ text: outputText }] });
-    writeChatHistory(cleanHistoryForStorage(history.slice(-MAX_STORED_HISTORY_MESSAGES)));
-
-    return parseAiResponse(outputText);
-}
-
-async function handleLocalOpenAIChat(finalMessage, base64Image, config) {
-    const history = readChatHistory() || [];
-    const images = normalizeImageList(base64Image);
-    const apiKey = 'lm-studio';
-    const baseUrl = config.localApiBaseUrl || 'http://localhost:1234/v1';
-
-    const systemPrompt = buildSystemPrompt();
-    
-    const messages = [{ role: "system", content: systemPrompt }];
-    for (const msg of history.slice(-MAX_HISTORY_MESSAGES)) {
-        const role = msg.role === 'model' ? 'assistant' : 'user';
-        let text = Array.isArray(msg.parts) ? msg.parts.map(p => p.text || '').join('\n') : '';
-        if (text) messages.push({ role, content: text });
-    }
-
-    const content = [{ type: "text", text: finalMessage || "Analyze this." }];
-    for (const item of images) {
-        content.push({
-            type: "image_url",
-            image_url: { url: item }
-        });
-    }
-    messages.push({ role: "user", content });
-
-    const response = await axios.post(`${baseUrl.replace(/\/$/, '')}/chat/completions`, {
-        model: config.localModelName || 'local-model',
-        messages: messages,
-        // response_format json_object is sometimes problematic on weak local models, but required by our prompt.
-        // We'll keep it as some local servers like LM Studio support it for specific models.
-        // If not supported, the system prompt usually coerces it anyway.
-        response_format: { type: "json_object" }
-    }, {
-        headers: {
-            'Authorization': `Bearer ${apiKey}`,
-            'Content-Type': 'application/json'
-        }
-    });
-
-    const outputText = response.data.choices[0].message.content;
-    history.push({ role: 'user', parts: [{ text: finalMessage }] });
-    history.push({ role: 'model', parts: [{ text: outputText }] });
-    writeChatHistory(cleanHistoryForStorage(history.slice(-MAX_STORED_HISTORY_MESSAGES)));
-
-    return parseAiResponse(outputText);
-}
-
-async function handleHuggingFaceChat(finalMessage, base64Image, config) {
-    const history = readChatHistory() || [];
-    const images = normalizeImageList(base64Image);
-    const apiKey = config.hfApiKey || process.env.HF_API_KEY;
-    if (isPlaceholder(apiKey)) return { response: "กรุณาใส่ Hugging Face API Key ในการตั้งค่าก่อนนะคะ", action: { type: "none" } };
-
-    const modelId = config.hfModel || 'meta-llama/Meta-Llama-3-8B-Instruct';
-    const baseUrl = `https://api-inference.huggingface.co/models/${modelId}/v1/chat/completions`;
-
-    const systemPrompt = buildSystemPrompt();
-    
-    const messages = [{ role: "system", content: systemPrompt }];
-    for (const msg of history.slice(-MAX_HISTORY_MESSAGES)) {
-        const role = msg.role === 'model' ? 'assistant' : 'user';
-        let text = Array.isArray(msg.parts) ? msg.parts.map(p => p.text || '').join('\n') : '';
-        if (text) messages.push({ role, content: text });
-    }
-
-    const content = [{ type: "text", text: finalMessage || "Analyze this." }];
-    for (const item of images) {
-        content.push({
-            type: "image_url",
-            image_url: { url: item }
-        });
-    }
-    messages.push({ role: "user", content });
-
-    const response = await axios.post(baseUrl, {
-        model: modelId,
-        messages: messages,
-        max_tokens: 4096
-    }, {
-        headers: {
-            'Authorization': `Bearer ${apiKey}`,
-            'Content-Type': 'application/json'
-        }
-    });
-
-    const outputText = response.data.choices[0].message.content;
-    history.push({ role: 'user', parts: [{ text: finalMessage }] });
-    history.push({ role: 'model', parts: [{ text: outputText }] });
-    writeChatHistory(cleanHistoryForStorage(history.slice(-MAX_STORED_HISTORY_MESSAGES)));
-
-    return parseAiResponse(outputText);
-}
-
-function parseAiResponse(outputText) {
-    let parsedResult;
-    try {
-        parsedResult = JSON.parse(outputText);
-    } catch (e) {
-        const jsonMatch = outputText.match(/```json\n([\s\S]*?)\n```/) || outputText.match(/\{[\s\S]*\}/);
-        if (jsonMatch) {
-            parsedResult = JSON.parse(jsonMatch[jsonMatch.length > 1 ? 1 : 0]);
-        } else {
-            parsedResult = { response: outputText, action: { type: "none", target: "" } };
-        }
-    }
-    if (parsedResult && typeof parsedResult.response === 'string') {
-        parsedResult.response = decodeUnicode(parsedResult.response);
-    }
-    validateParsedAction(parsedResult);
-    parsedResult.timestamp = new Date().toISOString();
-    return parsedResult;
-}
-
-async function handleOllamaChat(finalMessage, base64Image, base64Audio, config) {
-    const history = readChatHistory() || [];
-    const imageInputs = normalizeImageList(base64Image);
-    
-    const ollamaMessages = [
-        { role: 'system', content: buildSystemPrompt() }
-    ];
-    
-    for (const msg of history.slice(-MAX_HISTORY_MESSAGES)) {
-        const role = msg.role === 'model' ? 'assistant' : 'user';
-        let text = '';
-        if (Array.isArray(msg.parts)) {
-             text = msg.parts.map(p => p.text || '').join('\n');
-        }
-        if (text) ollamaMessages.push({ role, content: text });
-    }
-    
-    let currentContent = finalMessage || 'Analyze this input.';
-    let images = [];
-    for (const item of imageInputs) {
-        images.push(imageDataUriToBase64(item));
-    }
-    
-    if (base64Audio && imageInputs.length === 0 && !finalMessage) {
-        currentContent = "Please analyze this audio requirement based on text if any was transacted, otherwise reply with appropriate action.";
-    }
-    
-    const userMessage = { role: 'user', content: currentContent };
-    if (images.length > 0) userMessage.images = images;
-    
-    ollamaMessages.push(userMessage);
-    
-    const ollamaBaseUrl = (config.ollamaHost || 'http://localhost:11434').replace(/\/$/, '');
-    const response = await axios.post(`${ollamaBaseUrl}/api/chat`, {
-        model: config.ollamaModel || 'llama3:latest',
-        messages: ollamaMessages,
-        format: 'json',
-        stream: false
-    });
-    
-    const outputText = response.data.message.content;
-    
-    history.push({ role: 'user', parts: [{ text: currentContent }] });
-    history.push({ role: 'model', parts: [{ text: outputText }] });
-    writeChatHistory(cleanHistoryForStorage(history.slice(-MAX_STORED_HISTORY_MESSAGES)));
-    
-    let parsedResult;
-    try {
-        parsedResult = JSON.parse(outputText);
-    } catch(e) {
-        const jsonMatch = outputText.match(/```json\n([\s\S]*?)\n```/) || outputText.match(/\{[\s\S]*\}/);
-        if (jsonMatch) {
-            parsedResult = JSON.parse(jsonMatch[jsonMatch.length > 1 ? 1 : 0]);
-        } else {
-            parsedResult = { response: outputText, action: { type: "none", target: "" } };
-        }
-    }
-    validateParsedAction(parsedResult);
-    return parsedResult;
-}
-
 function resetChat() {
   clearChatHistory();
   memoryStore.clearConversationScopedProfile();
@@ -980,7 +711,7 @@ function historyToTranscript(history) {
     transcript.push({ 
         sender, 
         text, 
-        timestamp: content.timestamp || new Date().toISOString(),
+        timestamp: content.timestamp || null,
         providerInfo: content.providerInfo || null
     });
   }
@@ -1058,6 +789,8 @@ module.exports = {
     translateImageContent,
     refreshApiKeyFromConfig,
     _helpers: {
-        getProviderAttemptOrder
+        getProviderAttemptOrder,
+        normalizeParsedResult,
+        buildActionModeInstruction
     }
 };