@animalabs/membrane 0.5.78 → 0.5.79

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@animalabs/membrane",
-  "version": "0.5.78",
+  "version": "0.5.79",
   "description": "LLM middleware - a selective boundary that transforms what passes through",
   "repository": {
     "type": "git",

package/src/formatters/anthropic-xml.ts

@@ -104,6 +104,7 @@ function toToolResult(block: ToolResultContent): ToolResult {
   }
   return {
     toolUseId: block.toolUseId,
+    toolName: block.toolName,
     content,
     isError: block.isError ?? false,
   };
@@ -160,6 +161,9 @@ export class AnthropicXmlFormatter implements PrefillFormatter {
     // Track conversation state
     let currentConversation: string[] = [];
     let lastNonEmptyParticipant: string | null = null;
+    // True right after an unlabeled tool-results glue — the next assistant
+    // message continues the same turn, so it must not get a fresh label.
+    let lastWasToolResults = false;
 
     // Track cache markers applied
     let cacheMarkersApplied = 0;
@@ -298,15 +302,39 @@ export class AnthropicXmlFormatter implements PrefillFormatter {
       const isBotMessage = message.participant === assistantParticipant;
       const isContinuation = isBotMessage && lastNonEmptyParticipant === assistantParticipant && !hasToolResult;
 
+      const isPureToolResults =
+        hasToolResult && message.content.every((c) => c.type === 'tool_result');
+
       if (isContinuation && isLastMessage) {
         // Bot continuation - don't add prefix
         continue;
       } else if (isLastMessage && isEmpty) {
         // Completion target - prefix added below
       } else if (text) {
-        currentConversation.push(`${message.participant}: ${text}${this.config.messageDelimiter}`);
-        if (!hasToolResult) {
+        if (isPureToolResults) {
+          // Tool results are not speech: replay them exactly as they were
+          // injected live — inside the assistant flow, unlabeled (legacy
+          // convention). A participant prefix here re-attributes the
+          // harness's injection as someone's utterance, and the model then
+          // reads the same result in two attributions across compiles
+          // (D2 of the Evander 2026-08-08 scaffold-leak analysis).
+          currentConversation.push(`${text}${this.config.messageDelimiter}`);
+          lastWasToolResults = true;
+        } else if (isBotMessage && lastWasToolResults) {
+          // The round after injected results continues the same assistant
+          // turn — no fresh label mid-turn, matching what the model lived.
+          // (If a turn ended exactly on a results injection, the next
+          // assistant turn glues here unlabeled — a minor cost the message
+          // model can't distinguish; a turn id would be needed.)
+          currentConversation.push(`${text}${this.config.messageDelimiter}`);
+          lastWasToolResults = false;
           lastNonEmptyParticipant = message.participant;
+        } else {
+          currentConversation.push(`${message.participant}: ${text}${this.config.messageDelimiter}`);
+          lastWasToolResults = false;
+          if (!hasToolResult) {
+            lastNonEmptyParticipant = message.participant;
+          }
         }
       }
 

package/src/membrane.ts

@@ -408,10 +408,16 @@ export class Membrane {
     // Track the initial prefill length so we can extract only NEW content for response
     // Also track what block type we're inside at the end of prefill
     let initialPrefillLength = 0;
+    // Watermark for per-round delta text (ToolContext.roundPreamble): start of
+    // the CURRENT round's model text in parser-accumulated coordinates.
+    // Advanced past each round's injected results push, so injected
+    // <function_results> XML never enters a round's delta.
+    let roundStartLen = 0;
     let initialBlockType: 'thinking' | 'tool_call' | 'tool_result' | null = null;
     if (prefillResult.assistantPrefill) {
       parser.push(prefillResult.assistantPrefill);
       initialPrefillLength = prefillResult.assistantPrefill.length;
+      roundStartLen = initialPrefillLength;
       // Capture what block type we're inside after prefill (if any)
       if (parser.isInsideBlock()) {
         const blockType = parser.getCurrentBlockType();
@@ -699,6 +705,7 @@ export class Membrane {
             const context: ToolContext = {
               rawText: parsed.fullMatch,
               preamble: parsed.beforeText.slice(initialPrefillLength),
+              roundPreamble: parsed.beforeText.slice(roundStartLen),
               depth: toolDepth,
               previousResults: executedToolResults,
               accumulated: parser.getAccumulated().slice(initialPrefillLength),
@@ -711,6 +718,14 @@ export class Membrane {
               );
             }
 
+            // Backfill tool names for the legacy XML result rendering
+            // (<result><tool_name>…</tool_name><stdout>…) when the executor
+            // didn't supply them.
+            const callNames = new Map(parsed.calls.map((c) => [c.id, c.name]));
+            for (const r of results) {
+              if (!r.toolName) r.toolName = callNames.get(r.toolUseId);
+            }
+
             // Track the tool results
             executedToolResults.push(...results);
 
@@ -832,6 +847,10 @@ export class Membrane {
               );
             }
 
+            // Next round's model text starts after everything injected this
+            // round (results XML, image-split tags, thinking opener).
+            roundStartLen = parser.getAccumulated().length;
+
             // Reset parser state for new streaming iteration. Tool rounds
             // are the caller's work — they count against maxToolDepth only,
             // never against the resumption guards (issue #39 review).
@@ -2314,10 +2333,14 @@ export class Membrane {
 
     // Initialize parser with prefill content
     let initialPrefillLength = 0;
+    // Watermark for per-round delta text (ToolContext.roundPreamble) — see
+    // streamWithXmlTools for rationale. Advanced past each results push.
+    let roundStartLen = 0;
     let initialBlockType: 'thinking' | 'tool_call' | 'tool_result' | null = null;
     if (prefillResult.assistantPrefill) {
       parser.push(prefillResult.assistantPrefill);
       initialPrefillLength = prefillResult.assistantPrefill.length;
+      roundStartLen = initialPrefillLength;
       if (parser.isInsideBlock()) {
         const blockType = parser.getCurrentBlockType();
         if (blockType === 'thinking' || blockType === 'tool_call' || blockType === 'tool_result') {
@@ -2564,6 +2587,7 @@ export class Membrane {
             const context: ToolContext = {
               rawText: parsed.fullMatch,
               preamble: parsed.beforeText.slice(initialPrefillLength),
+              roundPreamble: parsed.beforeText.slice(roundStartLen),
               depth: toolDepth,
               previousResults: executedToolResults,
               accumulated: parser.getAccumulated().slice(initialPrefillLength),
@@ -2578,6 +2602,14 @@ export class Membrane {
 
             const { results, injectedMessages } = await stream.requestToolExecution(toolCallsEvent);
 
+            // Backfill tool names for the legacy XML result rendering
+            // (<result><tool_name>…</tool_name><stdout>…) when the executor
+            // didn't supply them.
+            const yieldCallNames = new Map(parsed.calls.map((c) => [c.id, c.name]));
+            for (const r of results) {
+              if (!r.toolName) r.toolName = yieldCallNames.get(r.toolUseId);
+            }
+
             // Mid-turn injected messages are not supported on the XML prefill
             // path: the continuation is an assistant prefill over an XML
             // transcript, not a message array, so there is no user envelope
@@ -2725,6 +2757,10 @@ export class Membrane {
               );
             }
 
+            // Next round's model text starts after everything injected this
+            // round (results XML, image-split tags, thinking opener).
+            roundStartLen = parser.getAccumulated().length;
+
             // Tool rounds are the caller's work — they count against
             // maxToolDepth only, never against the resumption guards
             // (issue #39 review: the uncapped tool-loop contract stands).

package/src/providers/anthropic.ts

@@ -780,7 +780,7 @@ function toAnthropicToolResultContent(
  *  can lose or mislabel mediaType (e.g. a PNG tagged image/jpeg), which the
  *  Anthropic API rejects with a 400. Trust the bytes; fall back to the declared
  *  type, then jpeg. */
-function detectImageMediaType(data: string | undefined, fallback?: string): string {
+export function detectImageMediaType(data: string | undefined, fallback?: string): string {
   try {
     const b = Buffer.from((data || "").slice(0, 24), "base64");
     if (b[0]===0x89&&b[1]===0x50&&b[2]===0x4e&&b[3]===0x47) return "image/png";

package/src/providers/bedrock.ts

@@ -25,6 +25,7 @@ import {
   INTERLEAVED_THINKING_BETA,
   needsInterleavedThinkingBeta,
   thinkingEnabled,
+  detectImageMediaType,
 } from './anthropic.js';
 
 // ============================================================================
@@ -404,6 +405,25 @@ export class BedrockAdapter implements ProviderAdapter {
     // caching works without the field, so strip just the ttl and keep the
     // breakpoint. Transport quirks belong to the transport, not to every
     // caller that sets cacheTtl. (Connectome issue #35.)
+    // Bedrock is strict about the wire shape of image sources: internal blocks
+    // carry camelCase `mediaType`, the API requires snake_case `media_type`.
+    // The Anthropic adapter converts on both paths (toAnthropicContent /
+    // toAnthropicToolResultContent); without the same conversion here a
+    // tool-returned image 400s with "media_type: Field required" mid-turn
+    // (observed on eidoverse snapshot results, 2026-08-08). Applies to
+    // top-level image blocks AND images nested inside tool_result content.
+    const toWireImage = (block: any): any => {
+      const source = block.source;
+      if (!source || source.type !== 'base64') return block;
+      const { mediaType, media_type, ...restSource } = source;
+      return {
+        ...block,
+        source: {
+          ...restSource,
+          media_type: detectImageMediaType(source.data, (media_type ?? mediaType) as string),
+        },
+      };
+    };
     const sanitizedMessages = (request.messages as any[]).map((msg: any) => {
       if (!Array.isArray(msg.content)) return msg;
       return {
@@ -411,7 +431,18 @@ export class BedrockAdapter implements ProviderAdapter {
         content: msg.content.map((block: any) => {
           if (block.type === 'image' && block.sourceUrl !== undefined) {
             const { sourceUrl, ...rest } = block;
-            return stripCacheTtl(rest);
+            return stripCacheTtl(toWireImage(rest));
+          }
+          if (block.type === 'image') {
+            return stripCacheTtl(toWireImage(block));
+          }
+          if (block.type === 'tool_result' && Array.isArray(block.content)) {
+            return stripCacheTtl({
+              ...block,
+              content: block.content.map((inner: any) =>
+                inner?.type === 'image' ? toWireImage(inner) : inner,
+              ),
+            });
           }
           return stripCacheTtl(block);
         }),

package/src/types/content.ts

@@ -128,6 +128,11 @@ export interface ToolUseContent {
 export interface ToolResultContent {
   type: 'tool_result';
   toolUseId: string;
+  /**
+   * Tool name, persisted so XML replay can reconstruct the legacy
+   * `<tool_name>` element byte-identically to the live injection.
+   */
+  toolName?: string;
   content: string | ContentBlock[];
   isError?: boolean;
   /**

package/src/types/tools.ts

@@ -37,6 +37,13 @@ export interface ToolCall {
 
 export interface ToolResult {
   toolUseId: string;
+  /**
+   * Tool name, for the legacy XML result rendering
+   * (`<result><tool_name>…</tool_name><stdout>…</stdout></result>`).
+   * Optional: XML paths backfill it from the round's parsed calls when the
+   * executor didn't supply it.
+   */
+  toolName?: string;
   /**
    * Result content - can be string or structured content blocks (for images).
    * For XML mode, images are noted in text. For native mode, passed as content blocks.
@@ -63,6 +70,19 @@ export interface ToolContext {
   /** Text before the tool calls (already streamed to user) */
   preamble: string;
 
+  /**
+   * XML mode only: THIS round's model-authored text — the slice of the
+   * turn between the end of the previous round's injected results and this
+   * round's <function_calls> opener. Unlike `preamble` (cumulative: the
+   * whole turn so far, including harness-injected <function_results> XML),
+   * this never repeats earlier rounds and never contains injected results.
+   * Consumers persisting per-round assistant text must prefer this field —
+   * persisting the cumulative `preamble` per round stores each round's text
+   * N times and re-persists injected results as model text (the Evander
+   * 2026-08-08 scaffold-leak pyramid).
+   */
+  roundPreamble?: string;
+
   /** Current depth in tool execution loop */
   depth: number;
 

package/src/utils/tool-parser.ts

@@ -188,40 +188,94 @@ export function endsWithPartialToolBlock(text: string): boolean {
 // ============================================================================
 
 /**
- * Format tool results as XML for injection.
- * Handles both string content and structured content blocks (with images).
+ * Structural tags of the XML tool convention. Result content containing any
+ * of these must be escaped or it would desync the document/stream parser;
+ * everything else rides raw (legacy convention — full escapeXml put `"`
+ * entities in front of the model, which Claude-3-era models then reproduce
+ * in their own output).
+ */
+const STRUCTURAL_TAG_RE =
+  /<\/?(?:antml:)?(?:function_calls|function_results|invoke|result|stdout|error|tool_name)\b/;
+
+function renderResultContentString(result: ToolResult): string {
+  if (typeof result.content === 'string') {
+    return result.content;
+  }
+  const parts: string[] = [];
+  for (const block of result.content) {
+    if (block.type === 'text') {
+      parts.push(block.text);
+    } else if (block.type === 'image') {
+      // For XML mode, we can't embed images directly
+      // Add a note about the image for the model
+      const sizeKb = Math.round((block.source.data.length * 0.75) / 1024);
+      parts.push(`[Image: ${block.source.mediaType}, ~${sizeKb}KB]`);
+    }
+  }
+  return parts.join('\n');
+}
+
+/**
+ * Format tool results as XML for injection — the LEGACY Anthropic tool
+ * convention Claude-3-era models were trained on:
+ *
+ *   <function_results>
+ *   <result>
+ *   <tool_name>NAME</tool_name>
+ *   <stdout>
+ *   content
+ *   </stdout>
+ *   </result>
+ *   </function_results>
+ *
+ * Errors render as <error>…</error> inside <function_results>. No
+ * tool_use_id attributes on the wire (a Messages-API concept — the
+ * store keeps the linkage on the blocks); content rides raw unless it
+ * contains structural tags (then escaped, see STRUCTURAL_TAG_RE).
  */
 export function formatToolResults(results: ToolResult[]): string {
   const parts: string[] = ['<function_results>'];
 
   for (const result of results) {
-    const tagName = result.isError ? 'error' : 'result';
-    parts.push(`<${tagName} tool_use_id="${result.toolUseId}">`);
-
-    // Handle both string and array content
-    if (typeof result.content === 'string') {
-      parts.push(escapeXml(result.content));
-    } else if (Array.isArray(result.content)) {
-      // Structured content blocks
-      for (const block of result.content) {
-        if (block.type === 'text') {
-          parts.push(escapeXml(block.text));
-        } else if (block.type === 'image') {
-          // For XML mode, we can't embed images directly
-          // Add a note about the image for the model
-          const sizeKb = Math.round((block.source.data.length * 0.75) / 1024);
-          parts.push(`[Image: ${block.source.mediaType}, ~${sizeKb}KB]`);
-        }
+    if (result.isError) {
+      parts.push('<error>');
+      parts.push(guardResultContent(renderResultContentString(result)));
+      parts.push('</error>');
+    } else {
+      parts.push('<result>');
+      if (result.toolName) {
+        parts.push(`<tool_name>${result.toolName}</tool_name>`);
       }
+      parts.push('<stdout>');
+      parts.push(guardResultContent(renderResultContentString(result)));
+      parts.push('</stdout>');
+      parts.push('</result>');
     }
-
-    parts.push(`</${tagName}>`);
   }
 
   parts.push('</function_results>');
   return parts.join('\n');
 }
 
+/** Escape result content only when it would desync the structural parse. */
+function guardResultContent(s: string): string {
+  return STRUCTURAL_TAG_RE.test(s) ? escapeXml(s) : s;
+}
+
+/** Opening XML of one result, up to where its content begins. */
+function resultOpenXml(result: ToolResult): string {
+  if (result.isError) return '<error>\n';
+  let xml = '<result>\n';
+  if (result.toolName) xml += `<tool_name>${result.toolName}</tool_name>\n`;
+  xml += '<stdout>\n';
+  return xml;
+}
+
+/** Closing XML of one result, after its content. */
+function resultCloseXml(result: ToolResult): string {
+  return result.isError ? '\n</error>\n' : '\n</stdout>\n</result>\n';
+}
+
 /**
  * Format a single tool result
  */
@@ -292,6 +346,13 @@ const FUNCTION_RESULTS_BLOCK_REGEX = /<(antml:)?function_results>([\s\S]*?)<\/(a
 const RESULT_REGEX = /<result\s+tool_use_id="([^"]+)">([\s\S]*?)<\/result>/g;
 const ERROR_REGEX = /<error\s+tool_use_id="([^"]+)">([\s\S]*?)<\/error>/g;
 
+// Legacy Anthropic convention — no ids on the wire; results pair
+// positionally with the preceding unmatched tool calls in document order
+// (optionally disambiguated by <tool_name>).
+const LEGACY_RESULT_REGEX =
+  /<result>\s*(?:<tool_name>([\s\S]*?)<\/tool_name>\s*)?<stdout>\n?([\s\S]*?)\n?<\/stdout>\s*<\/result>/g;
+const LEGACY_ERROR_REGEX = /<error>\n?([\s\S]*?)\n?<\/error>/g;
+
 /**
  * Parse accumulated assistant text into structured ContentBlock[].
  * Extracts thinking blocks, tool calls, tool results, and plain text.
@@ -331,6 +392,21 @@ export function parseAccumulatedIntoBlocks(
   };
   const positions: BlockPosition[] = [];
 
+  // Call sites in document order, for pairing legacy-shaped results
+  // (no tool_use_id on the wire) with the calls they answer.
+  const callSites: Array<{ id: string; name: string; pos: number }> = [];
+  const pairedCallIds = new Set<string>();
+  const claimCall = (beforePos: number, name?: string): string => {
+    for (const site of callSites) {
+      if (site.pos >= beforePos) break;
+      if (pairedCallIds.has(site.id)) continue;
+      if (name && site.name !== name) continue;
+      pairedCallIds.add(site.id);
+      return site.id;
+    }
+    return generateToolId();
+  };
+
   // Find all thinking blocks
   THINKING_BLOCK_REGEX.lastIndex = 0;
   let thinkingMatch: RegExpExecArray | null;
@@ -377,6 +453,7 @@ export function parseAccumulatedIntoBlocks(
       const id = generateToolId();
       const toolCall: ToolCall = { id, name: toolName, input };
       toolCalls.push(toolCall);
+      callSites.push({ id, name: toolName, pos: funcMatch.index });
       blockToolCalls.push({
         type: 'tool_use',
         id,
@@ -394,6 +471,7 @@ export function parseAccumulatedIntoBlocks(
       const id = generateToolId();
       const toolCall: ToolCall = { id, name: toolName, input: {} };
       toolCalls.push(toolCall);
+      callSites.push({ id, name: toolName, pos: funcMatch.index });
       blockToolCalls.push({
         type: 'tool_use',
         id,
@@ -428,6 +506,7 @@ export function parseAccumulatedIntoBlocks(
     while ((resultMatch = RESULT_REGEX.exec(innerContent)) !== null) {
       const toolUseId = resultMatch[1] ?? '';
       const content = unescapeXml(resultMatch[2] ?? '');
+      pairedCallIds.add(toolUseId);
       const result: ToolResult = { toolUseId, content, isError: false };
       toolResults.push(result);
       blockResults.push({
@@ -445,6 +524,7 @@ export function parseAccumulatedIntoBlocks(
     while ((errorMatch = ERROR_REGEX.exec(innerContent)) !== null) {
       const toolUseId = errorMatch[1] ?? '';
       const content = unescapeXml(errorMatch[2] ?? '');
+      pairedCallIds.add(toolUseId);
       const result: ToolResult = { toolUseId, content, isError: true };
       toolResults.push(result);
       blockResults.push({
@@ -456,6 +536,39 @@ export function parseAccumulatedIntoBlocks(
       });
     }
 
+    // Legacy-shaped results/errors (no ids on the wire): pair positionally
+    // with the preceding unclaimed calls, disambiguated by <tool_name>.
+    LEGACY_RESULT_REGEX.lastIndex = 0;
+    let legacyResultMatch: RegExpExecArray | null;
+    while ((legacyResultMatch = LEGACY_RESULT_REGEX.exec(innerContent)) !== null) {
+      const toolName = legacyResultMatch[1]?.trim() || undefined;
+      const content = unescapeXml(legacyResultMatch[2] ?? '');
+      const toolUseId = claimCall(resultsMatch.index, toolName);
+      toolResults.push({ toolUseId, toolName, content, isError: false });
+      blockResults.push({
+        type: 'tool_result',
+        toolUseId,
+        toolName,
+        content,
+        isError: false,
+        rawXml,
+      });
+    }
+    LEGACY_ERROR_REGEX.lastIndex = 0;
+    let legacyErrorMatch: RegExpExecArray | null;
+    while ((legacyErrorMatch = LEGACY_ERROR_REGEX.exec(innerContent)) !== null) {
+      const content = unescapeXml(legacyErrorMatch[1] ?? '');
+      const toolUseId = claimCall(resultsMatch.index);
+      toolResults.push({ toolUseId, content, isError: true });
+      blockResults.push({
+        type: 'tool_result',
+        toolUseId,
+        content,
+        isError: true,
+        rawXml,
+      });
+    }
+
     if (blockResults.length > 0) {
       positions.push({
         start: resultsMatch.index,
@@ -628,7 +741,6 @@ export function formatToolResultsForSplitTurn(results: ToolResult[]): SplitTurnC
 
   for (let i = 0; i < results.length; i++) {
     const result = results[i]!;
-    const tagName = result.isError ? 'error' : 'result';
 
     // Check if this result has images
     let resultHasImages = false;
@@ -636,14 +748,14 @@ export function formatToolResultsForSplitTurn(results: ToolResult[]): SplitTurnC
     let resultImages: ProviderImageBlock[] = [];
 
     if (typeof result.content === 'string') {
-      textParts.push(escapeXml(result.content));
+      textParts.push(guardResultContent(result.content));
     } else if (Array.isArray(result.content)) {
       for (const block of result.content) {
         if (block.type === 'text') {
-          textParts.push(escapeXml(block.text));
+          textParts.push(guardResultContent(block.text));
         } else if (block.type === 'image') {
           if (!isAcceptedImageMediaType(block.source.mediaType)) {
-            textParts.push(escapeXml(strippedImagePlaceholder(block.source.mediaType).text));
+            textParts.push(strippedImagePlaceholder(block.source.mediaType).text);
           } else {
             resultHasImages = true;
             resultImages.push({
@@ -664,15 +776,15 @@ export function formatToolResultsForSplitTurn(results: ToolResult[]): SplitTurnC
       imageInsertionPoint = i;
       images.push(...resultImages);
 
-      // Add opening tag and text content (no closing tag yet)
-      beforeImageXml += `<${tagName} tool_use_id="${result.toolUseId}">\n`;
+      // Add opening tags and text content (no closing tags yet)
+      beforeImageXml += resultOpenXml(result);
       if (textParts.length > 0) {
         beforeImageXml += textParts.join('\n');
       }
-      // Note: Intentionally NOT adding closing tag - split happens here
+      // Note: Intentionally NOT adding closing tags - split happens here
 
       // After image, we need to close this result and add remaining results
-      afterImageXml = `</${tagName}>\n`;
+      afterImageXml = resultCloseXml(result);
 
       // Process remaining results into afterImageXml
       for (let j = i + 1; j < results.length; j++) {
@@ -685,9 +797,9 @@ export function formatToolResultsForSplitTurn(results: ToolResult[]): SplitTurnC
       break;
     } else if (imageInsertionPoint === -1) {
       // No images yet - add full result to beforeImageXml
-      beforeImageXml += `<${tagName} tool_use_id="${result.toolUseId}">\n`;
+      beforeImageXml += resultOpenXml(result);
       beforeImageXml += textParts.join('\n');
-      beforeImageXml += `\n</${tagName}>\n`;
+      beforeImageXml += resultCloseXml(result);
     }
   }
 
@@ -714,15 +826,14 @@ export function formatToolResultsForSplitTurn(results: ToolResult[]): SplitTurnC
  * Format a single tool result as complete XML
  */
 function formatSingleResultXml(result: ToolResult): string {
-  const tagName = result.isError ? 'error' : 'result';
-  let xml = `<${tagName} tool_use_id="${result.toolUseId}">\n`;
+  let xml = resultOpenXml(result);
 
   if (typeof result.content === 'string') {
-    xml += escapeXml(result.content);
+    xml += guardResultContent(result.content);
   } else if (Array.isArray(result.content)) {
     for (const block of result.content) {
       if (block.type === 'text') {
-        xml += escapeXml(block.text);
+        xml += guardResultContent(block.text);
       } else if (block.type === 'image') {
         // For remaining results after split, images become text placeholders
         const sizeKb = Math.round((block.source.data.length * 0.75) / 1024);
@@ -731,7 +842,7 @@ function formatSingleResultXml(result: ToolResult): string {
     }
   }
 
-  xml += `\n</${tagName}>\n`;
+  xml += resultCloseXml(result);
   return xml;
 }