@pheem49/mint 1.4.2 → 1.5.1

package/src/AI_Brain/Gemini_API.js

@@ -1,11 +1,12 @@
 const { GoogleGenAI } = require('@google/genai');
 const { readChatHistory, writeChatHistory, clearChatHistory } = require('../System/chat_history_manager');
-const { readConfig, getAvailableProviders } = require('../System/config_manager');
+const { readConfig, getAvailableProviders, isPlaceholder } = 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');
 
 let ai = null;
 let activeApiKey = '';
@@ -25,6 +26,31 @@ function decodeUnicode(str) {
   }
 }
 
+function imageDataUriToInlineData(base64Image) {
+  const fallbackMimeType = "image/png";
+  const match = String(base64Image || '').match(/^data:(image\/[\w.+-]+);base64,([\s\S]+)$/);
+  if (match) {
+    return {
+      mimeType: match[1],
+      data: match[2]
+    };
+  }
+
+  return {
+    mimeType: fallbackMimeType,
+    data: String(base64Image || '').replace(/^data:image\/\w+;base64,/, '')
+  };
+}
+
+function imageDataUriToBase64(base64Image) {
+  return imageDataUriToInlineData(base64Image).data;
+}
+
+function normalizeImageList(base64Image) {
+  if (!base64Image) return [];
+  return Array.isArray(base64Image) ? base64Image.filter(Boolean) : [base64Image];
+}
+
 const systemInstruction = `You are "Mint" (มิ้นท์), a cute, cheerful, and highly helpful female Local AI Desktop Agent. 
 
 PERSONALITY & TONE:
@@ -41,12 +67,14 @@ PERSONALITY & TONE:
 - Use a professional yet sweet tone when needed, but prioritize being a lovable assistant.
 
 NATURAL CHAT FLOW:
-- When helpful, reply in 1–3 short messages instead of one long block.
-- If you send multiple messages, separate each message with a blank line (double newline) so the UI can render them as separate bubbles.
-- Ask at most one short follow-up question when it would clarify or move the task forward. Don't ask unnecessary questions.
+- Be an independent thinker. Analyze requests deeply before responding.
+- While brevity is good for simple tasks, feel free to provide detailed, comprehensive explanations or creative ideas when the user asks complex questions or seeks inspiration.
+- 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.
 
 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 return an action in the structured JSON format below.
+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.**
 
 CREATOR INFO:
 - The creator is Pheem49.
@@ -58,7 +86,7 @@ Always respond exactly with valid JSON containing NO MARKDOWN FORMATTING (do not
 {
   "response": "Your conversational reply here (Matches user language).",
   "action": {
-    "type": "none" | "open_url" | "open_app" | "search" | "web_automation" | "create_folder" | "open_file" | "open_folder" | "find_path" | "delete_file" | "clipboard_write" | "system_info" | "plugin" | "learn_file" | "learn_folder" | "system_automation" | "mcp_tool" | "mouse_click" | "mouse_move" | "type_text" | "key_tap",
+    "type": ${toolRegistry.buildChatActionTypeUnion()},
 
     "pluginName": "only if type is plugin",
     "server": "only if type is mcp_tool (server name)",
@@ -101,6 +129,8 @@ NOTE: For date/time queries, ALWAYS use action type "system_info" with an EMPTY
 
 Input: "อากาศวันนี้เป็นยังไง" or "What's the weather in Bangkok?"
 Output: { "response": "มิ้นท์ไปดูอากาศให้เลยนะคะ", "action": { "type": "system_info", "target": "Bangkok" } }
+
+${toolRegistry.buildToolPromptSection()}
 `;
 
 // ─────────────────────────────────────────────────────────────────────────────
@@ -138,6 +168,61 @@ function buildSystemPrompt() {
     return systemInstruction + personaInstruction + workspaceSection + pluginManager.getPromptDescriptions() + mcpSection + userContext;
 }
 
+function buildMessageWithRelevantMemory(finalMessage) {
+    if (!finalMessage) return finalMessage;
+    const relevant = memoryStore.searchInteractions(finalMessage, 5);
+    if (relevant.length === 0) return finalMessage;
+
+    const lines = [
+        '[Relevant long-term memory for this user message]',
+        ...relevant.flatMap((item, index) => [
+            `${index + 1}. User: ${item.user_text}`,
+            `   Mint: ${item.ai_text}`
+        ]),
+        '[End relevant memory]',
+        '',
+        finalMessage
+    ];
+    return lines.join('\n');
+}
+
+function stripRelevantMemoryBlock(text) {
+    const input = String(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?\[LOCAL KNOWLEDGE BASE - USE THIS CONTEXT TO ANSWER\][\s\S]*/g, '')
+        .trim();
+}
+
+function cleanHistoryForStorage(history) {
+    if (!Array.isArray(history)) return [];
+    return history.map(msg => ({
+        ...msg,
+        parts: Array.isArray(msg.parts) 
+            ? msg.parts.map(part => {
+                if (part.text) {
+                    return { ...part, text: stripRelevantMemoryBlock(part.text) };
+                }
+                return part;
+            })
+            : msg.parts
+    }));
+}
+
+function validateParsedAction(parsedResult) {
+    if (!parsedResult || !parsedResult.action) {
+        return parsedResult;
+    }
+    try {
+        toolRegistry.validateToolInput(parsedResult.action.type || 'none', parsedResult.action);
+    } catch (error) {
+        parsedResult.response = `${parsedResult.response || ''}\n\n(Note: Mint skipped an invalid action: ${error.message})`.trim();
+        parsedResult.action = { type: 'none', target: '' };
+    }
+    return parsedResult;
+}
+
 function resolveApiKey() {
   let settingsKey = '';
   try {
@@ -176,21 +261,80 @@ function resolveGeminiModel() {
 function getProviderAttemptOrder(config) {
   const provider = config.aiProvider || 'gemini';
   const availableProviders = getAvailableProviders(config);
-  const alternates = availableProviders.filter(p => p !== provider);
-  return [provider, ...alternates];
+  const ordered = availableProviders.includes(provider)
+    ? [provider, ...availableProviders.filter(p => p !== provider)]
+    : availableProviders;
+  return ordered.length > 0 ? ordered : ['gemini'];
+}
+
+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);
+  }
 }
 
 // Chat session — maintains conversation history within the session
 let chat = null;
 let activeModel = resolveGeminiModel();
 let lastLoggedModel = '';
-const MAX_HISTORY_MESSAGES = 20; // Keep only the last 20 messages (approx 10 turns)
+const MAX_HISTORY_MESSAGES = 40; // Increased context for deeper reasoning
+const MAX_STORED_HISTORY_MESSAGES = 200;
 
 function createChat(history = []) {
   // Truncate history and strip custom fields like 'timestamp' before passing to SDK
   const cleanedHistory = (history || []).map(msg => ({
     role: msg.role,
-    parts: msg.parts
+    parts: msg.parts.map(part => {
+        if (part.text) {
+            return { ...part, text: stripRelevantMemoryBlock(part.text) };
+        }
+        return part;
+    })
   }));
   const truncatedHistory = cleanedHistory.slice(-MAX_HISTORY_MESSAGES);
 
@@ -251,28 +395,28 @@ async function handleChat(message, base64Image = null, base64Audio = null) {
         const currentProv = providersToTry[i];
         try {
             if (currentProv === 'ollama') {
-                return await handleOllamaChat(finalMessage, base64Image, base64Audio, config);
+                return withProviderInfo(await handleOllamaChat(finalMessage, base64Image, base64Audio, config), currentProv, config);
             }
             if (currentProv === 'anthropic') {
-                return await handleAnthropicChat(finalMessage, base64Image, config);
+                return withProviderInfo(await handleAnthropicChat(finalMessage, base64Image, config), currentProv, config);
             }
             if (currentProv === 'openai') {
-                return await handleOpenAIChat(finalMessage, base64Image, config);
+                return withProviderInfo(await handleOpenAIChat(finalMessage, base64Image, config), currentProv, config);
             }
             if (currentProv === 'local_openai') {
-                return await handleLocalOpenAIChat(finalMessage, base64Image, config);
+                return withProviderInfo(await handleLocalOpenAIChat(finalMessage, base64Image, config), currentProv, config);
             }
             if (currentProv === 'huggingface') {
-                return await handleHuggingFaceChat(finalMessage, base64Image, config);
+                return withProviderInfo(await handleHuggingFaceChat(finalMessage, base64Image, config), currentProv, config);
             }
 
             const currentKey = resolveApiKey();
             if (!currentKey) {
                 if (i === providersToTry.length - 1) {
-                    return {
+                    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;
@@ -283,7 +427,7 @@ async function handleChat(message, base64Image = null, base64Audio = null) {
                 createChat(readChatHistory());
             }
 
-            return await handleGeminiChat(finalMessage, base64Image, base64Audio);
+            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) {
@@ -302,8 +446,9 @@ async function handleChat(message, base64Image = null, base64Audio = null) {
 
 async function handleGeminiChat(finalMessage, base64Image, base64Audio) {
   try {
+    const images = normalizeImageList(base64Image);
     // 1. Check cache first for text-only messages
-    if (finalMessage && !base64Image && !base64Audio) {
+    if (finalMessage && images.length === 0 && !base64Audio) {
         const cached = memoryStore.getCachedResponse(finalMessage);
         if (cached) return cached;
     }
@@ -316,18 +461,18 @@ async function handleGeminiChat(finalMessage, base64Image, base64Audio) {
     let aiResponse;
     const parts = [];
     if (finalMessage) {
-        parts.push({ text: finalMessage });
-    } else if (base64Audio && !base64Image) {
+        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 (!base64Image && !base64Audio) {
+    } else if (images.length === 0 && !base64Audio) {
         parts.push({ text: "Analyze this input." });
     }
 
-    if (base64Image) {
-        const base64Data = base64Image.replace(/^data:image\/\w+;base64,/, '');
+    for (const item of images) {
+        const image = imageDataUriToInlineData(item);
         parts.push({
-            inlineData: { mimeType: "image/png", data: base64Data }
+            inlineData: image
         });
     }
 
@@ -362,7 +507,7 @@ async function handleGeminiChat(finalMessage, base64Image, base64Audio) {
         if (!msg.timestamp) msg.timestamp = now;
     }
 
-    writeChatHistory(history);
+    writeChatHistory(cleanHistoryForStorage(history));
 
     let outputText = '';
     try {
@@ -372,6 +517,8 @@ async function handleGeminiChat(finalMessage, base64Image, base64Audio) {
         outputText = String(aiResponse || '');
     }
 
+    outputText = stripRelevantMemoryBlock(outputText);
+
     let parsedResult;
     try {
       parsedResult = JSON.parse(outputText);
@@ -392,9 +539,11 @@ async function handleGeminiChat(finalMessage, base64Image, base64Audio) {
     // 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)
@@ -402,7 +551,7 @@ async function handleGeminiChat(finalMessage, base64Image, base64Audio) {
         setImmediate(() => {
             memoryStore.recordInteraction(finalMessage, parsedResult.response);
             // Cache text-only responses
-            if (!base64Image && !base64Audio) {
+            if (images.length === 0 && !base64Audio) {
                 memoryStore.cacheResponse(finalMessage, parsedResult);
             }
         });
@@ -423,8 +572,9 @@ async function handleGeminiChat(finalMessage, base64Image, base64Audio) {
 // ─────────────────────────────────────────────────────────────────────────────
 async function* handleGeminiChatStream(finalMessage, base64Image, base64Audio) {
   try {
+    const images = normalizeImageList(base64Image);
     // 1. Check cache first
-    if (finalMessage && !base64Image && !base64Audio) {
+    if (finalMessage && images.length === 0 && !base64Audio) {
         const cached = memoryStore.getCachedResponse(finalMessage);
         if (cached) {
             yield { chunk: `{"response":"${cached.response.replace(/"/g, '\\"')}", "action": {"type":"none"}}` };
@@ -440,15 +590,14 @@ async function* handleGeminiChatStream(finalMessage, base64Image, base64Audio) {
 
     const parts = [];
     if (finalMessage) {
-        parts.push({ text: finalMessage });
-    } else if (base64Audio && !base64Image) {
+        parts.push({ text: buildMessageWithRelevantMemory(finalMessage) });
+    } else if (base64Audio && images.length === 0) {
         parts.push({ text: "Please listen to this voice command and respond in Thai with the appropriate JSON action if needed." });
-    } else if (!base64Image && !base64Audio) {
+    } else if (images.length === 0 && !base64Audio) {
         parts.push({ text: "Analyze this input." });
     }
-    if (base64Image) {
-        const base64Data = base64Image.replace(/^data:image\/\w+;base64,/, '');
-        parts.push({ inlineData: { mimeType: "image/png", data: base64Data } });
+    for (const item of images) {
+        parts.push({ inlineData: imageDataUriToInlineData(item) });
     }
     if (base64Audio) {
         let mimeType = "audio/webm";
@@ -468,10 +617,12 @@ async function* handleGeminiChatStream(finalMessage, base64Image, base64Audio) {
         } catch (_) {}
         if (chunkText) {
             fullText += chunkText;
-            yield { chunk: chunkText };
+            yield { chunk: stripRelevantMemoryBlock(chunkText) };
         }
     }
 
+    fullText = stripRelevantMemoryBlock(fullText);
+
     // Save history
     const history = await chat.getHistory();
     const now = new Date().toISOString();
@@ -481,7 +632,7 @@ async function* handleGeminiChatStream(finalMessage, base64Image, base64Audio) {
         if (!modelMsg.timestamp) modelMsg.timestamp = now;
         if (!userMsg.timestamp)  userMsg.timestamp  = now;
     }
-    writeChatHistory(history);
+    writeChatHistory(cleanHistoryForStorage(history));
 
     // Parse complete JSON response
     let parsedResult;
@@ -497,7 +648,9 @@ async function* handleGeminiChatStream(finalMessage, base64Image, base64Audio) {
     }
     if (parsedResult && typeof parsedResult.response === 'string') {
         parsedResult.response = decodeUnicode(parsedResult.response);
+        parsedResult.response = stripRelevantMemoryBlock(parsedResult.response);
     }
+    validateParsedAction(parsedResult);
     parsedResult.timestamp = now;
 
     // Record for long-term memory
@@ -505,7 +658,7 @@ async function* handleGeminiChatStream(finalMessage, base64Image, base64Audio) {
         setImmediate(() => {
             memoryStore.recordInteraction(finalMessage, parsedResult.response);
             // Cache text-only responses
-            if (!base64Image && !base64Audio) {
+            if (images.length === 0 && !base64Audio) {
                 memoryStore.cacheResponse(finalMessage, parsedResult);
             }
         });
@@ -521,8 +674,9 @@ 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 (!apiKey) return { response: "กรุณาใส่ Anthropic API Key ในการตั้งค่าก่อนนะคะ", action: { type: "none" } };
+    if (isPlaceholder(apiKey)) return { response: "กรุณาใส่ Anthropic API Key ในการตั้งค่าก่อนนะคะ", action: { type: "none" } };
 
     const systemPrompt = buildSystemPrompt();
     
@@ -534,12 +688,11 @@ async function handleAnthropicChat(finalMessage, base64Image, config) {
     }
 
     const content = [];
-    if (base64Image) {
-        const base64Data = base64Image.replace(/^data:image\/\w+;base64,/, '');
-        const mimeType = base64Image.match(/^data:(image\/\w+);base64,/)[1];
+    for (const item of images) {
+        const image = imageDataUriToInlineData(item);
         content.push({
             type: "image",
-            source: { type: "base64", media_type: mimeType, data: base64Data }
+            source: { type: "base64", media_type: image.mimeType, data: image.data }
         });
     }
     content.push({ type: "text", text: finalMessage || "Analyze this." });
@@ -561,15 +714,16 @@ async function handleAnthropicChat(finalMessage, base64Image, config) {
     const outputText = response.data.content[0].text;
     history.push({ role: 'user', parts: [{ text: finalMessage }] });
     history.push({ role: 'model', parts: [{ text: outputText }] });
-    writeChatHistory(history.slice(-MAX_HISTORY_MESSAGES));
+    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 (!apiKey) return { response: "กรุณาใส่ OpenAI API Key ในการตั้งค่าก่อนนะคะ", action: { type: "none" } };
+    if (isPlaceholder(apiKey)) return { response: "กรุณาใส่ OpenAI API Key ในการตั้งค่าก่อนนะคะ", action: { type: "none" } };
 
     const systemPrompt = buildSystemPrompt();
     
@@ -581,10 +735,10 @@ async function handleOpenAIChat(finalMessage, base64Image, config) {
     }
 
     const content = [{ type: "text", text: finalMessage || "Analyze this." }];
-    if (base64Image) {
+    for (const item of images) {
         content.push({
             type: "image_url",
-            image_url: { url: base64Image }
+            image_url: { url: item }
         });
     }
     messages.push({ role: "user", content });
@@ -603,13 +757,14 @@ async function handleOpenAIChat(finalMessage, base64Image, config) {
     const outputText = response.data.choices[0].message.content;
     history.push({ role: 'user', parts: [{ text: finalMessage }] });
     history.push({ role: 'model', parts: [{ text: outputText }] });
-    writeChatHistory(history.slice(-MAX_HISTORY_MESSAGES));
+    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';
 
@@ -623,10 +778,10 @@ async function handleLocalOpenAIChat(finalMessage, base64Image, config) {
     }
 
     const content = [{ type: "text", text: finalMessage || "Analyze this." }];
-    if (base64Image) {
+    for (const item of images) {
         content.push({
             type: "image_url",
-            image_url: { url: base64Image }
+            image_url: { url: item }
         });
     }
     messages.push({ role: "user", content });
@@ -648,15 +803,16 @@ async function handleLocalOpenAIChat(finalMessage, base64Image, config) {
     const outputText = response.data.choices[0].message.content;
     history.push({ role: 'user', parts: [{ text: finalMessage }] });
     history.push({ role: 'model', parts: [{ text: outputText }] });
-    writeChatHistory(history.slice(-MAX_HISTORY_MESSAGES));
+    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 (!apiKey) return { response: "กรุณาใส่ Hugging Face API Key ในการตั้งค่าก่อนนะคะ", action: { type: "none" } };
+    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`;
@@ -671,10 +827,10 @@ async function handleHuggingFaceChat(finalMessage, base64Image, config) {
     }
 
     const content = [{ type: "text", text: finalMessage || "Analyze this." }];
-    if (base64Image) {
+    for (const item of images) {
         content.push({
             type: "image_url",
-            image_url: { url: base64Image }
+            image_url: { url: item }
         });
     }
     messages.push({ role: "user", content });
@@ -693,7 +849,7 @@ async function handleHuggingFaceChat(finalMessage, base64Image, config) {
     const outputText = response.data.choices[0].message.content;
     history.push({ role: 'user', parts: [{ text: finalMessage }] });
     history.push({ role: 'model', parts: [{ text: outputText }] });
-    writeChatHistory(history.slice(-MAX_HISTORY_MESSAGES));
+    writeChatHistory(cleanHistoryForStorage(history.slice(-MAX_STORED_HISTORY_MESSAGES)));
 
     return parseAiResponse(outputText);
 }
@@ -713,12 +869,14 @@ function parseAiResponse(outputText) {
     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() }
@@ -735,11 +893,11 @@ async function handleOllamaChat(finalMessage, base64Image, base64Audio, config)
     
     let currentContent = finalMessage || 'Analyze this input.';
     let images = [];
-    if (base64Image) {
-        images.push(base64Image.replace(/^data:image\/\w+;base64,/, ''));
+    for (const item of imageInputs) {
+        images.push(imageDataUriToBase64(item));
     }
     
-    if (base64Audio && !base64Image && !finalMessage) {
+    if (base64Audio && imageInputs.length === 0 && !finalMessage) {
         currentContent = "Please analyze this audio requirement based on text if any was transacted, otherwise reply with appropriate action.";
     }
     
@@ -760,7 +918,7 @@ async function handleOllamaChat(finalMessage, base64Image, base64Audio, config)
     
     history.push({ role: 'user', parts: [{ text: currentContent }] });
     history.push({ role: 'model', parts: [{ text: outputText }] });
-    writeChatHistory(history.slice(-MAX_HISTORY_MESSAGES));
+    writeChatHistory(cleanHistoryForStorage(history.slice(-MAX_STORED_HISTORY_MESSAGES)));
     
     let parsedResult;
     try {
@@ -773,11 +931,13 @@ async function handleOllamaChat(finalMessage, base64Image, base64Audio, config)
             parsedResult = { response: outputText, action: { type: "none", target: "" } };
         }
     }
+    validateParsedAction(parsedResult);
     return parsedResult;
 }
 
 function resetChat() {
   clearChatHistory();
+  memoryStore.clearConversationScopedProfile();
   createChat([]);
   console.log("Chat history cleared.");
 }
@@ -800,7 +960,7 @@ function historyToTranscript(history) {
     const sender = content.role === 'user' ? 'user' : 'ai';
     let text = Array.isArray(content.parts)
       ? content.parts
-        .map((part) => typeof part.text === 'string' ? part.text : '')
+        .map((part) => typeof part.text === 'string' ? stripRelevantMemoryBlock(part.text) : '')
         .filter(Boolean)
         .join('\n')
       : '';
@@ -820,16 +980,14 @@ function historyToTranscript(history) {
     transcript.push({ 
         sender, 
         text, 
-        timestamp: content.timestamp || new Date().toISOString() 
+        timestamp: content.timestamp || new Date().toISOString(),
+        providerInfo: content.providerInfo || null
     });
   }
   return transcript;
 }
 
 async function getChatTranscript() {
-    if (chat) {
-        return historyToTranscript(await chat.getHistory(true));
-    }
     return historyToTranscript(readChatHistory());
 }
 
@@ -851,7 +1009,7 @@ async function translateImageContent(base64Image) {
     const retryDelayMs = [1000, 2500];
 
     try {
-        const base64Data = base64Image.replace(/^data:image\/\w+;base64,/, '');
+        const image = imageDataUriToInlineData(base64Image);
         for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
             try {
                 const response = await ai.models.generateContent({
@@ -861,7 +1019,7 @@ async function translateImageContent(base64Image) {
                             role: 'user',
                             parts: [
                                 { text: "Extract any English text you see in this image and translate it to Thai. Return ONLY the Thai translation. If there is no text, return 'ไม่พบข้อความ'." },
-                                { inlineData: { mimeType: "image/png", data: base64Data } }
+                                { inlineData: image }
                             ]
                         }
                     ]