neoagent 2.1.11 → 2.1.12

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "neoagent",
-  "version": "2.1.11",
+  "version": "2.1.12",
   "description": "Proactive personal AI agent with no limits",
   "license": "MIT",
   "main": "server/index.js",

package/server/public/flutter_bootstrap.js

@@ -37,6 +37,6 @@ _flutter.buildConfig = {"engineRevision":"052f31d115eceda8cbff1b3481fcde4330c4ae
 
 _flutter.loader.load({
   serviceWorkerSettings: {
-    serviceWorkerVersion: "1464466977" /* Flutter's service worker is deprecated and will be removed in a future Flutter release. */
+    serviceWorkerVersion: "2032032802" /* Flutter's service worker is deprecated and will be removed in a future Flutter release. */
   }
 });

package/server/services/ai/engine.js

@@ -7,6 +7,7 @@ const { ensureDefaultAiSettings, getAiSettings } = require('./settings');
 const { selectToolsForTask } = require('./toolSelector');
 const { compactToolResult } = require('./toolResult');
 const { salvageTextToolCalls } = require('./toolCallSalvage');
+const { sanitizeModelOutput } = require('./outputSanitizer');
 
 function generateTitle(task) {
   if (!task || typeof task !== 'string') return 'Untitled';
@@ -300,13 +301,16 @@ class AgentEngine {
         });
       }
     };
-    const { provider, model, providerName } = await getProviderForUser(
+    const selectedProvider = await getProviderForUser(
       userId,
       userMessage,
       triggerType === 'subagent',
       _modelOverride,
       providerStatusConfig
     );
+    let provider = selectedProvider.provider;
+    let model = selectedProvider.model;
+    let providerName = selectedProvider.providerName;
 
     const runTitle = generateTitle(userMessage);
     db.prepare(`INSERT OR REPLACE INTO agent_runs(id, user_id, title, status, trigger_type, trigger_source, model)
@@ -381,6 +385,7 @@ class AgentEngine {
         this.emit(userId, 'run:thinking', { runId, iteration });
 
         let response;
+        let responseModel = model;
         let streamContent = '';
         const callOptions = { model, reasoningEffort: this.getReasoningEffort(providerName, options) };
 
@@ -391,22 +396,30 @@ class AgentEngine {
               for await (const chunk of gen) {
                 if (chunk.type === 'content') {
                   streamContent += chunk.content;
-                  this.emit(userId, 'run:stream', { runId, content: streamContent, iteration });
+                  this.emit(userId, 'run:stream', {
+                    runId,
+                    content: sanitizeModelOutput(streamContent, { model }),
+                    iteration
+                  });
                 }
                 if (chunk.type === 'done') {
                   response = chunk;
+                  responseModel = model;
                 }
                 if (chunk.type === 'tool_calls') {
                   response = {
                     content: chunk.content || streamContent,
                     toolCalls: chunk.toolCalls,
+                    providerContentBlocks: chunk.providerContentBlocks || null,
                     finishReason: 'tool_calls',
                     usage: chunk.usage || null
                   };
+                  responseModel = model;
                 }
               }
             } else {
               response = await provider.chat(messages, tools, callOptions);
+              responseModel = model;
             }
           } catch (err) {
             console.error(`[Engine] Model call failed (${model}):`, err.message);
@@ -419,33 +432,42 @@ class AgentEngine {
                 aiSettings.fallback_model_id,
                 providerStatusConfig
               );
-              // Update local state for the retry
-              const nextProvider = fallback.provider;
-              const nextModel = fallback.model;
-              const nextProviderName = fallback.providerName;
+              provider = fallback.provider;
+              model = fallback.model;
+              providerName = fallback.providerName;
 
               // Recursive call once
-              const retryOptions = { ...callOptions, model: nextModel, reasoningEffort: this.getReasoningEffort(nextProviderName, options) };
+              const retryOptions = { ...callOptions, model, reasoningEffort: this.getReasoningEffort(providerName, options) };
 
               if (options.stream !== false) {
-                const gen = nextProvider.stream(messages, tools, retryOptions);
+                const gen = provider.stream(messages, tools, retryOptions);
                 for await (const chunk of gen) {
                   if (chunk.type === 'content') {
                     streamContent += chunk.content;
-                    this.emit(userId, 'run:stream', { runId, content: streamContent, iteration });
+                    this.emit(userId, 'run:stream', {
+                      runId,
+                      content: sanitizeModelOutput(streamContent, { model }),
+                      iteration
+                    });
+                  }
+                  if (chunk.type === 'done') {
+                    response = chunk;
+                    responseModel = model;
                   }
-                  if (chunk.type === 'done') response = chunk;
                   if (chunk.type === 'tool_calls') {
                     response = {
                       content: chunk.content || streamContent,
                       toolCalls: chunk.toolCalls,
+                      providerContentBlocks: chunk.providerContentBlocks || null,
                       finishReason: 'tool_calls',
                       usage: chunk.usage || null
                     };
+                    responseModel = model;
                   }
                 }
               } else {
-                response = await nextProvider.chat(messages, tools, retryOptions);
+                response = await provider.chat(messages, tools, retryOptions);
+                responseModel = model;
               }
             } else {
               throw err;
@@ -463,7 +485,7 @@ class AgentEngine {
           totalTokens += response.usage.totalTokens || 0;
         }
 
-        lastContent = response.content || streamContent || '';
+        lastContent = sanitizeModelOutput(response.content || streamContent || '', { model: responseModel });
 
         if ((!response.toolCalls || response.toolCalls.length === 0) && lastContent) {
           const salvaged = salvageTextToolCalls(lastContent, tools);
@@ -477,6 +499,7 @@ class AgentEngine {
 
         const assistantMessage = { role: 'assistant', content: lastContent };
         if (response.toolCalls?.length) assistantMessage.tool_calls = response.toolCalls;
+        if (response.providerContentBlocks?.length) assistantMessage.providerContentBlocks = response.providerContentBlocks;
         messages.push(assistantMessage);
 
         if (conversationId) {
@@ -583,10 +606,14 @@ class AgentEngine {
           model,
           reasoningEffort: this.getReasoningEffort(providerName, options)
         });
-        lastContent = finalResponse.content || '';
+        lastContent = sanitizeModelOutput(finalResponse.content || '', { model });
         forcedFinalResponse = true;
 
-        messages.push({ role: 'assistant', content: lastContent });
+        const finalAssistantMessage = { role: 'assistant', content: lastContent };
+        if (finalResponse.providerContentBlocks?.length) {
+          finalAssistantMessage.providerContentBlocks = finalResponse.providerContentBlocks;
+        }
+        messages.push(finalAssistantMessage);
         if (conversationId) {
           db.prepare('INSERT INTO conversation_messages (conversation_id, role, content, tokens) VALUES (?, ?, ?, ?)')
             .run(conversationId, 'assistant', lastContent, finalResponse.usage?.totalTokens || 0);

package/server/services/ai/outputSanitizer.js

@@ -0,0 +1,67 @@
+const { sanitizeStreamingToolCallText } = require('./toolCallSalvage');
+
+const HAN_CHAR_REGEX = /\p{Script=Han}/gu;
+const LATIN_CHAR_REGEX = /\p{Script=Latin}/gu;
+const LETTER_CHAR_REGEX = /\p{L}/gu;
+const HAN_RUN_REGEX = /[\p{Script=Han}\u3000-\u303F]+/gu;
+const MARKDOWN_CODE_SPAN_REGEX = /(```[\s\S]*?```|`[^`\n]+`)/g;
+
+function countMatches(text, regex) {
+  const matches = text.match(regex);
+  return matches ? matches.length : 0;
+}
+
+function shouldStripIncidentalHan(text, model) {
+  if (model !== 'MiniMax-M2.7') return false;
+
+  const hanCount = countMatches(text, HAN_CHAR_REGEX);
+  if (hanCount === 0) return false;
+  if (hanCount > 24) return false;
+
+  const latinCount = countMatches(text, LATIN_CHAR_REGEX);
+  if (latinCount < 20) return false;
+
+  const letterCount = countMatches(text, LETTER_CHAR_REGEX);
+  if (letterCount > 0 && (hanCount / letterCount) > 0.18) return false;
+
+  return true;
+}
+
+function sanitizePlainText(text) {
+  return text
+    .replace(/([\p{L}\p{N}])[\p{Script=Han}\u3000-\u303F]+([\p{L}\p{N}])/gu, '$1 $2')
+    .replace(HAN_RUN_REGEX, '')
+    .replace(/[ \t]{2,}/g, ' ')
+    .replace(/[ \t]+\n/g, '\n')
+    .replace(/\n[ \t]+/g, '\n')
+    .replace(/[ \t]+([,.;:!?)\]}])/g, '$1')
+    .replace(/([([{])\s+/g, '$1');
+}
+
+function sanitizeMarkdownAware(text) {
+  return text
+    .split(MARKDOWN_CODE_SPAN_REGEX)
+    .map((part) => {
+      if (!part) return part;
+      if (part.startsWith('```') || part.startsWith('`')) return part;
+      return sanitizePlainText(part);
+    })
+    .join('');
+}
+
+function sanitizeModelOutput(text, options = {}) {
+  if (typeof text !== 'string' || text.length === 0) return text;
+
+  let sanitized = text;
+
+  if (options.model === 'MiniMax-M2.7' && (sanitized.includes('<invoke') || sanitized.includes(':tool_call'))) {
+    sanitized = sanitizeStreamingToolCallText(sanitized);
+  }
+
+  if (!shouldStripIncidentalHan(sanitized, options.model)) return sanitized;
+  return sanitizeMarkdownAware(sanitized);
+}
+
+module.exports = {
+  sanitizeModelOutput
+};

package/server/services/ai/providers/anthropic.js

@@ -37,6 +37,50 @@ class AnthropicProvider extends BaseProvider {
     }));
   }
 
+  normalizeContentBlocks(blocks = []) {
+    const normalized = [];
+
+    for (const block of blocks) {
+      if (!block || !block.type) continue;
+
+      if (block.type === 'thinking') {
+        normalized.push({
+          type: 'thinking',
+          thinking: block.thinking || '',
+          ...(block.signature ? { signature: block.signature } : {})
+        });
+        continue;
+      }
+
+      if (block.type === 'redacted_thinking') {
+        normalized.push({
+          type: 'redacted_thinking',
+          data: block.data
+        });
+        continue;
+      }
+
+      if (block.type === 'text') {
+        normalized.push({
+          type: 'text',
+          text: block.text || ''
+        });
+        continue;
+      }
+
+      if (block.type === 'tool_use') {
+        normalized.push({
+          type: 'tool_use',
+          id: block.id,
+          name: block.name,
+          input: block.input || {}
+        });
+      }
+    }
+
+    return normalized;
+  }
+
   convertMessages(messages) {
     let system = '';
     const converted = [];
@@ -60,6 +104,14 @@ class AnthropicProvider extends BaseProvider {
       }
 
       if (msg.role === 'assistant' && msg.tool_calls) {
+        if (Array.isArray(msg.providerContentBlocks) && msg.providerContentBlocks.length > 0) {
+          converted.push({
+            role: 'assistant',
+            content: this.normalizeContentBlocks(msg.providerContentBlocks)
+          });
+          continue;
+        }
+
         const content = [];
         if (msg.content) content.push({ type: 'text', text: msg.content });
         for (const tc of msg.tool_calls) {
@@ -100,6 +152,7 @@ class AnthropicProvider extends BaseProvider {
 
     let content = '';
     const toolCalls = [];
+    const providerContentBlocks = this.normalizeContentBlocks(response.content);
 
     for (const block of response.content) {
       if (block.type === 'text') {
@@ -119,6 +172,7 @@ class AnthropicProvider extends BaseProvider {
     return {
       content,
       toolCalls,
+      providerContentBlocks,
       finishReason: response.stop_reason === 'tool_use' ? 'tool_calls' : 'stop',
       usage: {
         promptTokens: response.usage.input_tokens,
@@ -148,31 +202,106 @@ class AnthropicProvider extends BaseProvider {
     let content = '';
     let currentToolCalls = [];
     let currentToolIndex = -1;
+    const providerContentBlocks = [];
 
     for await (const event of stream) {
       if (event.type === 'content_block_start') {
-        if (event.content_block.type === 'tool_use') {
+        if (event.content_block.type === 'thinking') {
+          providerContentBlocks[event.index] = {
+            type: 'thinking',
+            thinking: event.content_block.thinking || '',
+            signature: event.content_block.signature || ''
+          };
+        } else if (event.content_block.type === 'redacted_thinking') {
+          providerContentBlocks[event.index] = {
+            type: 'redacted_thinking',
+            data: event.content_block.data
+          };
+        } else if (event.content_block.type === 'text') {
+          providerContentBlocks[event.index] = {
+            type: 'text',
+            text: event.content_block.text || ''
+          };
+        } else if (event.content_block.type === 'tool_use') {
           currentToolIndex++;
           currentToolCalls.push({
             id: event.content_block.id,
             type: 'function',
             function: { name: event.content_block.name, arguments: '' }
           });
+          providerContentBlocks[event.index] = {
+            type: 'tool_use',
+            id: event.content_block.id,
+            name: event.content_block.name,
+            input: {}
+          };
         }
       } else if (event.type === 'content_block_delta') {
         if (event.delta.type === 'text_delta') {
           content += event.delta.text;
+          if (providerContentBlocks[event.index]?.type === 'text') {
+            providerContentBlocks[event.index].text += event.delta.text;
+          }
           yield { type: 'content', content: event.delta.text };
+        } else if (event.delta.type === 'thinking_delta') {
+          if (providerContentBlocks[event.index]?.type === 'thinking') {
+            providerContentBlocks[event.index].thinking += event.delta.thinking || '';
+          }
+        } else if (event.delta.type === 'signature_delta') {
+          if (providerContentBlocks[event.index]?.type === 'thinking') {
+            providerContentBlocks[event.index].signature = event.delta.signature || '';
+          }
         } else if (event.delta.type === 'input_json_delta') {
           if (currentToolCalls[currentToolIndex]) {
             currentToolCalls[currentToolIndex].function.arguments += event.delta.partial_json;
           }
+          if (providerContentBlocks[event.index]?.type === 'tool_use') {
+            const currentJson = providerContentBlocks[event.index]._inputJson || '';
+            providerContentBlocks[event.index]._inputJson = currentJson + (event.delta.partial_json || '');
+          }
         }
       } else if (event.type === 'message_stop') {
+        const normalizedBlocks = providerContentBlocks
+          .filter(Boolean)
+          .map((block) => {
+            if (block.type === 'tool_use') {
+              let parsedInput = block.input || {};
+              if (typeof block._inputJson === 'string' && block._inputJson.trim()) {
+                try {
+                  parsedInput = JSON.parse(block._inputJson);
+                } catch { }
+              }
+              return {
+                type: 'tool_use',
+                id: block.id,
+                name: block.name,
+                input: parsedInput
+              };
+            }
+            if (block.type === 'thinking') {
+              return {
+                type: 'thinking',
+                thinking: block.thinking || '',
+                ...(block.signature ? { signature: block.signature } : {})
+              };
+            }
+            if (block.type === 'redacted_thinking') {
+              return {
+                type: 'redacted_thinking',
+                data: block.data
+              };
+            }
+            return {
+              type: 'text',
+              text: block.text || ''
+            };
+          });
+
         yield {
           type: 'done',
           content,
           toolCalls: currentToolCalls,
+          providerContentBlocks: normalizedBlocks,
           finishReason: currentToolCalls.length > 0 ? 'tool_calls' : 'stop',
           usage: null
         };

package/server/services/ai/toolCallSalvage.js

@@ -3,14 +3,38 @@ const { v4: uuidv4 } = require('uuid')
 const INVOKE_OPEN_RE = /(?:[A-Za-z0-9_.-]+:tool_call\s*)?<invoke\s+name="([^"]+)">/g
 const PARAM_OPEN_RE = /<parameter\s+name="([^"]+)">/g
 const PARAM_CLOSED_RE = /<parameter\s+name="([^"]+)">([\s\S]*?)<\/parameter>/g
+const TOOL_WRAPPER_RE = /<\/?[A-Za-z0-9_.-]+:tool_call>/g
+const COMPLETE_INLINE_CALL_RE = /(?:[A-Za-z0-9_.-]+:tool_call\s*)?<invoke\s+name="[^"]+">[\s\S]*?<\/invoke>/g
 const INVOKE_CLOSE = '</invoke>'
 
 function trimLooseControlText(text) {
   return String(text || '')
+    .replace(TOOL_WRAPPER_RE, '')
     .replace(/(?:^|\s)[A-Za-z0-9_.-]+:tool_call\s*$/g, '')
     .trim()
 }
 
+function sanitizeStreamingToolCallText(text) {
+  let visible = String(text || '')
+    .replace(COMPLETE_INLINE_CALL_RE, '')
+    .replace(TOOL_WRAPPER_RE, '')
+
+  const partialStarts = [
+    visible.lastIndexOf('<invoke'),
+    visible.lastIndexOf(':tool_call')
+  ].filter((index) => index >= 0)
+
+  if (partialStarts.length > 0) {
+    const partialStart = Math.max(...partialStarts)
+    const suffix = visible.slice(partialStart)
+    if (!suffix.includes(INVOKE_CLOSE)) {
+      visible = visible.slice(0, partialStart)
+    }
+  }
+
+  return trimLooseControlText(visible).replace(/\n{3,}/g, '\n\n')
+}
+
 function parseParameterMap(body) {
   const args = {}
   let sawClosedParam = false
@@ -113,5 +137,6 @@ function salvageTextToolCalls(content, tools = []) {
 }
 
 module.exports = {
-  salvageTextToolCalls
+  salvageTextToolCalls,
+  sanitizeStreamingToolCallText
 }

package/server/services/android/controller.js

@@ -64,6 +64,25 @@ function commandExists(command) {
   return probe.status === 0;
 }
 
+function parseResolvedLaunchComponent(output, packageName) {
+  const lines = String(output || '')
+    .split('\n')
+    .map((line) => line.trim())
+    .filter(Boolean);
+  const normalizedPackage = String(packageName || '').trim();
+  const componentPattern = /^[A-Za-z0-9._$]+\/[A-Za-z0-9._$]+$/;
+  const relativePattern = /^[A-Za-z0-9._$]+\/\.[A-Za-z0-9._$]+$/;
+
+  const exact = lines.find((line) =>
+    normalizedPackage
+      ? line.startsWith(`${normalizedPackage}/`)
+      : componentPattern.test(line) || relativePattern.test(line)
+  );
+  if (exact) return exact;
+
+  return lines.find((line) => componentPattern.test(line) || relativePattern.test(line)) || null;
+}
+
 function appendState(patch) {
   const current = readState();
   const next = {
@@ -1305,7 +1324,20 @@ class AndroidController {
     if (args.activity) {
       await this.#adb(serial, `shell am start -n ${quoteShell(`${args.packageName}/${args.activity}`)}`, { timeout: 20000 });
     } else if (args.packageName) {
-      await this.#adb(serial, `shell monkey -p ${quoteShell(args.packageName)} -c android.intent.category.LAUNCHER 1`, { timeout: 30000 });
+      const resolved = await this.#runAllowFailure(
+        `${quoteShell(adbBinary())} -s ${quoteShell(serial)} shell cmd package resolve-activity --brief -c android.intent.category.LAUNCHER ${quoteShell(args.packageName)}`,
+        { timeout: 15000 },
+      );
+      const component = parseResolvedLaunchComponent(
+        `${resolved.stdout || ''}\n${resolved.stderr || ''}`,
+        args.packageName,
+      );
+
+      if (component) {
+        await this.#adb(serial, `shell am start -n ${quoteShell(component)}`, { timeout: 20000 });
+      } else {
+        await this.#adb(serial, `shell monkey -p ${quoteShell(args.packageName)} -c android.intent.category.LAUNCHER 1`, { timeout: 30000 });
+      }
     } else {
       throw new Error('packageName is required for android_open_app');
     }
@@ -1458,6 +1490,7 @@ module.exports = {
   configuredSystemImagePackage,
   configuredSystemImagePlatform,
   formatSystemImageError,
+  parseResolvedLaunchComponent,
   parseLatestCmdlineToolsUrl,
   parseSystemImages,
   sanitizeUiXml,