@animalabs/membrane 0.5.78 → 0.5.80

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/index.ts

@@ -24,3 +24,16 @@ export * from './formatters/index.js';
 
 // Context management
 export * from './context/index.js';
+
+// Prompt-cache keepalive (Anthropic 1h cache)
+export {
+  CacheKeepalive,
+  ineligibleReason as cacheKeepaliveIneligibleReason,
+  lineageKey as cacheLineageKey,
+} from './cache-keepalive.js';
+export type {
+  CacheKeepaliveConfig,
+  KeepaliveEvent,
+  KeepaliveLane,
+  KeepaliveSend,
+} from './cache-keepalive.js';

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).
@@ -986,7 +1005,7 @@ export class Membrane {
       // Tool execution loop
       while (toolDepth <= maxToolDepth) {
         // Build provider request with native tools
-        const providerRequest = this.buildNativeToolRequest(request, messages);
+        const providerRequest = this.buildNativeToolRequest(request, messages, toolDepth > 0);
 
         // Stream from provider
         let textAccumulated = '';
@@ -1178,12 +1197,20 @@ export class Membrane {
     }
   }
 
+  /** See the floating-cache-marker block in buildNativeToolRequest. */
+  private floatBudgetWarned = false;
+
   /**
-   * Build a provider request with native tool support
+   * Build a provider request with native tool support.
+   *
+   * `toolLoopRebuild` is true when this build is a tool-loop continuation
+   * (toolDepth > 0) rather than the turn's first request — the only case
+   * where the floating cache marker applies.
    */
   private buildNativeToolRequest(
     request: NormalizedRequest,
-    messages: typeof request.messages
+    messages: typeof request.messages,
+    toolLoopRebuild = false
   ): any {
     // Provider-native formatters own their complete input-item shape. The
     // legacy implementation below is intentionally Anthropic-specific; using
@@ -1335,7 +1362,17 @@ export class Membrane {
     // tool_results to `messages`. Any unmatched tool_use that reaches
     // this splice is upstream stranding (the bug class this fix exists
     // to catch) — `[pending]` is exactly the right synthesis.
-    const normalized = normalizeToolPairs(providerMessages);
+    // A synthesized [pending] tool_result's bytes are rewritten when the
+    // real result lands — the floating-marker block below must not cache
+    // past one. `synthetic_pending_result` (not the downstream
+    // cache_suppressed_for_synthetic, which only fires when a marker was
+    // actually stripped) is the root condition.
+    let pendingResultSynthesized = false;
+    const normalized = normalizeToolPairs(providerMessages, {
+      onEvent: (e) => {
+        if (e.kind === 'synthetic_pending_result') pendingResultSynthesized = true;
+      },
+    });
     const mergedMessages = mergeConsecutiveRoles(normalized.messages);
 
     // Convert tools to provider format.
@@ -1368,6 +1405,90 @@ export class Membrane {
       );
     }
 
+    // ------------------------------------------------------------------
+    // Floating cache marker: incremental prompt caching inside the native
+    // tool loop. Message breakpoints are placed by the context strategy at
+    // compile time — once per turn — but this builder re-runs on every
+    // tool round with that round's messages appended, so the deepest
+    // upstream marker stays glued to the turn-start snapshot and each
+    // rebuild re-pays the entire appended suffix at full input price
+    // (qa-ops incident, 2026-08-20: two subagents re-sent a suffix growing
+    // to ~118k tokens ~30 times each — ~5.3M uncached tokens in 18 min —
+    // with their one marker sitting on message 2 of 61).
+    //
+    // The tool loop only ever appends, so a marker riding the newest
+    // message yields the intended incremental pattern: each round writes
+    // its delta and cache-reads everything before it.
+    //
+    // Authority contract: the float spends only the RESIDUAL breakpoint
+    // budget (Anthropic allows 4 cache_control including tools/system).
+    // Upstream markers are never displaced or stripped — if they fill all
+    // 4 slots the float is withheld (with a warning) and behavior is
+    // exactly pre-float. With 2+ slots free, the previous round's
+    // endpoint is marked too: a wide parallel-tool round can append more
+    // blocks than the provider's ~20-block backward search covers, which
+    // would orphan the previous round's cache entry behind an unmarked
+    // boundary.
+    //
+    // Skipped when the normalizer synthesized a [pending] tool_result:
+    // those bytes are rewritten when the real result lands, and caching
+    // past them poisons the prefix — the same rationale as the
+    // normalizer's phase 5.5 cache suppression.
+    // ------------------------------------------------------------------
+    const floatingEnabled =
+      request.floatingCacheMarker ?? this.config.defaultFloatingCacheMarker ?? true;
+    if (toolLoopRebuild && floatingEnabled && cacheControl && !pendingResultSynthesized) {
+      // Residuum from a RECOUNT of the constructed wire artifacts, not the
+      // running messageBreakpoints tally — the tally diverges from the wire
+      // in both directions (mirrors NativeFormatter's recount, same bug
+      // class as the Sill 2026-07-25 wedge): a message-level breakpoint
+      // landing on a block already carrying stale cache_control is one
+      // physical marker counted twice, and a pre-marked system block is a
+      // real wire marker the tally never sees. Counted post-fallback and
+      // post-normalize, so fallback spend and phase-5.5 suppression are
+      // both reflected.
+      let wireMarkers = 0;
+      for (const m of mergedMessages) {
+        if (!Array.isArray(m.content)) continue;
+        for (const b of m.content as Array<Record<string, unknown>>) {
+          if (b.cache_control) wireMarkers++;
+        }
+      }
+      if (tools) for (const t of tools) { if (t.cache_control) wireMarkers++; }
+      if (Array.isArray(system)) {
+        for (const b of system as Array<Record<string, unknown>>) {
+          if (b.cache_control) wireMarkers++;
+        }
+      }
+      let residuum = 4 - wireMarkers;
+      if (residuum <= 0) {
+        if (!this.floatBudgetWarned) {
+          this.floatBudgetWarned = true;
+          console.warn(
+            `[membrane] floating cache marker withheld: upstream markers already ` +
+            `occupy all 4 cache_control slots (${wireMarkers} on the wire). ` +
+            `Tool-round suffixes will not cache incrementally.`
+          );
+        }
+      } else {
+        // Newest message first; then the previous round's endpoint (two
+        // wire messages back: [..., prevResults, assistant, results]).
+        const targets = [mergedMessages.length - 1, mergedMessages.length - 3];
+        for (const mi of targets) {
+          if (residuum <= 0 || mi < 0) continue;
+          const content = mergedMessages[mi]?.content;
+          if (!Array.isArray(content) || content.length === 0) continue;
+          const bpIdx = lastCacheableBlockIndex(content as Array<Record<string, unknown>>);
+          if (bpIdx < 0) continue;
+          // Already a breakpoint here (e.g. the strategy's own end marker
+          // on the turn's first rebuild) — nothing to add.
+          if ((content[bpIdx] as Record<string, unknown>).cache_control) continue;
+          (content[bpIdx] as Record<string, unknown>).cache_control = cacheControl;
+          residuum--;
+        }
+      }
+    }
+
     // Build thinking config for native extended thinking (budget clamped to max_tokens)
     // Fable/Mythos models: thinking is always on and unconfigurable; sampling params are removed.
     // Sending thinking config or temperature returns a 400 — omit both entirely.
@@ -2314,10 +2435,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 +2689,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 +2704,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 +2859,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).
@@ -2877,7 +3015,7 @@ export class Membrane {
         }
 
         // Build provider request with native tools
-        const providerRequest = this.buildNativeToolRequest(request, messages);
+        const providerRequest = this.buildNativeToolRequest(request, messages, toolDepth > 0);
 
         // Stream from provider
         let textAccumulated = '';

package/src/providers/anthropic.ts

@@ -22,6 +22,7 @@ import {
   abortError,
 } from '../types/index.js';
 import { flattenRootSchemaUnion } from './anthropic-tool-schema.js';
+import { CacheKeepalive, type CacheKeepaliveConfig } from '../cache-keepalive.js';
 
 // ============================================================================
 // Model capability gates
@@ -146,6 +147,15 @@ export interface AnthropicAdapterConfig {
   
   /** Default max tokens */
   defaultMaxTokens?: number;
+
+  /**
+   * Prompt-cache keepalive: hold this agent's cached prefix warm across idle
+   * gaps by replaying the last request with `max_tokens: 0`, which refreshes
+   * the entry's TTL at cache-READ price instead of letting it expire into a
+   * 2x cache write on the next wake. See `../cache-keepalive.ts`.
+   * Pass `{ enabled: false }` to turn off.
+   */
+  cacheKeepalive?: CacheKeepaliveConfig;
 }
 
 // ============================================================================
@@ -161,6 +171,8 @@ export class AnthropicAdapter implements ProviderAdapter {
    *  the SDK rather than merging, so when we add a per-request beta we must
    *  re-carry this one alongside it or auth breaks. */
   private defaultBeta: string | undefined;
+  /** Holds idle agents' cached prefixes warm; undefined when disabled. */
+  readonly cacheKeepalive: CacheKeepalive | undefined;
 
   constructor(config: AnthropicAdapterConfig = {}) {
     const clientOptions: ClientOptions = {
@@ -178,6 +190,19 @@ export class AnthropicAdapter implements ProviderAdapter {
 
     this.client = new Anthropic(clientOptions);
     this.defaultMaxTokens = config.defaultMaxTokens ?? 4096;
+
+    this.cacheKeepalive = config.cacheKeepalive?.enabled === false
+      ? undefined
+      : new CacheKeepalive(
+          // Replay path. Deliberately bypasses buildRequest(): the payload is
+          // the already-built wire request from a real call, and rebuilding it
+          // risks a byte diff that silently converts a 0.1x read into a 2x write.
+          async (wire, headers) => await this.client.messages.create(
+            wire as unknown as Anthropic.MessageCreateParamsNonStreaming,
+            headers ? { headers } : undefined,
+          ),
+          config.cacheKeepalive ?? {},
+        );
   }
 
   supportsModel(modelId: string): boolean {
@@ -192,10 +217,15 @@ export class AnthropicAdapter implements ProviderAdapter {
     const fullRequest = { ...anthropicRequest, stream: false as const };
     options?.onRequest?.(fullRequest);
 
+    const headers = this.betaHeaders(request);
+    this.cacheKeepalive?.record(
+      fullRequest as unknown as Record<string, unknown>, headers, 'complete',
+    );
+
     try {
       const response = await this.client.messages.create(fullRequest, {
         signal: options?.signal,
-        headers: this.betaHeaders(request),
+        headers,
       });
 
       return this.parseResponse(response, fullRequest);
@@ -214,6 +244,14 @@ export class AnthropicAdapter implements ProviderAdapter {
     const fullRequest = { ...anthropicRequest, stream: true };
     options?.onRequest?.(fullRequest);
 
+    // Snapshot the primary lane's prefix so it can be held warm across idle
+    // gaps. `stream: true` is dropped at replay time (transport, not cache key).
+    this.cacheKeepalive?.record(
+      fullRequest as unknown as Record<string, unknown>,
+      this.betaHeaders(request),
+      'stream',
+    );
+
     // Idle timeout: abort if no SSE event arrives within the deadline.
     // The SDK's timeout only covers the initial HTTP response headers;
     // once streaming starts, a silently dropped connection waits forever.
@@ -664,7 +702,12 @@ export class AnthropicAdapter implements ProviderAdapter {
         return authError(message, error, rawRequest);
       }
 
-      if (message.includes('context') || message.includes('too long')) {
+      // Context-length is a client-side request-shape problem — it only ever
+      // arrives as a 400 (invalid_request_error). Without the status guard, a
+      // transient 5xx whose body happens to contain "context" or "too long"
+      // (e.g. "Internal error: context processing failed") was misclassified
+      // as non-retryable context_length, silently suppressing retries.
+      if (status === 400 && (message.includes('context') || message.includes('too long'))) {
         return contextLengthError(message, error, rawRequest);
       }
 
@@ -780,7 +823,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/config.ts

@@ -180,6 +180,12 @@ export interface MembraneConfig {
    */
   defaultPromptCaching?: boolean;
 
+  /**
+   * Default for request.floatingCacheMarker when the request doesn't set it.
+   * Default: true. See NormalizedRequest.floatingCacheMarker.
+   */
+  defaultFloatingCacheMarker?: boolean;
+
   /**
    * Prefill formatter for message serialization and response parsing.
    * Controls how messages are formatted for the API and how responses are parsed.

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/request.ts

@@ -159,6 +159,20 @@ export interface NormalizedRequest {
    */
   cacheTtl?: '5m' | '1h';
 
+  /**
+   * Float a trailing cache_control marker onto the newest message when the
+   * native tool loop rebuilds the request between tool-execution rounds, so
+   * the growing tool-round suffix caches incrementally (each round writes
+   * only its delta and cache-reads everything before it). Placed only from
+   * the request's *residual* breakpoint budget — the marker is withheld when
+   * upstream markers already occupy all 4 Anthropic cache_control slots —
+   * so upstream breakpoints are never displaced or stripped.
+   * Defaults to true (when promptCaching is enabled). Set false for context
+   * strategies whose request prefix churns between rounds, where a trailing
+   * marker would be pure cache-write cost.
+   */
+  floatingCacheMarker?: boolean;
+
   /**
    * Context prefix for simulacrum seeding.
    * Injected as first assistant message (before conversation history).

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;