@animalabs/membrane 0.5.74 → 0.5.76

package/src/membrane.ts

@@ -476,8 +476,11 @@ export class Membrane {
 
           if (parsed && parsed.calls.length > 0) {
             // Notify about pre-tool content
-            if (onPreToolContent && parsed.beforeText.trim()) {
-              await onPreToolContent(parsed.beforeText);
+            // Slice the seeded prefill off: beforeText starts with the whole
+            // flattened document in XML mode (see ToolContext note below).
+            const preToolNew = parsed.beforeText.slice(initialPrefillLength);
+            if (onPreToolContent && preToolNew.trim()) {
+              await onPreToolContent(preToolNew);
             }
 
             // Emit block events for each tool call
@@ -504,13 +507,24 @@ export class Membrane {
             // Track the tool calls
             executedToolCalls.push(...parsed.calls);
 
-            // Execute tools
+            // Execute tools.
+            // preamble/accumulated must expose the MODEL'S text only. The
+            // parser is seeded with the entire assistant prefill (the whole
+            // flattened document in XML mode), so parsed.beforeText starts
+            // with it — consumers that persist the preamble as "what the
+            // agent said this round" would otherwise write the full document
+            // back into the store as an assistant message (observed on Ash,
+            // 2026-07-26: a died-mid-rounds turn flushed a ~720k-char
+            // document echo into her message store as 62 sharded messages).
+            // The turn-END path already slices (newContent =
+            // fullAccumulated.slice(initialPrefillLength)); the tool-round
+            // path must match it.
             const context: ToolContext = {
               rawText: parsed.fullMatch,
-              preamble: parsed.beforeText,
+              preamble: parsed.beforeText.slice(initialPrefillLength),
               depth: toolDepth,
               previousResults: executedToolResults,
-              accumulated: parser.getAccumulated(),
+              accumulated: parser.getAccumulated().slice(initialPrefillLength),
             };
 
             const results = await onToolCalls(parsed.calls, context);
@@ -1033,6 +1047,13 @@ export class Membrane {
           const textBlock: Record<string, unknown> = { type: 'text', text };
           if ((block as any).cache_control) {
             textBlock.cache_control = (block as any).cache_control;
+            // A block-level passthrough occupies one of the 4 breakpoint slots
+            // exactly like a marked message — count it, so the tools/system
+            // fallback below doesn't stack more on top. (Imported/seeded
+            // conversations can carry stale request-time cache_control on
+            // stored blocks — first seen wedging Sill 2026-07-25: 3 cm markers
+            // + 2 stale Arc-export blocks = 5 → hard 400 on every inference.)
+            messageBreakpoints++;
           }
           content.push(textBlock);
         } else if (block.type === 'tool_use') {
@@ -2225,13 +2246,24 @@ export class Membrane {
             // Track the tool calls
             executedToolCalls.push(...parsed.calls);
 
-            // Build tool context
+            // Build tool context.
+            // preamble/accumulated must expose the MODEL'S text only: the
+            // parser was seeded with the entire assistant prefill (the whole
+            // flattened document in XML mode), so parsed.beforeText starts
+            // with it. Consumers persist the preamble as "what the agent said
+            // this round" — unsliced, a turn that dies mid-rounds flushes the
+            // full document back into the agent's store as its own message
+            // (observed on Ash 2026-07-26: ~720k-char document echo persisted
+            // as 62 sharded assistant messages, doubling her store and
+            // wedging every subsequent compile). The turn-END path already
+            // slices (newContent = fullAccumulated.slice(initialPrefillLength));
+            // the tool-round path must match it.
             const context: ToolContext = {
               rawText: parsed.fullMatch,
-              preamble: parsed.beforeText,
+              preamble: parsed.beforeText.slice(initialPrefillLength),
               depth: toolDepth,
               previousResults: executedToolResults,
-              accumulated: parser.getAccumulated(),
+              accumulated: parser.getAccumulated().slice(initialPrefillLength),
             };
 
             // Yield control for tool execution

package/src/providers/anthropic.ts

@@ -68,6 +68,61 @@ function noTemperatureSupport(model: string): boolean {
   return NO_TEMPERATURE_MODELS.some(prefix => model.startsWith(prefix));
 }
 
+/** Beta flag for thinking blocks between tool calls on pre-4.6 Claude 4.
+ *  Shared with the Bedrock adapter, where it rides in the request body
+ *  (`anthropic_beta`) instead of an HTTP header. */
+export const INTERLEAVED_THINKING_BETA = 'interleaved-thinking-2025-05-14';
+
+/**
+ * Interleaved thinking (thinking blocks between tool calls) is native from
+ * Opus/Sonnet 4.6 onward; earlier Claude 4 models only do it behind the
+ * `interleaved-thinking-2025-05-14` beta flag. Matches Claude 4 ids with a
+ * minor version below 6 — dated snapshots (claude-opus-4-1-20250805), bare
+ * bases (claude-opus-4), and date-only 4.0 ids (claude-opus-4-20250514) are
+ * all covered, as are gateway-prefixed ids ('anthropic/claude-opus-4-5').
+ * Claude 3.x never matches (no interleaved support, beta or not); 4.6+ and
+ * the 5-series need no flag.
+ */
+export function needsInterleavedThinkingBeta(model: string): boolean {
+  const m = /claude-(?:opus|sonnet|haiku)-4(?:-(\d+))?/.exec(model);
+  if (!m) return false;
+  const minor = m[1];
+  if (minor === undefined) return true; // bare 'claude-opus-4'
+  if (minor.length >= 8) return true;   // 8-digit date right after the major = a 4.0 id
+  return parseInt(minor, 10) < 6;
+}
+
+/** Pull any anthropic-beta value out of a ClientOptions defaultHeaders bag,
+ *  which the SDK types as record | entries-array | Headers. Case-insensitive
+ *  on the key; non-string values (explicit null override, arrays) are treated
+ *  as absent. */
+function extractBetaHeader(headers: ClientOptions['defaultHeaders']): string | undefined {
+  if (!headers) return undefined;
+  if (typeof (headers as Headers).get === 'function') {
+    return (headers as Headers).get('anthropic-beta') ?? undefined;
+  }
+  const entries = Array.isArray(headers)
+    ? headers
+    : Object.entries(headers as Record<string, unknown>);
+  for (const [key, value] of entries) {
+    if (String(key).toLowerCase() === 'anthropic-beta' && typeof value === 'string') {
+      return value;
+    }
+  }
+  return undefined;
+}
+
+/** Resolve whether a thinking config is enabled on a request. Thinking can
+ *  arrive top-level OR smuggled through `extra` (see the sampling gate in
+ *  buildRequest) — both the sampling strip and the beta header must agree on
+ *  one answer, so they share this resolver. Exported for the Bedrock adapter,
+ *  which applies the same interleaved-thinking gate to its request body. */
+export function thinkingEnabled(request: ProviderRequest): boolean {
+  const extraThinking = (request.extra as { thinking?: { type?: string } } | undefined)?.thinking;
+  const thinkingConfig = request.thinking ?? extraThinking;
+  return thinkingConfig !== undefined && thinkingConfig.type !== 'disabled';
+}
+
 // ============================================================================
 // Adapter Configuration
 // ============================================================================
@@ -101,12 +156,18 @@ export class AnthropicAdapter implements ProviderAdapter {
   readonly name = 'anthropic';
   private client: Anthropic;
   private defaultMaxTokens: number;
+  /** Any anthropic-beta value from defaultHeaders (e.g. the oauth beta for
+   *  subscription tokens). Per-request headers REPLACE same-key defaults in
+   *  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;
 
   constructor(config: AnthropicAdapterConfig = {}) {
     const clientOptions: ClientOptions = {
       baseURL: config.baseURL,
       defaultHeaders: config.defaultHeaders,
     };
+    this.defaultBeta = extractBetaHeader(config.defaultHeaders);
 
     if (config.authToken !== undefined) {
       clientOptions.authToken = config.authToken;
@@ -134,6 +195,7 @@ export class AnthropicAdapter implements ProviderAdapter {
     try {
       const response = await this.client.messages.create(fullRequest, {
         signal: options?.signal,
+        headers: this.betaHeaders(request),
       });
 
       return this.parseResponse(response, fullRequest);
@@ -198,6 +260,7 @@ export class AnthropicAdapter implements ProviderAdapter {
     try {
       const stream = await this.client.messages.stream(anthropicRequest, {
         signal: idleAbort.signal,
+        headers: this.betaHeaders(request),
       });
 
       // Accumulate response metadata from SSE events directly, so we can
@@ -399,6 +462,25 @@ export class AnthropicAdapter implements ProviderAdapter {
     }
   }
 
+  /** Per-request headers for both create() and stream(): the interleaved-
+   *  thinking beta when thinking is enabled on a pre-4.6 Claude 4 model.
+   *  Any default anthropic-beta (oauth) is re-carried in the same header —
+   *  the SDK replaces same-key defaults instead of merging, and the API
+   *  accepts comma-separated betas. Undefined when nothing to add, so the
+   *  defaults apply untouched. */
+  private betaHeaders(request: ProviderRequest): Record<string, string> | undefined {
+    if (!thinkingEnabled(request) || !needsInterleavedThinkingBeta(request.model)) {
+      return undefined;
+    }
+    // Set-join so a default that already carries the interleaved beta
+    // doesn't emit it twice (the API tolerates duplicates; this is hygiene).
+    const betas = new Set(
+      (this.defaultBeta ?? '').split(',').map((b) => b.trim()).filter(Boolean),
+    );
+    betas.add(INTERLEAVED_THINKING_BETA);
+    return { 'anthropic-beta': [...betas].join(',') };
+  }
+
   private buildRequest(request: ProviderRequest): Anthropic.MessageCreateParams {
     // Strip provider-specific fields (e.g., sourceUrl for Gemini) from image blocks
     // before sending to Anthropic, which rejects extra inputs.
@@ -464,9 +546,7 @@ export class AnthropicAdapter implements ProviderAdapter {
     // otherwise `extra: { thinking, temperature }` reproduces the exact 400
     // this gate exists to prevent (same bug class as the extra-sampling bypass,
     // one field over).
-    const extraThinking = (request.extra as { thinking?: { type?: string } } | undefined)?.thinking;
-    const thinkingConfig = request.thinking ?? extraThinking;
-    const thinkingOn = thinkingConfig !== undefined && thinkingConfig.type !== 'disabled';
+    const thinkingOn = thinkingEnabled(request);
 
     if (request.temperature !== undefined && !stripSampling && !thinkingOn) {
       params.temperature = request.temperature;

package/src/providers/bedrock.ts

@@ -21,6 +21,11 @@ import {
   abortError,
 } from '../types/index.js';
 import { createCombinedSignal } from './utils.js';
+import {
+  INTERLEAVED_THINKING_BETA,
+  needsInterleavedThinkingBeta,
+  thinkingEnabled,
+} from './anthropic.js';
 
 // ============================================================================
 // Adapter Configuration
@@ -64,6 +69,8 @@ interface BedrockMessageRequest {
   stop_sequences?: string[];
   tools?: unknown[];
   thinking?: { type: 'enabled'; budget_tokens: number };
+  /** Beta flags. On bedrock-runtime these ride in the body, not a header. */
+  anthropic_beta?: string[];
 }
 
 interface BedrockMessageResponse {
@@ -407,6 +414,17 @@ export class BedrockAdapter implements ProviderAdapter {
       Object.assign(params, rest);
     }
 
+    // Interleaved thinking on pre-4.6 Claude 4: same gate as the Anthropic
+    // adapter, but bedrock-runtime takes betas as the `anthropic_beta` body
+    // field rather than an HTTP header. Runs after the extra-assign so a
+    // consumer-supplied anthropic_beta is merged (Set-deduped), not clobbered.
+    // The gate only matches Claude 4 <4.6 ids, so legacy 3.x models (which
+    // reject unknown beta flags) never receive the field.
+    if (thinkingEnabled(request) && needsInterleavedThinkingBeta(request.model)) {
+      const existing = Array.isArray(params.anthropic_beta) ? params.anthropic_beta : [];
+      params.anthropic_beta = [...new Set([...existing, INTERLEAVED_THINKING_BETA])];
+    }
+
     return params;
   }
 
@@ -499,6 +517,7 @@ export class BedrockAdapter implements ProviderAdapter {
     let inputTokens = 0;
     let outputTokens = 0;
     let stopReason: string = 'end_turn';
+    let stopSequence: string | undefined;
     let fullText = '';
 
     const reader = response.body?.getReader();
@@ -664,6 +683,16 @@ export class BedrockAdapter implements ProviderAdapter {
                   if (eventData.delta?.stop_reason) {
                     stopReason = eventData.delta.stop_reason;
                   }
+                  // WHICH stop sequence fired, not just that one did. Dropping
+                  // this (pre-2026-07-26) broke prefill/XML tool use on
+                  // Bedrock entirely: membrane's tool gate matches
+                  // stopSequence === '</function_calls>', so calls were never
+                  // parsed or executed, the close tag was never restored, and
+                  // the turn continuation looped forever on the dangling
+                  // block (~6 output tokens per full-prefill round).
+                  if (eventData.delta?.stop_sequence) {
+                    stopSequence = eventData.delta.stop_sequence;
+                  }
                 }
               }
             } catch (e) {
@@ -718,6 +747,7 @@ export class BedrockAdapter implements ProviderAdapter {
       }),
       model: modelId,
       stop_reason: stopReason as BedrockMessageResponse['stop_reason'],
+      stop_sequence: stopSequence ?? null,
       usage: {
         input_tokens: inputTokens,
         output_tokens: outputTokens,

package/src/types/content.ts

@@ -110,6 +110,17 @@ export interface ToolUseContent {
   id: string;
   name: string;
   input: Record<string, unknown>;
+  /**
+   * Verbatim document text this call was parsed from in prefill/XML mode:
+   * the full `<function_calls>…</function_calls>` block, shared by every
+   * invoke parsed from that block. Prefill formatters replay it exactly
+   * instead of synthesizing a rendering — in prefill mode the context IS
+   * the document the agent authored, and a paraphrase of its own action
+   * both corrupts the record and teaches the model a syntax the parser
+   * does not accept (membrane#36). Analogous to `signature` on a thinking
+   * block. Absent on native-tools blocks and on legacy stored blocks.
+   */
+  rawXml?: string;
   /** See {@link TextContent.rawItem}. */
   rawItem?: unknown;
 }
@@ -119,6 +130,13 @@ export interface ToolResultContent {
   toolUseId: string;
   content: string | ContentBlock[];
   isError?: boolean;
+  /**
+   * Verbatim document text this result was parsed from in prefill/XML mode:
+   * the full `<function_results>…</function_results>` block as the harness
+   * originally placed it in the document, shared by every result parsed
+   * from that block. Replayed exactly on the prefill path (membrane#36).
+   */
+  rawXml?: string;
   /** See {@link TextContent.rawItem}. */
   rawItem?: unknown;
 }

package/src/utils/tool-parser.ts

@@ -350,6 +350,10 @@ export function parseAccumulatedIntoBlocks(
   let funcMatch: RegExpExecArray | null;
   while ((funcMatch = FUNCTION_BLOCK_WITH_CONTENT_REGEX.exec(processedText)) !== null) {
     const innerContent = funcMatch[2] ?? '';
+    // Verbatim document text of the whole block — carried on each parsed
+    // tool_use so prefill replay reproduces the generation exactly instead
+    // of synthesizing a paraphrase (membrane#36).
+    const rawXml = funcMatch[0];
     const blockToolCalls: ContentBlock[] = [];
 
     // Parse invoke tags in this block
@@ -378,6 +382,7 @@ export function parseAccumulatedIntoBlocks(
         id,
         name: toolName,
         input,
+        rawXml,
       });
     }
 
@@ -394,6 +399,7 @@ export function parseAccumulatedIntoBlocks(
         id,
         name: toolName,
         input: {},
+        rawXml,
       });
     }
 
@@ -411,6 +417,9 @@ export function parseAccumulatedIntoBlocks(
   let resultsMatch: RegExpExecArray | null;
   while ((resultsMatch = FUNCTION_RESULTS_BLOCK_REGEX.exec(processedText)) !== null) {
     const innerContent = resultsMatch[2] ?? '';
+    // Verbatim document text the harness placed — carried for exact replay
+    // on the prefill path (membrane#36).
+    const rawXml = resultsMatch[0];
     const blockResults: ContentBlock[] = [];
 
     // Parse result tags
@@ -426,6 +435,7 @@ export function parseAccumulatedIntoBlocks(
         toolUseId,
         content,
         isError: false,
+        rawXml,
       });
     }
 
@@ -442,6 +452,7 @@ export function parseAccumulatedIntoBlocks(
         toolUseId,
         content,
         isError: true,
+        rawXml,
       });
     }