@animalabs/membrane 0.5.73 → 0.5.75

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;
   }
 
@@ -632,6 +650,15 @@ export class BedrockAdapter implements ProviderAdapter {
                     if (contentBlocks[currentBlockIndex]) {
                       contentBlocks[currentBlockIndex]!.signature = (contentBlocks[currentBlockIndex]!.signature ?? '') + (eventData.delta as any).signature;
                     }
+                  } else if (eventData.delta?.type === 'input_json_delta' && (eventData.delta as any).partial_json !== undefined) {
+                    // Tool-call arguments stream as input_json_delta fragments.
+                    // Dropping these (pre-2026-07-21 behavior) gutted every
+                    // tool_use block: stop_reason said tool_use but the block
+                    // lost its input — and then its id/name in final assembly.
+                    const blk = contentBlocks[currentBlockIndex] as (typeof contentBlocks)[number] & { partialJson?: string };
+                    if (blk) {
+                      blk.partialJson = (blk.partialJson ?? '') + (eventData.delta as any).partial_json;
+                    }
                   }
                 } else if (eventData.type === 'content_block_stop') {
                   // Mirror the Anthropic adapter: fire onContentBlock a second
@@ -640,6 +667,13 @@ export class BedrockAdapter implements ProviderAdapter {
                   // on the dual-fire convention (e.g. membrane's native
                   // yielding path) silently drops block_complete on Bedrock.
                   const blockIdx = (eventData as { index?: number }).index ?? currentBlockIndex;
+                  // Finalize tool_use blocks: parse accumulated argument JSON
+                  // into `input` before the block_complete fire, so consumers
+                  // of the dual-fire convention see a complete tool call.
+                  const stoppedBlk = contentBlocks[blockIdx] as ((typeof contentBlocks)[number] & { partialJson?: string; input?: unknown }) | undefined;
+                  if (stoppedBlk?.type === 'tool_use' && stoppedBlk.partialJson !== undefined) {
+                    try { stoppedBlk.input = JSON.parse(stoppedBlk.partialJson || '{}'); } catch { /* keep prior input */ }
+                  }
                   callbacks.onContentBlock?.(blockIdx, contentBlocks[blockIdx]);
                 } else if (eventData.type === 'message_delta') {
                   if (eventData.usage) {
@@ -687,6 +721,17 @@ export class BedrockAdapter implements ProviderAdapter {
           // Pass through verbatim — carries the encrypted `data` payload
           return { ...b } as unknown as { type: 'text'; text?: string };
         }
+        if (b.type === 'tool_use') {
+          // Preserve id/name and the input accumulated from input_json_delta
+          // fragments — the generic text mapping below would strip them and
+          // parseResponse would then drop the block (requires id && name).
+          const tb = b as { type: string; id?: string; name?: string; input?: unknown; partialJson?: string };
+          let input: unknown = tb.input ?? {};
+          if (tb.partialJson) {
+            try { input = JSON.parse(tb.partialJson); } catch { /* keep prior input */ }
+          }
+          return { type: 'tool_use', id: tb.id, name: tb.name, input } as unknown as { type: 'text'; text?: string };
+        }
         return { type: b.type as 'text', text: b.text };
       }),
       model: modelId,

package/src/types/config.ts

@@ -136,6 +136,14 @@ export interface MembraneConfig {
    */
   maxParticipantsForStop?: number;
 
+  /**
+   * Default for request.promptCaching when the request doesn't set it.
+   * Historical default is true (Anthropic API). Set false for transports
+   * that reject cache_control (e.g. Bedrock legacy Claude models, which 400
+   * with "your request did not allow prompt caching").
+   */
+  defaultPromptCaching?: 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

@@ -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/types/provider.ts

@@ -239,6 +239,12 @@ export interface ProviderRequestOptions {
   timeoutMs?: number;
   /** Abort if no SSE event arrives within this many ms (default: 120000) */
   idleTimeoutMs?: number;
+  /**
+   * Deadline for the FIRST stream event (TTFT). Large contexts on a cache
+   * miss legitimately take minutes before message_start while the SDK
+   * swallows ping keepalives (default: max(idleTimeoutMs, 600000)).
+   */
+  firstEventTimeoutMs?: number;
   /** Called with the raw API request body right before fetch */
   onRequest?: (rawRequest: unknown) => void;
   /**

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,
       });
     }