@animalabs/membrane 0.1.3 → 0.1.5

package/src/membrane.ts

@@ -95,23 +95,24 @@ export class Membrane {
           finalRequest = await this.config.hooks.beforeRequest(request, providerRequest) ?? providerRequest;
         }
 
-        rawRequest = finalRequest;
-
-        // Call onRequest callback for logging
-        options.onRequest?.(rawRequest);
-
         const providerResponse = await this.adapter.complete(finalRequest, {
           signal: options.signal,
           timeoutMs: options.timeoutMs,
         });
 
+        // Use the actual raw request from provider (after any adapter transformations)
+        rawRequest = providerResponse.rawRequest;
+
+        // Call onRequest callback with actual request sent to API
+        options.onRequest?.(rawRequest);
+
         const response = this.transformResponse(
           providerResponse,
           request,
           prefillResult,
           startTime,
           attempts,
-          finalRequest
+          rawRequest
         );
 
         // Call afterResponse hook
@@ -239,17 +240,16 @@ export class Membrane {
 
     // Initialize parser with prefill content so it knows about any open tags
     // (e.g., <thinking> in the prefill means API response continues inside thinking)
+    // Track the initial prefill length so we can extract only NEW content for response
+    let initialPrefillLength = 0;
     if (prefillResult.assistantPrefill) {
       parser.push(prefillResult.assistantPrefill);
+      initialPrefillLength = prefillResult.assistantPrefill.length;
     }
 
     try {
       // Tool execution loop
       while (toolDepth <= maxToolDepth) {
-        rawRequest = providerRequest;
-
-        // Call onRequest callback for logging
-        onRequest?.(rawRequest);
 
         // Track if we manually detected a stop sequence (API doesn't always stop)
         let detectedStopSequence: string | null = null;
@@ -325,6 +325,12 @@ export class Membrane {
           streamResult.stopSequence = detectedStopSequence;
         }
 
+        // Use the actual raw request from provider (after adapter transformations)
+        rawRequest = streamResult.rawRequest;
+
+        // Call onRequest callback with actual request sent to API
+        onRequest?.(rawRequest);
+
         rawResponse = streamResult.raw;
         lastStopReason = this.mapStopReason(streamResult.stopReason);
 
@@ -455,9 +461,13 @@ export class Membrane {
         break;
       }
 
-      // Build final response
+      // Build final response - only use NEW content (after initial prefill) for content parsing
+      // The full accumulated text is still available in raw.response
+      const fullAccumulated = parser.getAccumulated();
+      const newContent = fullAccumulated.slice(initialPrefillLength);
+
       return this.buildFinalResponse(
-        parser.getAccumulated(),
+        newContent,
         contentBlocks,
         lastStopReason,
         totalUsage,
@@ -473,8 +483,12 @@ export class Membrane {
     } catch (error) {
       // Check if this is an abort error
       if (this.isAbortError(error)) {
+        // Only use NEW content (after initial prefill) for partial content
+        const fullAccumulated = parser.getAccumulated();
+        const newContent = fullAccumulated.slice(initialPrefillLength);
+
         return this.buildAbortedResponse(
-          parser.getAccumulated(),
+          newContent,
           totalUsage,
           executedToolCalls,
           executedToolResults,
@@ -527,10 +541,6 @@ export class Membrane {
       while (toolDepth <= maxToolDepth) {
         // Build provider request with native tools
         const providerRequest = this.buildNativeToolRequest(request, messages);
-        rawRequest = providerRequest;
-
-        // Call onRequest callback for logging
-        onRequest?.(rawRequest);
 
         // Stream from provider
         let textAccumulated = '';
@@ -557,6 +567,12 @@ export class Membrane {
           { signal }
         );
 
+        // Use the actual raw request from provider (after adapter transformations)
+        rawRequest = streamResult.rawRequest;
+
+        // Call onRequest callback with actual request sent to API
+        onRequest?.(rawRequest);
+
         rawResponse = streamResult.raw;
         lastStopReason = this.mapStopReason(streamResult.stopReason);
 

package/src/providers/anthropic.ts

@@ -61,18 +61,16 @@ export class AnthropicAdapter implements ProviderAdapter {
     options?: ProviderRequestOptions
   ): Promise<ProviderResponse> {
     const anthropicRequest = this.buildRequest(request);
-    
+    const fullRequest = { ...anthropicRequest, stream: false as const };
+
     try {
-      const response = await this.client.messages.create({
-        ...anthropicRequest,
-        stream: false,
-      }, {
+      const response = await this.client.messages.create(fullRequest, {
         signal: options?.signal,
       });
-      
-      return this.parseResponse(response);
+
+      return this.parseResponse(response, fullRequest);
     } catch (error) {
-      throw this.handleError(error);
+      throw this.handleError(error, fullRequest);
     }
   }
 
@@ -82,16 +80,18 @@ export class AnthropicAdapter implements ProviderAdapter {
     options?: ProviderRequestOptions
   ): Promise<ProviderResponse> {
     const anthropicRequest = this.buildRequest(request);
-    
+    // Note: stream is implicitly true when using .stream()
+    const fullRequest = { ...anthropicRequest, stream: true };
+
     try {
       const stream = await this.client.messages.stream(anthropicRequest, {
         signal: options?.signal,
       });
-      
+
       let accumulated = '';
       const contentBlocks: unknown[] = [];
       let currentBlockIndex = -1;
-      
+
       for await (const event of stream) {
         if (event.type === 'content_block_start') {
           currentBlockIndex = event.index;
@@ -110,12 +110,12 @@ export class AnthropicAdapter implements ProviderAdapter {
           callbacks.onContentBlock?.(currentBlockIndex, contentBlocks[currentBlockIndex]);
         }
       }
-      
+
       const finalMessage = await stream.finalMessage();
-      return this.parseResponse(finalMessage);
-      
+      return this.parseResponse(finalMessage, fullRequest);
+
     } catch (error) {
-      throw this.handleError(error);
+      throw this.handleError(error, fullRequest);
     }
   }
 
@@ -161,7 +161,7 @@ export class AnthropicAdapter implements ProviderAdapter {
     return params;
   }
 
-  private parseResponse(response: Anthropic.Message): ProviderResponse {
+  private parseResponse(response: Anthropic.Message, rawRequest: unknown): ProviderResponse {
     return {
       content: response.content,
       stopReason: response.stop_reason ?? 'end_turn',
@@ -173,43 +173,45 @@ export class AnthropicAdapter implements ProviderAdapter {
         cacheReadTokens: (response.usage as any).cache_read_input_tokens,
       },
       model: response.model,
+      rawRequest,
       raw: response,
     };
   }
 
-  private handleError(error: unknown): MembraneError {
+  private handleError(error: unknown, rawRequest?: unknown): MembraneError {
     if (error instanceof Anthropic.APIError) {
       const status = error.status;
       const message = error.message;
-      
+
       if (status === 429) {
         // Try to parse retry-after
         const retryAfter = this.parseRetryAfter(error);
-        return rateLimitError(message, retryAfter, error);
+        return rateLimitError(message, retryAfter, error, rawRequest);
       }
-      
+
       if (status === 401) {
-        return authError(message, error);
+        return authError(message, error, rawRequest);
       }
-      
+
       if (message.includes('context') || message.includes('too long')) {
-        return contextLengthError(message, error);
+        return contextLengthError(message, error, rawRequest);
       }
-      
+
       if (status >= 500) {
-        return serverError(message, status, error);
+        return serverError(message, status, error, rawRequest);
       }
     }
-    
+
     if (error instanceof Error && error.name === 'AbortError') {
-      return abortError();
+      return abortError(undefined, rawRequest);
     }
-    
+
     return new MembraneError({
       type: 'unknown',
       message: error instanceof Error ? error.message : String(error),
       retryable: false,
       rawError: error,
+      rawRequest,
     });
   }
 

package/src/providers/openai-compatible.ts

@@ -130,12 +130,12 @@ export class OpenAICompatibleAdapter implements ProviderAdapter {
     options?: ProviderRequestOptions
   ): Promise<ProviderResponse> {
     const openAIRequest = this.buildRequest(request);
-    
+
     try {
       const response = await this.makeRequest(openAIRequest, options);
-      return this.parseResponse(response, request.model);
+      return this.parseResponse(response, request.model, openAIRequest);
     } catch (error) {
-      throw this.handleError(error);
+      throw this.handleError(error, openAIRequest);
     }
   }
 
@@ -146,7 +146,7 @@ export class OpenAICompatibleAdapter implements ProviderAdapter {
   ): Promise<ProviderResponse> {
     const openAIRequest = this.buildRequest(request);
     openAIRequest.stream = true;
-    
+
     try {
       const response = await fetch(`${this.baseURL}/chat/completions`, {
         method: 'POST',
@@ -154,42 +154,42 @@ export class OpenAICompatibleAdapter implements ProviderAdapter {
         body: JSON.stringify(openAIRequest),
         signal: options?.signal,
       });
-      
+
       if (!response.ok) {
         const errorText = await response.text();
         throw new Error(`API error: ${response.status} ${errorText}`);
       }
-      
+
       const reader = response.body?.getReader();
       if (!reader) {
         throw new Error('No response body');
       }
-      
+
       const decoder = new TextDecoder();
       let accumulated = '';
       let finishReason = 'stop';
       let toolCalls: OpenAIToolCall[] = [];
-      
+
       while (true) {
         const { done, value } = await reader.read();
         if (done) break;
-        
+
         const chunk = decoder.decode(value, { stream: true });
         const lines = chunk.split('\n').filter(line => line.startsWith('data: '));
-        
+
         for (const line of lines) {
           const data = line.slice(6);
           if (data === '[DONE]') continue;
-          
+
           try {
             const parsed = JSON.parse(data);
             const delta = parsed.choices?.[0]?.delta;
-            
+
             if (delta?.content) {
               accumulated += delta.content;
               callbacks.onChunk(delta.content);
             }
-            
+
             // Handle streaming tool calls
             if (delta?.tool_calls) {
               for (const tc of delta.tool_calls) {
@@ -208,7 +208,7 @@ export class OpenAICompatibleAdapter implements ProviderAdapter {
                 }
               }
             }
-            
+
             if (parsed.choices?.[0]?.finish_reason) {
               finishReason = parsed.choices[0].finish_reason;
             }
@@ -217,21 +217,21 @@ export class OpenAICompatibleAdapter implements ProviderAdapter {
           }
         }
       }
-      
+
       // Build response with accumulated data
       const message: OpenAIMessage = {
         role: 'assistant',
         content: accumulated || null,
       };
-      
+
       if (toolCalls.length > 0) {
         message.tool_calls = toolCalls;
       }
-      
-      return this.parseStreamedResponse(message, finishReason, request.model);
-      
+
+      return this.parseStreamedResponse(message, finishReason, request.model, openAIRequest);
+
     } catch (error) {
-      throw this.handleError(error);
+      throw this.handleError(error, openAIRequest);
     }
   }
 
@@ -371,10 +371,10 @@ export class OpenAICompatibleAdapter implements ProviderAdapter {
     return response.json() as Promise<OpenAIResponse>;
   }
 
-  private parseResponse(response: OpenAIResponse, requestedModel: string): ProviderResponse {
+  private parseResponse(response: OpenAIResponse, requestedModel: string, rawRequest: unknown): ProviderResponse {
     const choice = response.choices[0];
     const message = choice?.message;
-    
+
     return {
       content: this.messageToContent(message),
       stopReason: this.mapFinishReason(choice?.finish_reason),
@@ -384,6 +384,7 @@ export class OpenAICompatibleAdapter implements ProviderAdapter {
         outputTokens: response.usage?.completion_tokens ?? 0,
       },
       model: response.model ?? requestedModel,
+      rawRequest,
       raw: response,
     };
   }
@@ -391,7 +392,8 @@ export class OpenAICompatibleAdapter implements ProviderAdapter {
   private parseStreamedResponse(
     message: OpenAIMessage,
     finishReason: string,
-    requestedModel: string
+    requestedModel: string,
+    rawRequest?: unknown
   ): ProviderResponse {
     return {
       content: this.messageToContent(message),
@@ -402,6 +404,7 @@ export class OpenAICompatibleAdapter implements ProviderAdapter {
         outputTokens: 0,
       },
       model: requestedModel,
+      rawRequest,
       raw: { message, finish_reason: finishReason },
     };
   }
@@ -444,40 +447,41 @@ export class OpenAICompatibleAdapter implements ProviderAdapter {
     }
   }
 
-  private handleError(error: unknown): MembraneError {
+  private handleError(error: unknown, rawRequest?: unknown): MembraneError {
     if (error instanceof Error) {
       const message = error.message;
-      
+
       if (message.includes('429') || message.includes('rate')) {
-        return rateLimitError(message, undefined, error);
+        return rateLimitError(message, undefined, error, rawRequest);
       }
-      
+
       if (message.includes('401') || message.includes('auth') || message.includes('Unauthorized')) {
-        return authError(message, error);
+        return authError(message, error, rawRequest);
       }
-      
+
       if (message.includes('context') || message.includes('too long') || message.includes('maximum context')) {
-        return contextLengthError(message, error);
+        return contextLengthError(message, error, rawRequest);
       }
-      
+
       if (message.includes('500') || message.includes('502') || message.includes('503')) {
-        return serverError(message, undefined, error);
+        return serverError(message, undefined, error, rawRequest);
       }
-      
+
       if (error.name === 'AbortError') {
-        return abortError();
+        return abortError(undefined, rawRequest);
       }
-      
+
       if (message.includes('network') || message.includes('fetch') || message.includes('ECONNREFUSED')) {
-        return networkError(message, error);
+        return networkError(message, error, rawRequest);
       }
     }
-    
+
     return new MembraneError({
       type: 'unknown',
       message: error instanceof Error ? error.message : String(error),
       retryable: false,
       rawError: error,
+      rawRequest,
     });
   }
 }

package/src/providers/openai.ts

@@ -203,12 +203,12 @@ export class OpenAIAdapter implements ProviderAdapter {
     options?: ProviderRequestOptions
   ): Promise<ProviderResponse> {
     const openAIRequest = this.buildRequest(request);
-    
+
     try {
       const response = await this.makeRequest(openAIRequest, options);
-      return this.parseResponse(response, request.model);
+      return this.parseResponse(response, request.model, openAIRequest);
     } catch (error) {
-      throw this.handleError(error);
+      throw this.handleError(error, openAIRequest);
     }
   }
 
@@ -221,7 +221,7 @@ export class OpenAIAdapter implements ProviderAdapter {
     openAIRequest.stream = true;
     // Request usage data in stream for cache metrics
     openAIRequest.stream_options = { include_usage: true };
-    
+
     try {
       const response = await fetch(`${this.baseURL}/chat/completions`, {
         method: 'POST',
@@ -229,43 +229,43 @@ export class OpenAIAdapter implements ProviderAdapter {
         body: JSON.stringify(openAIRequest),
         signal: options?.signal,
       });
-      
+
       if (!response.ok) {
         const errorText = await response.text();
         throw new Error(`OpenAI API error: ${response.status} ${errorText}`);
       }
-      
+
       const reader = response.body?.getReader();
       if (!reader) {
         throw new Error('No response body');
       }
-      
+
       const decoder = new TextDecoder();
       let accumulated = '';
       let finishReason = 'stop';
       let toolCalls: OpenAIToolCall[] = [];
       let streamUsage: OpenAIResponse['usage'] | undefined;
-      
+
       while (true) {
         const { done, value } = await reader.read();
         if (done) break;
-        
+
         const chunk = decoder.decode(value, { stream: true });
         const lines = chunk.split('\n').filter(line => line.startsWith('data: '));
-        
+
         for (const line of lines) {
           const data = line.slice(6);
           if (data === '[DONE]') continue;
-          
+
           try {
             const parsed = JSON.parse(data);
             const delta = parsed.choices?.[0]?.delta;
-            
+
             if (delta?.content) {
               accumulated += delta.content;
               callbacks.onChunk(delta.content);
             }
-            
+
             // Handle streaming tool calls
             if (delta?.tool_calls) {
               for (const tc of delta.tool_calls) {
@@ -284,11 +284,11 @@ export class OpenAIAdapter implements ProviderAdapter {
                 }
               }
             }
-            
+
             if (parsed.choices?.[0]?.finish_reason) {
               finishReason = parsed.choices[0].finish_reason;
             }
-            
+
             // Capture usage data (comes in final chunk with stream_options.include_usage)
             if (parsed.usage) {
               streamUsage = parsed.usage;
@@ -298,21 +298,21 @@ export class OpenAIAdapter implements ProviderAdapter {
           }
         }
       }
-      
+
       // Build response with accumulated data
       const message: OpenAIMessage = {
         role: 'assistant',
         content: accumulated || null,
       };
-      
+
       if (toolCalls.length > 0) {
         message.tool_calls = toolCalls;
       }
-      
-      return this.parseStreamedResponse(message, finishReason, request.model, streamUsage);
-      
+
+      return this.parseStreamedResponse(message, finishReason, request.model, streamUsage, openAIRequest);
+
     } catch (error) {
-      throw this.handleError(error);
+      throw this.handleError(error, openAIRequest);
     }
   }
 
@@ -460,13 +460,13 @@ export class OpenAIAdapter implements ProviderAdapter {
     return response.json() as Promise<OpenAIResponse>;
   }
 
-  private parseResponse(response: OpenAIResponse, requestedModel: string): ProviderResponse {
+  private parseResponse(response: OpenAIResponse, requestedModel: string, rawRequest: unknown): ProviderResponse {
     const choice = response.choices[0];
     const message = choice?.message;
-    
+
     // Extract prompt caching details (OpenAI automatic caching for prompts ≥1024 tokens)
     const cachedTokens = response.usage?.prompt_tokens_details?.cached_tokens ?? 0;
-    
+
     return {
       content: this.messageToContent(message),
       stopReason: this.mapFinishReason(choice?.finish_reason),
@@ -479,6 +479,7 @@ export class OpenAIAdapter implements ProviderAdapter {
         cacheReadTokens: cachedTokens > 0 ? cachedTokens : undefined,
       },
       model: response.model ?? requestedModel,
+      rawRequest,
       raw: response,
     };
   }
@@ -487,11 +488,12 @@ export class OpenAIAdapter implements ProviderAdapter {
     message: OpenAIMessage,
     finishReason: string,
     requestedModel: string,
-    streamUsage?: OpenAIResponse['usage']
+    streamUsage?: OpenAIResponse['usage'],
+    rawRequest?: unknown
   ): ProviderResponse {
     // Extract cached tokens from stream usage if available
     const cachedTokens = streamUsage?.prompt_tokens_details?.cached_tokens ?? 0;
-    
+
     return {
       content: this.messageToContent(message),
       stopReason: this.mapFinishReason(finishReason),
@@ -502,6 +504,7 @@ export class OpenAIAdapter implements ProviderAdapter {
         cacheReadTokens: cachedTokens > 0 ? cachedTokens : undefined,
       },
       model: requestedModel,
+      rawRequest,
       raw: { message, finish_reason: finishReason, usage: streamUsage },
     };
   }
@@ -544,44 +547,45 @@ export class OpenAIAdapter implements ProviderAdapter {
     }
   }
 
-  private handleError(error: unknown): MembraneError {
+  private handleError(error: unknown, rawRequest?: unknown): MembraneError {
     if (error instanceof Error) {
       const message = error.message;
-      
+
       // OpenAI specific error patterns
       if (message.includes('429') || message.includes('rate_limit')) {
         // Try to extract retry-after
         const retryMatch = message.match(/retry after (\d+)/i);
         const retryAfter = retryMatch?.[1] ? parseInt(retryMatch[1], 10) * 1000 : undefined;
-        return rateLimitError(message, retryAfter, error);
+        return rateLimitError(message, retryAfter, error, rawRequest);
       }
-      
+
       if (message.includes('401') || message.includes('invalid_api_key') || message.includes('Incorrect API key')) {
-        return authError(message, error);
+        return authError(message, error, rawRequest);
       }
-      
+
       if (message.includes('context_length') || message.includes('maximum context') || message.includes('too long')) {
-        return contextLengthError(message, error);
+        return contextLengthError(message, error, rawRequest);
       }
-      
+
       if (message.includes('500') || message.includes('502') || message.includes('503') || message.includes('server_error')) {
-        return serverError(message, undefined, error);
+        return serverError(message, undefined, error, rawRequest);
       }
-      
+
       if (error.name === 'AbortError') {
-        return abortError();
+        return abortError(undefined, rawRequest);
       }
-      
+
       if (message.includes('network') || message.includes('fetch') || message.includes('ECONNREFUSED')) {
-        return networkError(message, error);
+        return networkError(message, error, rawRequest);
       }
     }
-    
+
     return new MembraneError({
       type: 'unknown',
       message: error instanceof Error ? error.message : String(error),
       retryable: false,
       rawError: error,
+      rawRequest,
     });
   }
 }