nothumanallowed 15.0.13 → 15.0.15

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nothumanallowed",
-  "version": "15.0.13",
+  "version": "15.0.15",
   "description": "NotHumanAllowed — 38 AI agents, 80 tools, Studio (visual agentic workflows). Email, calendar, browser automation, screen capture, canvas, cron/heartbeat, Alexandria E2E messaging, GitHub, Notion, Slack, voice chat, free AI (Liara), 28 languages. Zero-dependency CLI.",
   "type": "module",
   "bin": {

package/src/server/routes/webcraft.mjs

@@ -731,22 +731,30 @@ WORKFLOW:
     const isDone = stepResponse.includes('<done/>') || stepResponse.includes('<done />');
 
     // Extract and execute ALL tool calls from this step
+    // First try matched pairs, then handle truncated (unclosed) tool tags
     const toolRegex = /<tool>([\s\S]*?)<\/tool>/g;
     let match;
     const toolResults = [];
+    const matchedRanges = [];
 
     while ((match = toolRegex.exec(stepResponse)) !== null) {
+      matchedRanges.push([match.index, match.index + match[0].length]);
       let toolCall;
       try {
-        // Fix common JSON issues from LLM
         let raw = match[1].trim();
         raw = raw.replace(/,\s*}/g, '}').replace(/,\s*]/g, ']');
         toolCall = JSON.parse(raw);
-      } catch (parseErr) {
-        console.error('[TOOL-PARSE] JSON parse failed:', parseErr.message, 'raw:', match[1].slice(0, 200));
-        toolResults.push({ op: 'error', result: 'JSON parse failed' });
-        emit({ type: 'tool', op: 'parse_error', path: '', result: 'json_parse_failed' });
-        continue;
+      } catch {
+        // LLM often puts raw HTML/code inside JSON values without proper escaping.
+        // Extract fields manually using a robust regex-based parser.
+        try {
+          toolCall = _parseToolCallRobust(match[1].trim());
+        } catch (parseErr2) {
+          console.error('[TOOL-PARSE] JSON parse failed even after robust parse:', parseErr2.message, 'raw:', match[1].slice(0, 200));
+          toolResults.push({ op: 'error', result: 'JSON parse failed' });
+          emit({ type: 'tool', op: 'parse_error', path: '', result: 'json_parse_failed' });
+          continue;
+        }
       }
 
       const { op, path: relPath, old: oldStr, new: newStr, content, newPath, query, glob: globPat, cmd } = toolCall;
@@ -1067,6 +1075,60 @@ WORKFLOW:
       }
     }
 
+    // Handle truncated tool call — <tool> without </tool> (response cut off by max_tokens)
+    const lastToolOpen = stepResponse.lastIndexOf('<tool>');
+    if (lastToolOpen >= 0) {
+      const alreadyMatched = matchedRanges.some(([start, end]) => lastToolOpen >= start && lastToolOpen < end);
+      if (!alreadyMatched) {
+        const truncatedRaw = stepResponse.slice(lastToolOpen + 6).trim();
+        if (truncatedRaw.length > 20) {
+          console.log('[TOOL-TRUNCATED] Found unclosed <tool> tag, attempting robust parse. Length:', truncatedRaw.length);
+          try {
+            const toolCall = _parseToolCallRobust(truncatedRaw);
+            // Execute the truncated tool call
+            const { op, path: relPath, old: oldStr, new: newStr, content } = toolCall;
+            if (op === 'edit' && relPath && oldStr) {
+              const src = ProjectStore.readFile(projectName, relPath);
+              if (src && src.includes(oldStr)) {
+                const newSrc = src.replace(oldStr, newStr ?? '');
+                ProjectStore.writeFile(projectName, relPath, newSrc);
+                hasChanges = true;
+                modifiedFiles.add(relPath);
+                toolResults.push({ op: 'edit', path: relPath, result: 'ok' });
+                emit({ type: 'tool', op: 'edit', path: relPath, result: 'ok', oldSnippet: oldStr.slice(0, 2000), newSnippet: newStr?.slice(0, 2000) ?? '' });
+                console.log('[TOOL-TRUNCATED] Edit applied successfully from truncated tool call');
+              } else if (src) {
+                // Try fuzzy match
+                const oldLines = oldStr.split('\n').map(l => l.trim());
+                const srcLines = src.split('\n');
+                let matchStart = -1;
+                for (let i = 0; i <= srcLines.length - oldLines.length; i++) {
+                  let ok = true;
+                  for (let j = 0; j < oldLines.length; j++) {
+                    if (srcLines[i + j].trim() !== oldLines[j]) { ok = false; break; }
+                  }
+                  if (ok) { matchStart = i; break; }
+                }
+                if (matchStart >= 0) {
+                  const before = srcLines.slice(0, matchStart).join('\n');
+                  const after = srcLines.slice(matchStart + oldLines.length).join('\n');
+                  const result = (before ? before + '\n' : '') + (newStr ?? '') + (after ? '\n' + after : '');
+                  ProjectStore.writeFile(projectName, relPath, result);
+                  hasChanges = true;
+                  modifiedFiles.add(relPath);
+                  toolResults.push({ op: 'edit', path: relPath, result: 'ok' });
+                  emit({ type: 'tool', op: 'edit', path: relPath, result: 'ok', oldSnippet: oldStr.slice(0, 2000), newSnippet: newStr?.slice(0, 2000) ?? '' });
+                  console.log('[TOOL-TRUNCATED] Edit applied via fuzzy match from truncated tool call');
+                }
+              }
+            }
+          } catch (e) {
+            console.log('[TOOL-TRUNCATED] Failed to parse truncated tool:', e.message);
+          }
+        }
+      }
+    }
+
     // If any edit failed, ignore <done/> — force retry
     const hasFailedEdit = toolResults.some((r) => r.op === 'edit' && (r.result?.includes('not_found') || r.result?.includes('blocked')));
     if (hasFailedEdit && step < MAX_STEPS - 1) {
@@ -2656,6 +2718,93 @@ function _safeName(name) {
   return (name ?? '').replace(/[^a-zA-Z0-9_\-. ]/g, '_').trim() || 'unnamed';
 }
 
+/**
+ * Robust tool call parser for when JSON.parse fails.
+ * The LLM often puts raw HTML/code with unescaped quotes, newlines, < > inside JSON values.
+ * This extracts "op", "path", "old", "new", "content", "query", "cmd" etc. by finding
+ * the key-value boundaries manually.
+ */
+function _parseToolCallRobust(raw) {
+  const result = {};
+
+  // Extract "op" — always a simple string
+  const opMatch = raw.match(/"op"\s*[:>]\s*"([^"]+)"/);
+  if (opMatch) result.op = opMatch[1];
+
+  // Extract "path" — simple string
+  const pathMatch = raw.match(/"path"\s*[:>]\s*"([^"]+)"/);
+  if (pathMatch) result.path = pathMatch[1];
+
+  // Extract "newPath" — simple string
+  const newPathMatch = raw.match(/"newPath"\s*[:>]\s*"([^"]+)"/);
+  if (newPathMatch) result.newPath = newPathMatch[1];
+
+  // Extract "query" — simple string (fix \| to |)
+  const queryMatch = raw.match(/"query"\s*[:>]\s*"([^"]+)"/);
+  if (queryMatch) result.query = queryMatch[1].replace(/\\\|/g, '|');
+
+  // Extract "glob" — simple string
+  const globMatch = raw.match(/"glob"\s*[:>]\s*"([^"]+)"/);
+  if (globMatch) result.glob = globMatch[1];
+
+  // Extract "cmd" — simple string
+  const cmdMatch = raw.match(/"cmd"\s*[:>]\s*"([^"]+)"/);
+  if (cmdMatch) result.cmd = cmdMatch[1];
+
+  // For edit: extract "old" and "new" — these can be HUGE multiline strings with HTML
+  // Strategy: find "old" key, then grab everything until we hit ","new" or the end
+  if (result.op === 'edit') {
+    const oldIdx = raw.indexOf('"old"');
+    const newIdx = raw.indexOf('"new"');
+    if (oldIdx >= 0 && newIdx > oldIdx) {
+      // old value is between "old":"/>" and ","new"
+      let oldStart = raw.indexOf('"', oldIdx + 5); // find opening quote after "old":
+      if (oldStart < 0) oldStart = raw.indexOf('>', oldIdx + 5); // handle "old">
+      if (oldStart >= 0) {
+        oldStart++; // skip the opening quote/bracket
+        // Find the end — look for ","new" pattern
+        const oldEnd = raw.lastIndexOf('"', newIdx - 1);
+        if (oldEnd > oldStart) {
+          result.old = raw.slice(oldStart, oldEnd);
+        }
+      }
+      // new value is after "new":"
+      let newStart = raw.indexOf('"', newIdx + 5);
+      if (newStart < 0) newStart = raw.indexOf('>', newIdx + 5);
+      if (newStart >= 0) {
+        newStart++;
+        // Find end — last " before the closing }
+        const lastBrace = raw.lastIndexOf('}');
+        const newEnd = raw.lastIndexOf('"', lastBrace);
+        if (newEnd > newStart) {
+          result.new = raw.slice(newStart, newEnd);
+        }
+      }
+    }
+  }
+
+  // For write: extract "content"
+  if (result.op === 'write') {
+    const contentIdx = raw.indexOf('"content"');
+    if (contentIdx >= 0) {
+      let contentStart = raw.indexOf('"', contentIdx + 9);
+      if (contentStart < 0) contentStart = raw.indexOf('>', contentIdx + 9);
+      if (contentStart >= 0) {
+        contentStart++;
+        const lastBrace = raw.lastIndexOf('}');
+        const contentEnd = raw.lastIndexOf('"', lastBrace);
+        if (contentEnd > contentStart) {
+          result.content = raw.slice(contentStart, contentEnd);
+        }
+      }
+    }
+  }
+
+  if (!result.op) throw new Error('Could not extract op from tool call');
+  console.log(`[TOOL-PARSE] Robust parse recovered: op=${result.op} path=${result.path} old.len=${result.old?.length ?? 0} new.len=${result.new?.length ?? 0}`);
+  return result;
+}
+
 function _isSafePath(relPath) {
   if (!relPath || typeof relPath !== 'string') return false;
   if (relPath.includes('..') || path.isAbsolute(relPath)) return false;