v1.7.24: Fix naked code / dropped tool calls for Llama-1B/3B models

- Fix A (mcpToolParser): _detectFallbackFileOperations now extracts filePath hints
  from dropped write_file json headers in same response (_hintMap by extension),
  then applies the hint to the subsequent code block instead of falling back to
  generic 'main.ext' / 'index.html' filename

- Fix B (mcpToolParser + agenticChat): repairToolCalls now returns droppedFilePaths.
  processResponse threads them to _detectFallbackFileOperations and returns them
  in result. agenticChat stores _pendingDroppedFilePaths across iterations and passes
  as lastDroppedFilePaths in textOpts so next iteration's code block gets correct
  filename hint when json header was in a previous generation

- Fix C (ChatPanel): Write tool json fences with no content (repair-dropped) now
  set pendingWriteFP instead of rendering 'Skipped' CollapsibleToolBlock.
  Next matching code block renders as proper write_file flat widget with check
  icon, filename label, and Apply button. Language extension must match.

- Fix D (mcpToolParser): _detectFallbackFileOperations now detects large raw
  HTML/code blobs without backtick fences (e.g. 77K dump from 1B context overflow).
  Calls _recoverWriteFileContent directly on the blob, using lastDroppedFilePaths[0]
  as filePath hint if available.

Author: Brendan Gray

main/agenticChat.js

@@ -943,6 +943,7 @@ function register(ctx) {
       // Smart continuation: track tool call patterns for stuck detection
       let recentToolCalls = []; // [{tool, paramsHash}]
       const writeFileHistory = {}; // Track per-filePath write count + peak content length for regression detection
+      let _pendingDroppedFilePaths = []; // filePaths from dropped write_file in previous iter — passed as hint to next processResponse
       const toolFailCounts = {}; // Track per-tool failure counts for enrichErrorFeedback
       let nudgesRemaining = 3; // Allow 3 nudges when model responds with text instead of tool calls
       let contextRotations = 0; // Track how many times we've rotated context
@@ -2091,8 +2092,9 @@ function register(ctx) {
           // ── LEGACY TEXT PARSING PATH ──
           // Use _stitchedForMcp (partial block from previous iter + this iter) so MCP can
           // parse the reconstructed complete tool call when a fence was truncated mid-JSON.
-          const textOpts = { toolPaceMs: localToolPace, skipWriteDeferral: modelTier.tier === 'tiny', userMessage: message };
+          const textOpts = { toolPaceMs: localToolPace, skipWriteDeferral: modelTier.tier === 'tiny', userMessage: message, lastDroppedFilePaths: _pendingDroppedFilePaths };
           toolResults = await mcpToolServer.processResponse(_stitchedForMcp, textOpts);
+          _pendingDroppedFilePaths = toolResults.droppedFilePaths || [];
         }
 
         // Cross-turn duplicate call detection — always active.

main/tools/mcpToolParser.js

@@ -625,6 +625,7 @@ function parseToolCalls(text) {
 function repairToolCalls(toolCalls, responseText) {
   const repaired = [];
   const issues = [];
+  const droppedFilePaths = []; // filePaths from dropped write_file (empty content) — for cross-iter fallback
 
   for (const call of toolCalls) {
     if (!call || typeof call.tool !== 'string') continue;
@@ -645,6 +646,7 @@ function repairToolCalls(toolCalls, responseText) {
         }
         // Unrecoverable — drop it instead of executing an empty write_file
         issues.push(`Dropped write_file: empty content for "${filePath || '(no path)'}" and no recoverable code found in response.`);
+        if (filePath) droppedFilePaths.push(filePath); // track for cross-iter fallback
         continue;
       }
 
@@ -704,7 +706,7 @@ function repairToolCalls(toolCalls, responseText) {
     console.log(`[MCP Repair] ${issues.length} issue(s): ${issues.join(' | ')}`);
   }
 
-  return { repaired, issues };
+  return { repaired, issues, droppedFilePaths };
 }
 
 /**
@@ -903,8 +905,10 @@ async function processResponse(responseText, options = {}) {
   // Fix malformed calls BEFORE execution — recover empty write_file params,
   // drop unrecoverable calls, fix URLs, etc. This prevents tool errors from
   // polluting context and confusing the model for the rest of the session.
+  let _repairDropped = []; // filePaths dropped here — threaded to fallback and returned for next-iter
   if (toolCalls.length > 0) {
-    const { repaired, issues } = repairToolCalls(toolCalls, responseText);
+    const { repaired, issues, droppedFilePaths: _rd } = repairToolCalls(toolCalls, responseText);
+    _repairDropped = _rd || [];
     if (issues.length > 0) {
       console.log(`[MCP] Repair dropped/fixed ${issues.length} call(s)`);
     }
@@ -953,7 +957,7 @@ async function processResponse(responseText, options = {}) {
       toolCalls.push(...proseCommands);
     }
 
-    const fallbackCalls = this._detectFallbackFileOperations(responseText, options.userMessage);
+    const fallbackCalls = this._detectFallbackFileOperations(responseText, options.userMessage, [..._repairDropped, ...(options.lastDroppedFilePaths || [])]);
     if (fallbackCalls.length > 0) {
       console.log('[MCP] Found fallback tool calls:', fallbackCalls.length);
       let effectiveFallbackCalls = fallbackCalls;
@@ -973,10 +977,10 @@ async function processResponse(responseText, options = {}) {
         const result = await this.executeTool(call.tool, call.params || {});
         results.push({ tool: call.tool, params: call.params, result });
       }
-      return { hasToolCalls: true, results, capped: fbCapped, skippedToolCalls: fbSkipped, formalCallCount: 0 };
+      return { hasToolCalls: true, results, capped: fbCapped, skippedToolCalls: fbSkipped, formalCallCount: 0, droppedFilePaths: [] };
     }
     console.log('[MCP] No fallback tool calls either');
-    return { hasToolCalls: false, results: [], formalCallCount: 0 };
+    return { hasToolCalls: false, results: [], formalCallCount: 0, droppedFilePaths: _repairDropped };
   }
 
   // ── Browser Tool Capping ──
@@ -1062,14 +1066,14 @@ async function processResponse(responseText, options = {}) {
     console.log(`[MCP] Browser cap enforced: executed ${browserStateChanges} state-changing actions, skipped ${browserSkipped}`);
   }
 
-  return { hasToolCalls: true, results, capped: capped || browserCapped, skippedToolCalls: skippedCount + browserSkipped, formalCallCount: toolCalls.length };
+  return { hasToolCalls: true, results, capped: capped || browserCapped, skippedToolCalls: skippedCount + browserSkipped, formalCallCount: toolCalls.length, droppedFilePaths: _repairDropped };
 }
 
 /**
  * Fallback detection for file operations when model doesn't use formal tool syntax.
  * Looks for patterns like "```html\n<!DOCTYPE...```" with context suggesting file creation.
  */
-function _detectFallbackFileOperations(responseText, userMessage) {
+function _detectFallbackFileOperations(responseText, userMessage, lastDroppedFilePaths = []) {
   const results = [];
 
   // ── Phase 1: Bash/shell/cmd code blocks → run_command recovery ──
@@ -1114,7 +1118,22 @@ function _detectFallbackFileOperations(responseText, userMessage) {
   // Explicit file-creation intent language is the only reliable signal.
   // However, when the response is PREDOMINANTLY code blocks (>60% by character count),
   // the model likely intended to create files, not explain concepts. Allow fallback in that case.
-  if (!hasFileIntent && !hasCodeBlocksWithLang) return results;
+  // Fix D: Detect large raw HTML/code blobs without backtick fences
+  // (e.g., models that dump HTML directly without tool structure after context rotation)
+  const _isLargeRawCodeBlob = !hasCodeBlocksWithLang && responseText.length > 1500 && (
+    /<html[\s>]|<!doctype\s+html/i.test(responseText) ||
+    (responseText.length > 4000 && /<\/html\s*>/i.test(responseText))
+  );
+  if (!hasFileIntent && !hasCodeBlocksWithLang && !_isLargeRawCodeBlob) return results;
+  if (!hasFileIntent && !hasCodeBlocksWithLang && _isLargeRawCodeBlob) {
+    const _recovered = _recoverWriteFileContent(responseText,
+      lastDroppedFilePaths.length > 0 ? lastDroppedFilePaths[0] : undefined);
+    if (_recovered) {
+      console.log(`[MCP] Fallback: raw code blob (${responseText.length} chars) → write_file "${_recovered.params.filePath}"`);
+      results.push(_recovered);
+    }
+    return results;
+  }
   if (!hasFileIntent && hasCodeBlocksWithLang) {
     // Measure code block ratio to avoid false positives on explanatory code
     const _cbRegex = /```\w+\s*\n([\s\S]*?)```/g;
@@ -1127,6 +1146,7 @@ function _detectFallbackFileOperations(responseText, userMessage) {
 
   const codeBlockRegex = /```(\w+)?\s*\n([\s\S]*?)```/g;
   let match;
+  const _hintMap = {}; // ext→filePath hints extracted from same-response write_file json headers
 
   const filePathPatterns = [
     /(?:(?:create|write|save|make|generate).*?(?:file|document).*?(?:named?|called?|at)?)\s*[`"']([^`"'\n]+\.\w+)[`"']/gi,
@@ -1149,7 +1169,20 @@ function _detectFallbackFileOperations(responseText, userMessage) {
     if (!content || content.length < 10) continue;
 
     // Skip code blocks that look like tool call JSON (already handled by parseToolCalls)
-    if (lang === 'json' && /^\s*\{\s*["']?(?:tool|name)["']?\s*:/.test(content)) continue;
+    // But extract filePath hints from write_file/create_file headers with no content
+    if (lang === 'json' && /^\s*\{\s*["']?(?:tool|name)["']?\s*:/.test(content)) {
+      try {
+        const _jp = JSON.parse(content);
+        const _jt = _jp.tool || _jp.name;
+        const _jfp = _jp.params?.filePath || _jp.params?.file_path || _jp.filePath;
+        if ((_jt === 'write_file' || _jt === 'create_file') && _jfp &&
+            (!_jp.params?.content || String(_jp.params.content).length < 5)) {
+          const _jext = _jfp.includes('.') ? _jfp.split('.').pop().toLowerCase() : '';
+          if (_jext) _hintMap['.' + _jext] = _jfp;
+        }
+      } catch (_e) { /* ignore parse errors */ }
+      continue;
+    }
 
     if (lang === 'python' || lang === 'py') {
       if (/import os|open\s*\(|os\.makedirs|fs\.write/.test(content)) continue;
@@ -1202,6 +1235,23 @@ function _detectFallbackFileOperations(responseText, userMessage) {
       }
     }
 
+    // Use hints: 1) same-response json header (_hintMap), 2) cross-iter dropped filePaths
+    if (!filePath && lang && langToExt[lang] && _hintMap[langToExt[lang]]) {
+      filePath = _hintMap[langToExt[lang]];
+      delete _hintMap[langToExt[lang]]; // consume hint
+      console.log(`[MCP] Fallback: same-response hint "${filePath}" for ${lang} block`);
+    }
+    if (!filePath && lang && langToExt[lang] && lastDroppedFilePaths.length > 0) {
+      const _crossFp = lastDroppedFilePaths.find(fp => {
+        const _fext = fp.includes('.') ? '.' + fp.split('.').pop().toLowerCase() : '';
+        return langToExt[lang] === _fext;
+      });
+      if (_crossFp) {
+        filePath = _crossFp;
+        console.log(`[MCP] Fallback: cross-iter hint "${filePath}" for ${lang} block`);
+      }
+    }
+
     if (!filePath && lang && langToExt[lang]) {
       const folderMatch = textBefore.match(/(?:in|inside|within|to|folder|directory)[:\s]+[`"']?([a-zA-Z_][\w/\\-]*)[`"']?/i);
       const folder = folderMatch ? folderMatch[1].replace(/\\/g, '/') : '';

package.json

@@ -1,6 +1,6 @@
 {
   "name": "guide-ide",
-  "version": "1.7.23",
+  "version": "1.7.24",
   "description": "guIDE - AI-Powered Offline IDE with local LLM, RAG, MCP tools, browser automation, and integrated terminal",
   "author": {
     "name": "Brendan Gray",

src/components/Chat/ChatPanel.tsx

@@ -1541,6 +1541,8 @@ ${e.message}`,
     // ALL tool blocks are collected here — appended as a single ToolCallGroup at the
     // bottom of the message. They are NEVER rendered inline in the text flow.
     const allToolElements: React.ReactElement[] = [];
+    let pendingWriteFP: string | null = null; // filePath from write_file json header with no content — reconnects to next code block
+    let pendingWriteLang = ''; // mapped language for the pending filePath extension
 
     for (let i = 0; i < parts.length; i++) {
       const part = parts[i];
@@ -1575,13 +1577,12 @@ ${e.message}`,
               </div>
             );
           } else if (isWriteTool && !writeContent && !result) {
-            // Write tool was in the response text but had no content and no execution result
-            // — it was dropped by repair (e.g., empty content). Show as skipped, not completed.
-            allToolElements.push(
-              <CollapsibleToolBlock key={`t-${i}`} label={getToolLabel(toolCall, 'fail')} icon="✗">
-                <div className="text-[11px] text-[#858585]">Skipped — no content provided</div>
-              </CollapsibleToolBlock>
-            );
+            // Write tool had no content — model likely emitted json header then code separately.
+            // Track the filePath so the next code block can be rendered as a write_file widget.
+            if (writeFilePath) {
+              pendingWriteFP = writeFilePath;
+              pendingWriteLang = writeLang;
+            }
           } else if (result) {
             allToolElements.push(
               <CollapsibleToolBlock key={`t-${i}`} label={getToolLabel(toolCall, result.isOk ? 'ok' : 'fail')} icon={result.isOk ? '✓' : '✗'}>
@@ -1633,8 +1634,26 @@ ${e.message}`,
           continue;
         }
 
-        // Regular code block
-        elements.push(<CodeBlock key={i} code={code} language={lang} onApply={() => onApplyCode(currentFile, code)} />);
+        // Regular code block — check if preceding write_file json header gave a filePath hint
+        if (pendingWriteFP && (!lang || pendingWriteLang === lang)) {
+          const pFp = pendingWriteFP;
+          const pLang = pendingWriteLang || lang;
+          pendingWriteFP = null;
+          pendingWriteLang = '';
+          const pWriteCall = { tool: 'write_file', params: { filePath: pFp } };
+          elements.push(
+            <div key={`pending-write-${i}`} className="my-1.5">
+              <div className="flex items-center gap-1.5 mb-1 px-0.5">
+                <Check size={11} className="text-[#89d185] flex-shrink-0" />
+                <span className="text-[11px] text-[#d4d4d4] font-medium">{getToolLabel(pWriteCall, 'ok')}</span>
+              </div>
+              <CodeBlock code={code} language={pLang} onApply={() => onApplyCode(currentFile, code)} isToolCall={true} />
+            </div>
+          );
+        } else {
+          pendingWriteFP = null;
+          elements.push(<CodeBlock key={i} code={code} language={lang} onApply={() => onApplyCode(currentFile, code)} />);
+        }
         continue;
       }