@animalabs/membrane 0.5.55 → 0.5.64

package/dist/types/tools.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tools.d.ts","sourceRoot":"","sources":["../../src/types/tools.ts"],"names":[],"mappings":"AAAA;;GAEG;AAMH,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;IAChB,KAAK,CAAC,EAAE,aAAa,CAAC;IACtB,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,CAAC;IAC3C,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;CACrB;AAED,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE;QACX,IAAI,EAAE,QAAQ,CAAC;QACf,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,CAAC;QAC3C,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;KACrB,CAAC;CACH;AAMD,MAAM,WAAW,QAAQ;IACvB,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAChC;AAED,MAAM,WAAW,UAAU;IACzB,SAAS,EAAE,MAAM,CAAC;IAClB;;;OAGG;IACH,OAAO,EAAE,MAAM,GAAG,sBAAsB,EAAE,CAAC;IAC3C,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB;AAED;;GAEG;AACH,MAAM,MAAM,sBAAsB,GAC9B;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GAC9B;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,MAAM,EAAE;QAAE,IAAI,EAAE,QAAQ,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAA;KAAE,CAAA;CAAE,CAAC;AAMnF,MAAM,WAAW,WAAW;IAC1B,iDAAiD;IACjD,OAAO,EAAE,MAAM,CAAC;IAEhB,4DAA4D;IAC5D,QAAQ,EAAE,MAAM,CAAC;IAEjB,2CAA2C;IAC3C,KAAK,EAAE,MAAM,CAAC;IAEd,oDAAoD;IACpD,eAAe,EAAE,UAAU,EAAE,CAAC;IAE9B,gCAAgC;IAChC,WAAW,EAAE,MAAM,CAAC;CACrB;AAMD,MAAM,WAAW,eAAe;IAC9B,wBAAwB;IACxB,KAAK,EAAE,QAAQ,EAAE,CAAC;IAElB,uCAAuC;IACvC,UAAU,EAAE,MAAM,CAAC;IAEnB,sCAAsC;IACtC,SAAS,EAAE,MAAM,CAAC;IAElB,4CAA4C;IAC5C,SAAS,EAAE,MAAM,CAAC;CACnB"}
+{"version":3,"file":"tools.d.ts","sourceRoot":"","sources":["../../src/types/tools.ts"],"names":[],"mappings":"AAAA;;GAEG;AAMH,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;IAChB,KAAK,CAAC,EAAE,aAAa,CAAC;IACtB,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,CAAC;IAC3C,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;CACrB;AAED,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE;QACX,IAAI,EAAE,QAAQ,CAAC;QACf,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,CAAC;QAC3C,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;KACrB,CAAC;CACH;AAMD,MAAM,WAAW,QAAQ;IACvB,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAChC;AAED,MAAM,WAAW,UAAU;IACzB,SAAS,EAAE,MAAM,CAAC;IAClB;;;OAGG;IACH,OAAO,EAAE,MAAM,GAAG,sBAAsB,EAAE,CAAC;IAC3C,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB;AAED;;GAEG;AACH,MAAM,MAAM,sBAAsB,GAC9B;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GAC9B;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,MAAM,EAAE;QAAE,IAAI,EAAE,QAAQ,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAA;KAAE,CAAA;CAAE,CAAC;AAMnF,MAAM,WAAW,WAAW;IAC1B,iDAAiD;IACjD,OAAO,EAAE,MAAM,CAAC;IAEhB,4DAA4D;IAC5D,QAAQ,EAAE,MAAM,CAAC;IAEjB,2CAA2C;IAC3C,KAAK,EAAE,MAAM,CAAC;IAEd,oDAAoD;IACpD,eAAe,EAAE,UAAU,EAAE,CAAC;IAE9B,gCAAgC;IAChC,WAAW,EAAE,MAAM,CAAC;IAEpB;;;;;;;OAOG;IACH,YAAY,CAAC,EAAE,OAAO,cAAc,EAAE,YAAY,EAAE,CAAC;CACtD;AAMD,MAAM,WAAW,eAAe;IAC9B,wBAAwB;IACxB,KAAK,EAAE,QAAQ,EAAE,CAAC;IAElB,uCAAuC;IACvC,UAAU,EAAE,MAAM,CAAC;IAEnB,sCAAsC;IACtC,SAAS,EAAE,MAAM,CAAC;IAElB,4CAA4C;IAC5C,SAAS,EAAE,MAAM,CAAC;CACnB"}

package/package.json

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

package/src/formatters/native.ts

@@ -385,10 +385,20 @@ export class NativeFormatter implements PrefillFormatter {
           is_error: block.isError,
         });
       } else if (block.type === 'thinking') {
+        // Round-trip thinking blocks verbatim, including the signature — the
+        // API validates it and (on display:'omitted' models) decrypts it to
+        // reconstruct the original reasoning. Signature-only blocks (empty
+        // thinking field) are valid and must be passed back unchanged.
         result.push({
           type: 'thinking',
           thinking: block.thinking,
+          ...((block as { signature?: string }).signature
+            ? { signature: (block as { signature?: string }).signature }
+            : {}),
         });
+      } else if (block.type === 'redacted_thinking') {
+        // Pass through verbatim (carries encrypted data field)
+        result.push({ ...(block as unknown as Record<string, unknown>) });
       } else if (block.type === 'document' || block.type === 'audio') {
         hasUnsupportedMedia = true;
       }

package/src/membrane.ts

@@ -292,6 +292,12 @@ export class Membrane {
     // These can't be handled by the text-based XML parser, so we capture and append them
     const extraContentBlocks: ContentBlock[] = [];
 
+    // Native thinking blocks from the provider (with signatures). The parser
+    // derives signature-less thinking blocks from <thinking> text (via
+    // wrapThinkingTags); signatures from these are merged into those after
+    // parsing, and signature-only blocks are prepended.
+    const providerThinkingBlocks: ContentBlock[] = [];
+
     // Transform initial request using the formatter
     let { providerRequest, prefillResult } = this.transformRequest(request, formatter);
 
@@ -385,6 +391,10 @@ export class Membrane {
           {
             signal,
             normalizedRequest: request,
+            // The tag-based parser tracks thinking via <thinking> tags — ask the
+            // provider to wrap native thinking deltas so they don't stream as
+            // visible text (see ProviderRequestOptions.wrapThinkingTags)
+            wrapThinkingTags: true,
             onRequest: (req) => {
               rawRequest = req;
               onRequest?.(req);
@@ -412,6 +422,10 @@ export class Membrane {
               } as ContentBlock);
             }
           }
+          // Native thinking blocks carry the signature (encrypted full
+          // reasoning) — captured so consumers can persist and round-trip
+          // them for reasoning continuity.
+          this.captureProviderThinkingBlocks(streamResult.content, providerThinkingBlocks);
         }
 
         rawResponse = streamResult.raw;
@@ -700,6 +714,9 @@ export class Membrane {
         response.content.push(...extraContentBlocks);
       }
 
+      // Merge provider thinking signatures into parser-derived thinking blocks
+      this.mergeProviderThinkingBlocks(response.content, providerThinkingBlocks);
+
       return response;
     } catch (error) {
       // Check if this is an abort error
@@ -1005,6 +1022,19 @@ export class Membrane {
             content: block.content,
             is_error: block.isError,
           });
+        } else if (block.type === 'thinking') {
+          // Round-trip thinking blocks verbatim including the signature — the
+          // API validates it and (on display:'omitted' models) decrypts it to
+          // reconstruct prior reasoning. Empty thinking + signature is valid.
+          content.push({
+            type: 'thinking',
+            thinking: (block as { thinking?: string }).thinking ?? '',
+            ...((block as { signature?: string }).signature
+              ? { signature: (block as { signature?: string }).signature }
+              : {}),
+          });
+        } else if (block.type === 'redacted_thinking') {
+          content.push({ ...(block as unknown as Record<string, unknown>) });
         } else if (block.type === 'image') {
           if (block.source.type === 'base64') {
             const imageBlock: Record<string, unknown> = {
@@ -1081,13 +1111,8 @@ export class Membrane {
       );
     }
 
-    // Build thinking config for native extended thinking
-    const thinking = request.config.thinking?.enabled
-      ? {
-          type: 'enabled' as const,
-          budget_tokens: request.config.thinking.budgetTokens ?? 5000,
-        }
-      : undefined;
+    // Build thinking config for native extended thinking (budget clamped to max_tokens)
+    const thinking = this.buildThinkingParam(request.config);
 
     // Anthropic requires temperature=1 when extended thinking is enabled
     const temperature = thinking ? 1 : request.config.temperature;
@@ -1125,9 +1150,12 @@ export class Membrane {
         } else if (item.type === 'thinking') {
           blocks.push({
             type: 'thinking',
-            thinking: item.thinking,
-            signature: item.signature,
+            thinking: item.thinking ?? '',
+            ...(item.signature ? { signature: item.signature } : {}),
           });
+        } else if (item.type === 'redacted_thinking') {
+          // Pass through verbatim — carries the encrypted `data` payload
+          blocks.push({ ...item } as ContentBlock);
         } else if (item.type === 'generated_image') {
           blocks.push({
             type: 'generated_image',
@@ -1138,14 +1166,75 @@ export class Membrane {
       }
       return blocks;
     }
-    
+
     if (typeof content === 'string') {
       return [{ type: 'text', text: content }];
     }
-    
+
     return [];
   }
 
+  /**
+   * Capture native thinking / redacted_thinking blocks from a provider
+   * response so they can be merged into parser-derived content (XML paths,
+   * where the parser only sees text). Includes signature-only thinking
+   * blocks (display:'omitted' returns an empty thinking field).
+   */
+  private captureProviderThinkingBlocks(
+    providerContent: unknown,
+    sink: ContentBlock[]
+  ): void {
+    if (!Array.isArray(providerContent)) return;
+    for (const block of providerContent) {
+      if (block?.type === 'thinking') {
+        sink.push({
+          type: 'thinking',
+          thinking: (block as any).thinking ?? '',
+          ...((block as any).signature ? { signature: (block as any).signature } : {}),
+        } as ContentBlock);
+      } else if (block?.type === 'redacted_thinking') {
+        sink.push({ ...(block as any) } as ContentBlock);
+      }
+    }
+  }
+
+  /**
+   * Merge provider thinking signatures into parser-derived thinking blocks
+   * (matched in stream order), and prepend any leftover provider blocks —
+   * signature-only thinking (display:'omitted') never appears in the text
+   * stream, so the parser produces no block for it. redacted_thinking
+   * blocks are always prepended verbatim.
+   *
+   * Mutates `content` in place. Shared by the XML stream paths
+   * (streamWithXmlTools and runXmlToolsYielding).
+   */
+  private mergeProviderThinkingBlocks(
+    content: ContentBlock[],
+    providerThinkingBlocks: ContentBlock[]
+  ): void {
+    if (providerThinkingBlocks.length === 0) return;
+
+    const parsedThinking = content.filter(
+      (b) => b.type === 'thinking'
+    ) as Array<{ type: 'thinking'; thinking: string; signature?: string }>;
+
+    const providerThinking = providerThinkingBlocks.filter((b) => b.type === 'thinking');
+    const redacted = providerThinkingBlocks.filter((b) => b.type === 'redacted_thinking');
+
+    const matched = Math.min(providerThinking.length, parsedThinking.length);
+    for (let i = 0; i < matched; i++) {
+      const sig = (providerThinking[i] as { signature?: string }).signature;
+      if (sig) {
+        parsedThinking[i]!.signature = sig;
+      }
+    }
+
+    const leftover = providerThinking.slice(matched);
+    if (leftover.length > 0 || redacted.length > 0) {
+      content.unshift(...leftover, ...redacted);
+    }
+  }
+
   // ==========================================================================
   // Internal Methods
   // ==========================================================================
@@ -1172,8 +1261,10 @@ export class Membrane {
    * Used by transformRequest, buildContinuationRequest, and buildContinuationRequestWithImages.
    */
   private getBaseProviderParams(config: NormalizedRequest['config']) {
+    // Build thinking config for native extended thinking
+    const thinking = this.buildThinkingParam(config);
     // Anthropic requires temperature=1 when extended thinking is enabled
-    const temperature = config.thinking?.enabled ? 1 : config.temperature;
+    const temperature = thinking ? 1 : config.temperature;
     return {
       model: config.model,
       maxTokens: config.maxTokens,
@@ -1182,9 +1273,41 @@ export class Membrane {
       topK: config.topK,
       presencePenalty: config.presencePenalty,
       frequencyPenalty: config.frequencyPenalty,
+      repetitionPenalty: config.repetitionPenalty,
+      thinking,
     };
   }
 
+  /**
+   * Build the provider thinking parameter from config.
+   *
+   * For type 'enabled', the API requires max_tokens > budget_tokens and a
+   * minimum budget of 1024 — a misconfigured budget (e.g., default 10000 with
+   * max_tokens 4096) is clamped to fit. If no valid budget fits (max_tokens
+   * too small), thinking is omitted entirely rather than sending a request
+   * the API will reject.
+   */
+  private buildThinkingParam(config: NormalizedRequest['config']):
+    | { type: 'adaptive'; display?: 'summarized' | 'omitted' }
+    | { type: 'enabled'; budget_tokens: number; display?: 'summarized' | 'omitted' }
+    | undefined {
+    if (!config.thinking?.enabled) return undefined;
+
+    const display = config.thinking.display;
+    if ((config.thinking.type ?? 'enabled') === 'adaptive') {
+      return { type: 'adaptive', ...(display ? { display } : {}) };
+    }
+
+    const requested = config.thinking.budgetTokens ?? 5000;
+    const maxTokens = typeof config.maxTokens === 'number' ? config.maxTokens : undefined;
+    const budget = maxTokens !== undefined ? Math.min(requested, maxTokens - 1024) : requested;
+    if (budget < 1024) {
+      // Can't fit a valid thinking budget under max_tokens — skip thinking
+      return undefined;
+    }
+    return { type: 'enabled', budget_tokens: budget, ...(display ? { display } : {}) };
+  }
+
   /**
    * Transform a normalized request into provider format using the formatter
    */
@@ -1232,6 +1355,15 @@ export class Membrane {
       },
     };
 
+    // The API rejects extended thinking combined with an assistant prefill.
+    // Prefill-style builds (XML formatter) use the thinking config for the
+    // literal `<thinking>` text prefix instead of the API feature — drop the
+    // API param when the built request actually ends in an assistant prefill.
+    // Chat-style builds (no prefill) keep it.
+    if (buildResult.assistantPrefill && providerRequest.thinking) {
+      delete providerRequest.thinking;
+    }
+
     return { providerRequest, prefillResult: buildResult };
   }
 
@@ -1243,6 +1375,8 @@ export class Membrane {
       timeoutMs?: number;
       idleTimeoutMs?: number;
       onRequest?: (rawRequest: unknown) => void;
+      /** See ProviderRequestOptions.wrapThinkingTags */
+      wrapThinkingTags?: boolean;
       /**
        * The original NormalizedRequest, threaded through so the
        * `beforeRequest` hook can see both shapes (normalized + provider).
@@ -1292,6 +1426,9 @@ export class Membrane {
     
     return {
       ...this.getBaseProviderParams(originalRequest.config),
+      // Continuations always end in an assistant prefill — the API rejects
+      // extended thinking combined with prefill, so never send the param here
+      thinking: undefined,
       messages,
       system: prefillResult.systemContent
         ? (Array.isArray(prefillResult.systemContent) && prefillResult.systemContent.length > 0
@@ -1362,6 +1499,9 @@ export class Membrane {
 
     return {
       ...this.getBaseProviderParams(originalRequest.config),
+      // Continuations always end in an assistant prefill — the API rejects
+      // extended thinking combined with prefill, so never send the param here
+      thinking: undefined,
       messages,
       system: prefillResult.systemContent
         ? (Array.isArray(prefillResult.systemContent) && prefillResult.systemContent.length > 0
@@ -1410,9 +1550,12 @@ export class Membrane {
         } else if (block.type === 'thinking') {
           content.push({
             type: 'thinking',
-            thinking: block.thinking,
-            signature: block.signature,
+            thinking: block.thinking ?? '',
+            ...(block.signature ? { signature: block.signature } : {}),
           });
+        } else if (block.type === 'redacted_thinking') {
+          // Pass through verbatim — carries the encrypted `data` payload
+          content.push({ ...(block as any) } as ContentBlock);
         } else if (block.type === 'generated_image') {
           content.push({
             type: 'generated_image',
@@ -1595,6 +1738,11 @@ export class Membrane {
         return 'stop_sequence';
       case 'tool_use':
         return 'tool_use';
+      case 'refusal':
+        // Safety refusal (e.g., Fable 5 reasoning_extraction). Must survive
+        // mapping — downstream consumers react to refusals (chapterx adds a
+        // Discord reaction). Defaulting this to end_turn silently hid them.
+        return 'refusal';
       default:
         return 'end_turn';
     }
@@ -1769,6 +1917,11 @@ export class Membrane {
     let rawRequest: unknown;
     let rawResponse: unknown;
 
+    // Native thinking blocks from the provider (with signatures) — merged
+    // into the parser-derived content before the final response is emitted.
+    // See streamWithXmlTools for the matching non-yielding logic.
+    const providerThinkingBlocks: ContentBlock[] = [];
+
     // Track executed tool calls and results
     const executedToolCalls: ToolCall[] = [];
     const executedToolResults: ToolResult[] = [];
@@ -1876,6 +2029,10 @@ export class Membrane {
             timeoutMs: options.timeoutMs,
             idleTimeoutMs: options.idleTimeoutMs,
             normalizedRequest: request,
+            // The tag-based parser tracks thinking via <thinking> tags — ask
+            // the provider to wrap native thinking deltas so they don't
+            // stream as visible text (same as streamWithXmlTools).
+            wrapThinkingTags: true,
             onRequest: (req: unknown) => { rawRequest = req; },
           }
         );
@@ -1888,6 +2045,11 @@ export class Membrane {
           streamResult.stopSequence = detectedStopSequence;
         }
 
+        // Capture native thinking blocks (with signatures) from the provider
+        // response — the text parser can't see signatures, so they're merged
+        // into the final response content after parsing.
+        this.captureProviderThinkingBlocks(streamResult.content, providerThinkingBlocks);
+
         rawResponse = streamResult.raw;
         lastStopReason = this.mapStopReason(streamResult.stopReason);
         lastStopSequence = streamResult.stopSequence ?? undefined;
@@ -2171,6 +2333,9 @@ export class Membrane {
         lastStopSequence
       );
 
+      // Merge provider thinking signatures into parser-derived thinking blocks
+      this.mergeProviderThinkingBlocks(response.content, providerThinkingBlocks);
+
       stream.emit({ type: 'complete', response });
     } catch (error) {
       if (this.isAbortError(error)) {
@@ -2377,6 +2542,10 @@ export class Membrane {
             depth: toolDepth,
             previousResults: executedToolResults,
             accumulated: allTextAccumulated,
+            // Full normalized blocks for this round, in provider order —
+            // lets consumers persist the assistant turn verbatim (signed
+            // thinking must precede tool_use in the same turn).
+            roundContent: responseBlocks,
           };
 
           // Yield control for tool execution
@@ -2483,13 +2652,16 @@ export class Membrane {
 }
 
 // Native tool names must match ^[a-zA-Z0-9_-]{1,128}$.
-// The framework uses module:tool namespacing, so we round-trip colons
-// through an escape encoding for the API wire format.
-// Lossless: escape underscores first (_u), then encode colons (_c).
+// Tool names use `--` namespacing, which is already API-valid; the only
+// character that ever needs escaping is a literal colon, encoded losslessly as
+// `__` and back. We deliberately do NOT escape underscores — they are valid,
+// and escaping them (the previous `_u`/`_c` scheme) garbled every
+// underscore-containing tool name in the request the model actually sees
+// (`send_message` → `send_umessage`), polluting its reasoning for no benefit.
 function sanitizeToolName(name: string): string {
-  return name.replace(/_/g, '_u').replace(/:/g, '_c');
+  return name.replace(/:/g, '__');
 }
 
 function unsanitizeToolName(name: string): string {
-  return name.replace(/_c/g, ':').replace(/_u/g, '_');
+  return name.replace(/__/g, ':');
 }

package/src/providers/anthropic.ts

@@ -122,12 +122,20 @@ export class AnthropicAdapter implements ProviderAdapter {
       let cacheReadTokens: number | undefined;
       let stopReason: string = 'end_turn';
       let stopSequence: string | undefined;
+      let stopDetails: unknown;
 
       // Content block tracking — finalized on content_block_stop
       const contentBlocks: Record<string, unknown>[] = [];
       let currentBlockIndex = -1;
       let currentBlockContent = '';
       let currentBlockInputJson = '';
+      // When wrapThinkingTags is set (XML formatter path), native thinking
+      // deltas are wrapped in <thinking>...</thinking> on the chunk stream so
+      // the tag-based parser tracks them as thinking instead of visible text.
+      // Tag opened lazily on the first delta — display:'omitted' models emit
+      // thinking blocks with no thinking_delta at all (signature only).
+      const wrapThinkingTags = options?.wrapThinkingTags === true;
+      let thinkingTagOpen = false;
 
       for await (const event of stream) {
         resetIdleTimer();
@@ -152,7 +160,21 @@ export class AnthropicAdapter implements ProviderAdapter {
             callbacks.onChunk(chunk);
           } else if (event.delta.type === 'thinking_delta') {
             currentBlockContent += event.delta.thinking;
+            if (wrapThinkingTags && !thinkingTagOpen) {
+              callbacks.onChunk('<thinking>');
+              thinkingTagOpen = true;
+            }
             callbacks.onChunk(event.delta.thinking);
+          } else if ((event.delta as { type: string }).type === 'signature_delta') {
+            // Accumulate the cryptographic signature that authenticates this
+            // thinking block. Without this, signatures never land on the
+            // streaming path and the next request — which carries the block
+            // back in history — fails Anthropic's signature validation.
+            const sig = (event.delta as { signature?: string }).signature;
+            const block = contentBlocks[currentBlockIndex];
+            if (block && block.type === 'thinking' && sig) {
+              block.signature = ((block.signature as string | undefined) ?? '') + sig;
+            }
           } else if ((event.delta as { type: string }).type === 'input_json_delta') {
             currentBlockInputJson += (event.delta as { partial_json: string }).partial_json;
           }
@@ -166,6 +188,10 @@ export class AnthropicAdapter implements ProviderAdapter {
               block.text = currentBlockContent;
             } else if (block.type === 'thinking') {
               block.thinking = currentBlockContent;
+              if (thinkingTagOpen) {
+                callbacks.onChunk('</thinking>\n');
+                thinkingTagOpen = false;
+              }
             } else if (block.type === 'tool_use' && currentBlockInputJson) {
               try { block.input = JSON.parse(currentBlockInputJson); } catch { /* partial JSON */ }
             }
@@ -176,9 +202,15 @@ export class AnthropicAdapter implements ProviderAdapter {
           // All content blocks are finalized by the time message_delta arrives.
           // Capture final metadata and exit — message_stop and the SSE connection
           // teardown after it add only variable latency with no useful data.
-          const delta = event.delta as { stop_reason?: string; stop_sequence?: string };
+          const delta = event.delta as {
+            stop_reason?: string;
+            stop_sequence?: string;
+            stop_details?: unknown;
+          };
           stopReason = delta.stop_reason ?? 'end_turn';
           stopSequence = delta.stop_sequence ?? undefined;
+          // stop_details carries refusal metadata (e.g., category: 'reasoning_extraction')
+          stopDetails = delta.stop_details ?? undefined;
           const deltaUsage = event.usage as unknown as {
             output_tokens: number;
             cache_creation_input_tokens?: number | null;
@@ -219,6 +251,7 @@ export class AnthropicAdapter implements ProviderAdapter {
           content: contentBlocks,
           stop_reason: stopReason,
           stop_sequence: stopSequence ?? null,
+          stop_details: stopDetails ?? null,
           model,
           usage: {
             input_tokens: inputTokens,
@@ -249,7 +282,11 @@ export class AnthropicAdapter implements ProviderAdapter {
 
   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
+    // before sending to Anthropic, which rejects extra inputs.
+    // Also normalize nested tool_result content blocks: Membrane uses camelCase
+    // `mediaType`, Anthropic expects snake_case `media_type`. Without this,
+    // an image returned by a tool reaches the API as `{source: {mediaType: ...}}`
+    // and is silently rejected (the model sees the text label only).
     const sanitizedMessages = (request.messages as any[]).map((msg: any) => {
       if (!Array.isArray(msg.content)) return msg;
       return {
@@ -259,6 +296,12 @@ export class AnthropicAdapter implements ProviderAdapter {
             const { sourceUrl, ...rest } = block;
             return rest;
           }
+          if (block.type === 'tool_result' && Array.isArray(block.content)) {
+            return {
+              ...block,
+              content: toAnthropicToolResultContent(block.content as ContentBlock[]),
+            };
+          }
           return block;
         }),
       };
@@ -396,6 +439,41 @@ export class AnthropicAdapter implements ProviderAdapter {
 // Content Conversion Utilities
 // ============================================================================
 
+/**
+ * Convert Membrane tool-result content blocks to Anthropic's tool_result.content
+ * mixed array (text + image). This is what carries an image returned by a tool
+ * (e.g. an MCP fetch_attachment result) all the way to the model. Other block
+ * types are not valid inside tool_result.content per the Anthropic API and are
+ * dropped.
+ */
+function toAnthropicToolResultContent(
+  blocks: ContentBlock[],
+): Array<Anthropic.TextBlockParam | Anthropic.ImageBlockParam> {
+  const out: Array<Anthropic.TextBlockParam | Anthropic.ImageBlockParam> = [];
+  for (const block of blocks) {
+    if (block.type === 'text') {
+      out.push({ type: 'text', text: block.text });
+    } else if (block.type === 'image') {
+      if (block.source.type === 'base64') {
+        out.push({
+          type: 'image',
+          source: {
+            type: 'base64',
+            media_type: block.source.mediaType as 'image/jpeg' | 'image/png' | 'image/gif' | 'image/webp',
+            data: block.source.data,
+          },
+        });
+      } else if (block.source.type === 'url') {
+        out.push({
+          type: 'image',
+          source: { type: 'url', url: block.source.url },
+        });
+      }
+    }
+  }
+  return out;
+}
+
 /**
  * Convert normalized content blocks to Anthropic format
  * Preserves cache_control for prompt caching
@@ -425,6 +503,11 @@ export function toAnthropicContent(blocks: ContentBlock[]): Anthropic.ContentBlo
               data: block.source.data,
             },
           });
+        } else if (block.source.type === 'url') {
+          result.push({
+            type: 'image',
+            source: { type: 'url', url: block.source.url },
+          });
         }
         break;
         
@@ -454,7 +537,7 @@ export function toAnthropicContent(blocks: ContentBlock[]): Anthropic.ContentBlo
           tool_use_id: block.toolUseId,
           content: typeof block.content === 'string'
             ? block.content
-            : JSON.stringify(block.content),
+            : toAnthropicToolResultContent(block.content),
           is_error: block.isError,
         });
         break;
@@ -463,11 +546,21 @@ export function toAnthropicContent(blocks: ContentBlock[]): Anthropic.ContentBlo
         result.push({
           type: 'thinking',
           thinking: block.thinking,
+          ...(block.signature ? { signature: block.signature } : {}),
+        } as any);
+        break;
+
+      case 'redacted_thinking':
+        // Round-trip verbatim — `data` is the encrypted reasoning payload;
+        // the API rejects/ignores the block without it.
+        result.push({
+          type: 'redacted_thinking',
+          data: (block as any).data,
         } as any);
         break;
     }
   }
-  
+
   return result;
 }
 
@@ -503,7 +596,9 @@ export function fromAnthropicContent(blocks: Anthropic.ContentBlock[]): ContentB
       default:
         // Handle redacted_thinking or unknown types
         if ((block as any).type === 'redacted_thinking') {
-          result.push({ type: 'redacted_thinking' });
+          // Preserve the encrypted `data` payload — without it the block
+          // cannot be round-tripped and prior reasoning is lost.
+          result.push({ type: 'redacted_thinking', data: (block as any).data } as any);
         }
         break;
     }

package/src/providers/bedrock.ts

@@ -681,7 +681,11 @@ export class BedrockAdapter implements ProviderAdapter {
       role: 'assistant',
       content: contentBlocks.map(b => {
         if (b.type === 'thinking') {
-          return { type: 'thinking' as const, thinking: b.thinking, signature: b.signature };
+          return { type: 'thinking' as const, thinking: b.thinking ?? '', signature: b.signature };
+        }
+        if (b.type === 'redacted_thinking') {
+          // Pass through verbatim — carries the encrypted `data` payload
+          return { ...b } as unknown as { type: 'text'; text?: string };
         }
         return { type: b.type as 'text', text: b.text };
       }),
@@ -709,12 +713,17 @@ export class BedrockAdapter implements ProviderAdapter {
           name: block.name,
           input: block.input as Record<string, unknown>,
         });
-      } else if (block.type === 'thinking' && block.thinking) {
+      } else if (block.type === 'thinking') {
+        // Signature-only thinking blocks (display:'omitted') have an empty
+        // thinking field but must still be preserved for round-tripping.
         content.push({
           type: 'thinking',
-          thinking: block.thinking,
-          signature: block.signature,
+          thinking: block.thinking ?? '',
+          ...(block.signature ? { signature: block.signature } : {}),
         });
+      } else if ((block as any).type === 'redacted_thinking') {
+        // Pass through verbatim — carries the encrypted `data` payload
+        content.push({ ...(block as any) } as ContentBlock);
       }
     }
 

package/src/providers/openai-compatible.ts

@@ -301,6 +301,10 @@ export class OpenAICompatibleAdapter implements ProviderAdapter {
       params.frequency_penalty = request.frequencyPenalty;
     }
 
+    if (request.repetitionPenalty !== undefined) {
+      params.repetition_penalty = request.repetitionPenalty;
+    }
+
     // OpenAI-compatible APIs may limit stop sequences (OpenAI: 4) — truncate to be safe
     if (request.stopSequences && request.stopSequences.length > 0) {
       params.stop = request.stopSequences.slice(0, 4);