@animalabs/membrane 0.5.66 → 0.5.68

package/src/providers/anthropic.ts

@@ -2,7 +2,7 @@
  * Anthropic provider adapter
  */
 
-import Anthropic from '@anthropic-ai/sdk';
+import Anthropic, { type ClientOptions } from '@anthropic-ai/sdk';
 import type {
   ProviderAdapter,
   ProviderRequest,
@@ -27,10 +27,20 @@ import {
 
 export interface AnthropicAdapterConfig {
   /** API key (defaults to ANTHROPIC_API_KEY env var) */
-  apiKey?: string;
+  apiKey?: string | null;
+
+  /**
+   * OAuth/Bearer token (defaults to ANTHROPIC_AUTH_TOKEN env var when the SDK
+   * is allowed to resolve environment auth). If explicitly provided, API-key
+   * auth is disabled so requests do not send both auth schemes.
+   */
+  authToken?: string | null;
   
   /** Base URL override */
   baseURL?: string;
+
+  /** Default headers to include with Anthropic requests */
+  defaultHeaders?: ClientOptions['defaultHeaders'];
   
   /** Default max tokens */
   defaultMaxTokens?: number;
@@ -46,10 +56,19 @@ export class AnthropicAdapter implements ProviderAdapter {
   private defaultMaxTokens: number;
 
   constructor(config: AnthropicAdapterConfig = {}) {
-    this.client = new Anthropic({
-      apiKey: config.apiKey,
+    const clientOptions: ClientOptions = {
       baseURL: config.baseURL,
-    });
+      defaultHeaders: config.defaultHeaders,
+    };
+
+    if (config.authToken !== undefined) {
+      clientOptions.authToken = config.authToken;
+      clientOptions.apiKey = null;
+    } else {
+      clientOptions.apiKey = config.apiKey;
+    }
+
+    this.client = new Anthropic(clientOptions);
     this.defaultMaxTokens = config.defaultMaxTokens ?? 4096;
   }
 
@@ -432,6 +451,18 @@ export class AnthropicAdapter implements ProviderAdapter {
       if (message.toLowerCase().includes('overloaded')) {
         return serverError(message, 529, error, rawRequest);
       }
+
+      // Vercel AI Gateway wraps transient upstream outages (a fallback
+      // provider 503, routing churn on a sunsetting model) in non-5xx
+      // aggregate errors whose body carries gateway routing metadata. The
+      // SAME request frequently succeeds on retry once a live provider is
+      // picked, so classify these as retryable instead of terminal.
+      const gw = message.toLowerCase();
+      if (gw.includes("providermetadata") || gw.includes("fallbacksavailable") ||
+          gw.includes("modelattempts") || gw.includes("temporarily unavailable") ||
+          gw.includes("no_providers_available")) {
+        return serverError(message, status ?? 503, error, rawRequest);
+      }
     }
 
     if (error instanceof Error && error.name === 'AbortError') {
@@ -482,7 +513,7 @@ function toAnthropicToolResultContent(
           type: 'image',
           source: {
             type: 'base64',
-            media_type: block.source.mediaType as 'image/jpeg' | 'image/png' | 'image/gif' | 'image/webp',
+            media_type: detectImageMediaType(block.source.data, block.source.mediaType as string) as 'image/jpeg' | 'image/png' | 'image/gif' | 'image/webp',
             data: block.source.data,
           },
         });
@@ -501,6 +532,24 @@ function toAnthropicToolResultContent(
  * Convert normalized content blocks to Anthropic format
  * Preserves cache_control for prompt caching
  */
+
+/** Detect image media type from the base64 payload's magic bytes. Storage/ingest
+ *  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 {
+  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";
+    if (b[0]===0xff&&b[1]===0xd8&&b[2]===0xff) return "image/jpeg";
+    if (b[0]===0x47&&b[1]===0x49&&b[2]===0x46) return "image/gif";
+    if (b[0]===0x52&&b[1]===0x49&&b[2]===0x46) return "image/webp";
+  } catch {}
+  const f = (fallback || "").toLowerCase();
+  if (f==="image/jpeg"||f==="image/png"||f==="image/gif"||f==="image/webp") return f;
+  return "image/jpeg";
+}
+
 export function toAnthropicContent(blocks: ContentBlock[]): Anthropic.ContentBlockParam[] {
   const result: Anthropic.ContentBlockParam[] = [];
   
@@ -522,7 +571,7 @@ export function toAnthropicContent(blocks: ContentBlock[]): Anthropic.ContentBlo
             type: 'image',
             source: {
               type: 'base64',
-              media_type: block.source.mediaType as 'image/jpeg' | 'image/png' | 'image/gif' | 'image/webp',
+              media_type: detectImageMediaType(block.source.data, block.source.mediaType as string) as 'image/jpeg' | 'image/png' | 'image/gif' | 'image/webp',
               data: block.source.data,
             },
           });

package/src/providers/openai-compatible.ts

@@ -47,6 +47,26 @@ interface OpenAIMessage {
   content?: string | OpenAIContentPart[] | null;
   tool_calls?: OpenAIToolCall[];
   tool_call_id?: string;
+  /** Reasoning-model trace (OpenRouter et al. deliver this in a separate
+   *  channel from `content`). Captured into a thinking block, and re-sent on
+   *  prior assistant turns to preserve chain-of-thought. */
+  reasoning?: string;
+  reasoning_details?: unknown;
+}
+
+/**
+ * Some OpenRouter backends (e.g. Parasail, Io Net) spill the tail of the
+ * reasoning plus the closing `</think>` into the `content` channel instead of
+ * keeping it all in `reasoning`. If a `</think>` appears with no matching
+ * `<think>` before it, drop everything up to and including it — that prefix is
+ * leaked reasoning, not answer text.
+ */
+function stripOrphanThinkClose(text: string): string {
+  const close = text.indexOf('</think>');
+  if (close === -1) return text;
+  const open = text.indexOf('<think>');
+  if (open !== -1 && open < close) return text; // well-formed inline block — leave it
+  return text.slice(close + '</think>'.length).replace(/^\s+/, '');
 }
 
 interface OpenAIToolCall {
@@ -178,6 +198,7 @@ export class OpenAICompatibleAdapter implements ProviderAdapter {
       const decoder = new TextDecoder();
       const sseParser = new SSELineParser();
       let accumulated = '';
+      let reasoning = '';
       let finishReason = 'stop';
       let toolCalls: OpenAIToolCall[] = [];
 
@@ -200,6 +221,11 @@ export class OpenAICompatibleAdapter implements ProviderAdapter {
               callbacks.onChunk(delta.content);
             }
 
+            // Reasoning-model trace arrives on its own channel (not `content`).
+            if (typeof delta?.reasoning === 'string') {
+              reasoning += delta.reasoning;
+            }
+
             // Handle streaming tool calls
             if (delta?.tool_calls) {
               for (const tc of delta.tool_calls) {
@@ -234,6 +260,8 @@ export class OpenAICompatibleAdapter implements ProviderAdapter {
         content: accumulated || null,
       };
 
+      if (reasoning) message.reasoning = reasoning;
+
       if (toolCalls.length > 0) {
         message.tool_calls = toolCalls;
       }
@@ -336,10 +364,18 @@ export class OpenAICompatibleAdapter implements ProviderAdapter {
         const contentParts: OpenAIContentPart[] = [];
         const toolCalls: OpenAIToolCall[] = [];
         const toolResults: OpenAIMessage[] = [];
+        let reasoningText = '';
 
         for (const block of msg.content) {
           if (block.type === 'text') {
             contentParts.push({ type: 'text', text: block.text });
+          } else if (block.type === 'thinking') {
+            // Round-trip the reasoning trace back to the provider (OpenRouter
+            // accepts `reasoning` on a prior assistant turn), mirroring how the
+            // Anthropic adapter re-feeds signed thinking blocks.
+            if (typeof block.thinking === 'string') {
+              reasoningText += (reasoningText ? '\n' : '') + block.thinking;
+            }
           } else if (block.type === 'image') {
             // Convert Anthropic-style image to OpenAI image_url with data URI
             if (block.source?.type === 'base64') {
@@ -396,6 +432,10 @@ export class OpenAICompatibleAdapter implements ProviderAdapter {
           result.tool_calls = toolCalls;
         }
 
+        if (reasoningText) {
+          result.reasoning = reasoningText;
+        }
+
         return [result];
       }
       
@@ -486,11 +526,18 @@ export class OpenAICompatibleAdapter implements ProviderAdapter {
 
     const content: ContentBlock[] = [];
 
+    // Reasoning trace first (mirrors Anthropic thinking-block ordering).
+    const reasoning = (message as OpenAIMessage).reasoning;
+    if (typeof reasoning === 'string' && reasoning.trim()) {
+      content.push({ type: 'thinking', thinking: reasoning } as ContentBlock);
+    }
+
     if (message.content) {
-      const text = typeof message.content === 'string' ? message.content : message.content.filter(p => p.type === 'text').map(p => p.text!).join('\n');
+      const raw = typeof message.content === 'string' ? message.content : message.content.filter(p => p.type === 'text').map(p => p.text!).join('\n');
+      const text = stripOrphanThinkClose(raw);
       if (text) content.push({ type: 'text', text });
     }
-    
+
     if (message.tool_calls) {
       for (const tc of message.tool_calls) {
         content.push({
@@ -575,10 +622,15 @@ export function toOpenAIMessages(
     const textParts: string[] = [];
     const toolCalls: OpenAIToolCall[] = [];
     const toolResults: { id: string; content: string }[] = [];
-    
+    let reasoningText = '';
+
     for (const block of msg.content) {
       if (block.type === 'text') {
         textParts.push(block.text);
+      } else if (block.type === 'thinking') {
+        if (typeof (block as { thinking?: string }).thinking === 'string') {
+          reasoningText += (reasoningText ? '\n' : '') + (block as { thinking: string }).thinking;
+        }
       } else if (block.type === 'tool_use') {
         toolCalls.push({
           id: block.id,
@@ -597,7 +649,7 @@ export function toOpenAIMessages(
     }
     
     // Add main message
-    if (textParts.length > 0 || toolCalls.length > 0) {
+    if (textParts.length > 0 || toolCalls.length > 0 || reasoningText) {
       const message: OpenAIMessage = {
         role: msg.role as 'user' | 'assistant',
         content: textParts.join('\n') || null,
@@ -605,6 +657,9 @@ export function toOpenAIMessages(
       if (toolCalls.length > 0) {
         message.tool_calls = toolCalls;
       }
+      if (reasoningText) {
+        message.reasoning = reasoningText;
+      }
       result.push(message);
     }
     
@@ -627,11 +682,17 @@ export function toOpenAIMessages(
 export function fromOpenAIMessage(message: OpenAIMessage): ContentBlock[] {
   const result: ContentBlock[] = [];
 
+  const reasoning = message.reasoning;
+  if (typeof reasoning === 'string' && reasoning.trim()) {
+    result.push({ type: 'thinking', thinking: reasoning } as ContentBlock);
+  }
+
   if (message.content) {
-    const text = typeof message.content === 'string' ? message.content : message.content.filter(p => p.type === 'text').map(p => p.text!).join('\n');
+    const raw = typeof message.content === 'string' ? message.content : message.content.filter(p => p.type === 'text').map(p => p.text!).join('\n');
+    const text = stripOrphanThinkClose(raw);
     if (text) result.push({ type: 'text', text });
   }
-  
+
   if (message.tool_calls) {
     for (const tc of message.tool_calls) {
       result.push({