@animalabs/membrane 0.5.69 → 0.5.70

package/src/formatters/openai-responses.ts

@@ -0,0 +1,206 @@
+/**
+ * Formatter for stateless, provider-native OpenAI Responses histories.
+ *
+ * Imported/native items are carried either in message metadata under
+ * `openaiResponsesItems` or on content blocks as `rawItem`. Those items are
+ * emitted verbatim and in order. Normalized messages created after import are
+ * converted to Responses input items without rewriting the native prefix.
+ */
+
+import type {
+  ContentBlock,
+  NormalizedMessage,
+  ToolCall,
+  ToolResult,
+} from '../types/index.js';
+import type {
+  BuildOptions,
+  BuildResult,
+  BlockEvent,
+  ParseResult,
+  PrefillFormatter,
+  StreamEmission,
+  StreamParser,
+} from './types.js';
+
+export const OPENAI_RESPONSES_ITEMS_METADATA_KEY = 'openaiResponsesItems';
+
+class ResponsesPassthroughParser implements StreamParser {
+  private accumulated = '';
+  private blockIndex = 0;
+  private blockStarted = false;
+
+  push(chunk: string): void { this.accumulated += chunk; }
+  processChunk(chunk: string): ParseResult {
+    this.accumulated += chunk;
+    const meta = { type: 'text' as const, visible: true, blockIndex: this.blockIndex };
+    const emissions: StreamEmission[] = [];
+    const blockEvents: BlockEvent[] = [];
+    if (!this.blockStarted) {
+      const event: BlockEvent = { event: 'block_start', index: this.blockIndex, block: { type: 'text' } };
+      emissions.push({ kind: 'blockEvent', event });
+      blockEvents.push(event);
+      this.blockStarted = true;
+    }
+    emissions.push({ kind: 'content', text: chunk, meta });
+    return { emissions, content: [{ text: chunk, meta }], blockEvents };
+  }
+  flush(): ParseResult {
+    const emissions: StreamEmission[] = [];
+    const blockEvents: BlockEvent[] = [];
+    if (this.blockStarted) {
+      const event: BlockEvent = {
+        event: 'block_complete', index: this.blockIndex,
+        block: { type: 'text', content: this.accumulated },
+      };
+      emissions.push({ kind: 'blockEvent', event });
+      blockEvents.push(event);
+      this.blockStarted = false;
+    }
+    return { emissions, content: [], blockEvents };
+  }
+  getAccumulated(): string { return this.accumulated; }
+  reset(): void { this.accumulated = ''; this.blockIndex = 0; this.blockStarted = false; }
+  isInsideBlock(): boolean { return false; }
+  getCurrentBlockType() { return 'text' as const; }
+  getBlockIndex(): number { return this.blockIndex; }
+  incrementBlockIndex(): void { this.blockIndex++; }
+  getDepths() { return { functionCalls: 0, functionResults: 0, thinking: 0 }; }
+  resetForNewIteration(): void {}
+}
+
+type NativeItem = { type?: string; id?: string; [key: string]: unknown };
+
+export class OpenAIResponsesFormatter implements PrefillFormatter {
+  readonly name = 'openai-responses';
+  readonly usesPrefill = false;
+
+  buildMessages(messages: NormalizedMessage[], options: BuildOptions): BuildResult {
+    const items: NativeItem[] = [];
+    let hasNativeHistory = false;
+
+    for (const message of messages) {
+      const nativeItems = message.metadata?.[OPENAI_RESPONSES_ITEMS_METADATA_KEY];
+      if (Array.isArray(nativeItems)) {
+        items.push(...nativeItems as NativeItem[]);
+        hasNativeHistory = true;
+        continue;
+      }
+
+      const seenRawItems = new Set<string>();
+      let pendingParts: ContentBlock[] = [];
+      const flushPending = () => {
+        if (pendingParts.length === 0) return;
+        items.push(...this.convertBlocks(message, pendingParts, options.assistantParticipant));
+        pendingParts = [];
+      };
+
+      for (const block of message.content) {
+        const rawItem = (block as unknown as { rawItem?: NativeItem }).rawItem;
+        if (!rawItem || typeof rawItem !== 'object') {
+          pendingParts.push(block);
+          continue;
+        }
+
+        flushPending();
+        hasNativeHistory = true;
+        const key = typeof rawItem.id === 'string'
+          ? `${rawItem.type ?? ''}:${rawItem.id}`
+          : JSON.stringify(rawItem);
+        if (!seenRawItems.has(key)) {
+          items.push(rawItem);
+          seenRawItems.add(key);
+        }
+      }
+      flushPending();
+    }
+
+    return {
+      // BuildResult's historical type says chat envelopes, but Membrane's
+      // provider boundary deliberately accepts unknown provider-native items.
+      messages: items as unknown as BuildResult['messages'],
+      // An imported rollout already contains its developer/system items.
+      // Re-injecting the recipe prompt would alter the stable prefix.
+      systemContent: hasNativeHistory ? undefined : options.systemPrompt,
+      stopSequences: options.additionalStopSequences ?? [],
+      nativeTools: options.tools?.map(tool => ({
+        type: 'function',
+        name: tool.name,
+        description: tool.description,
+        parameters: tool.inputSchema,
+      })),
+      ready: true,
+    };
+  }
+
+  private convertBlocks(
+    message: NormalizedMessage,
+    blocks: ContentBlock[],
+    assistantParticipant: string,
+  ): NativeItem[] {
+    const isAssistant = message.participant === assistantParticipant;
+    const out: NativeItem[] = [];
+    let messageParts: unknown[] = [];
+
+    const flushMessage = () => {
+      if (messageParts.length === 0) return;
+      out.push({
+        type: 'message',
+        role: isAssistant ? 'assistant' : 'user',
+        content: messageParts,
+      });
+      messageParts = [];
+    };
+
+    for (const block of blocks) {
+      if (block.type === 'text') {
+        messageParts.push({
+          type: isAssistant ? 'output_text' : 'input_text',
+          text: block.text,
+        });
+      } else if (block.type === 'image' && !isAssistant) {
+        const source = block.source;
+        messageParts.push(source.type === 'url'
+          ? { type: 'input_image', image_url: source.url }
+          : { type: 'input_image', image_url: `data:${source.mediaType};base64,${source.data}` });
+      } else if (block.type === 'tool_use') {
+        flushMessage();
+        out.push({
+          type: 'function_call',
+          call_id: block.id,
+          name: block.name,
+          arguments: JSON.stringify(block.input ?? {}),
+        });
+      } else if (block.type === 'tool_result') {
+        flushMessage();
+        out.push({
+          type: 'function_call_output',
+          call_id: block.toolUseId,
+          output: typeof block.content === 'string'
+            ? block.content
+            : JSON.stringify(block.content),
+        });
+      } else if (block.type === 'redacted_thinking') {
+        flushMessage();
+        out.push({ type: 'reasoning', encrypted_content: block.data });
+      }
+    }
+    flushMessage();
+    return out;
+  }
+
+  formatToolResults(results: ToolResult[]): string {
+    return JSON.stringify(results.map(result => ({
+      type: 'function_call_output',
+      call_id: result.toolUseId,
+      output: result.content,
+    })));
+  }
+
+  createStreamParser(): StreamParser { return new ResponsesPassthroughParser(); }
+  parseToolCalls(_content: string): ToolCall[] { return []; }
+  hasToolUse(_content: string): boolean { return false; }
+  parseContentBlocks(content: string): ContentBlock[] {
+    return content ? [{ type: 'text', text: content }] : [];
+  }
+}

package/src/membrane.ts

@@ -236,7 +236,7 @@ export class Membrane {
     // Auto mode: choose based on formatter
     // NativeFormatter → native tools via API
     // AnthropicXmlFormatter (default) → XML tools in prefill
-    if (this.formatter.name === 'native') {
+    if (this.formatter.name === 'native' || this.formatter.name === 'openai-responses') {
       return 'native';
     }
 
@@ -986,6 +986,14 @@ export class Membrane {
     request: NormalizedRequest,
     messages: typeof request.messages
   ): any {
+    // Provider-native formatters own their complete input-item shape. The
+    // legacy implementation below is intentionally Anthropic-specific; using
+    // it for Responses would normalize away item IDs, encrypted reasoning,
+    // assistant phases, and compaction items.
+    if (this.formatter.name === 'openai-responses') {
+      return this.transformRequest({ ...request, messages }, this.formatter).providerRequest;
+    }
+
     // Convert messages to provider format
     const providerMessages: any[] = [];
     
@@ -1174,20 +1182,25 @@ export class Membrane {
       const blocks: ContentBlock[] = [];
       for (const item of content) {
         if (item.type === 'text') {
-          blocks.push({ type: 'text', text: item.text });
+          blocks.push({
+            type: 'text', text: item.text,
+            ...(item.rawItem ? { rawItem: item.rawItem } : {}),
+          } as ContentBlock);
         } else if (item.type === 'tool_use') {
           blocks.push({
             type: 'tool_use',
             id: item.id,
             name: unsanitizeToolName(item.name),
             input: item.input,
-          });
+            ...(item.rawItem ? { rawItem: item.rawItem } : {}),
+          } as ContentBlock);
         } else if (item.type === 'thinking') {
           blocks.push({
             type: 'thinking',
             thinking: item.thinking ?? '',
             ...(item.signature ? { signature: item.signature } : {}),
-          });
+            ...(item.rawItem ? { rawItem: item.rawItem } : {}),
+          } as ContentBlock);
         } else if (item.type === 'redacted_thinking') {
           // Pass through verbatim — carries the encrypted `data` payload
           blocks.push({ ...item } as ContentBlock);
@@ -1197,6 +1210,12 @@ export class Membrane {
             data: item.data,
             mimeType: item.mimeType,
           });
+        } else if (item.rawItem) {
+          // Opaque Responses items such as encrypted compaction or custom
+          // tool records have no normalized ContentBlock equivalent. Retain a
+          // zero-width carrier so Chronicle and the Responses formatter can
+          // replay the raw item without surfacing synthetic prompt text.
+          blocks.push({ type: 'text', text: '', rawItem: item.rawItem } as ContentBlock);
         }
       }
       return blocks;

package/src/providers/anthropic.ts

@@ -186,6 +186,11 @@ export class AnthropicAdapter implements ProviderAdapter {
       let outputTokens = 0;
       let cacheCreationTokens: number | undefined;
       let cacheReadTokens: number | undefined;
+      let cacheCreation5mTokens: number | undefined;
+      let cacheCreation1hTokens: number | undefined;
+      let hasCacheCreationBreakdown = false;
+      let inferenceGeo: string | undefined;
+      let serviceTier: string | undefined;
       let stopReason: string = 'end_turn';
       let stopSequence: string | undefined;
       let stopDetails: unknown;
@@ -207,10 +212,22 @@ export class AnthropicAdapter implements ProviderAdapter {
         resetIdleTimer();
         if (event.type === 'message_start') {
           model = event.message.model;
-          const usage = event.message.usage as unknown as Record<string, number>;
-          inputTokens = usage.input_tokens ?? 0;
-          cacheCreationTokens = usage.cache_creation_input_tokens;
-          cacheReadTokens = usage.cache_read_input_tokens;
+          const usage = event.message.usage as unknown as Record<string, unknown>;
+          inputTokens = typeof usage.input_tokens === 'number' ? usage.input_tokens : 0;
+          cacheCreationTokens = typeof usage.cache_creation_input_tokens === 'number'
+            ? usage.cache_creation_input_tokens : undefined;
+          cacheReadTokens = typeof usage.cache_read_input_tokens === 'number'
+            ? usage.cache_read_input_tokens : undefined;
+          const cacheCreation = usage.cache_creation as Record<string, unknown> | undefined;
+          if (cacheCreation) {
+            hasCacheCreationBreakdown = true;
+            cacheCreation5mTokens = typeof cacheCreation.ephemeral_5m_input_tokens === 'number'
+              ? cacheCreation.ephemeral_5m_input_tokens : 0;
+            cacheCreation1hTokens = typeof cacheCreation.ephemeral_1h_input_tokens === 'number'
+              ? cacheCreation.ephemeral_1h_input_tokens : 0;
+          }
+          inferenceGeo = typeof usage.inference_geo === 'string' ? usage.inference_geo : undefined;
+          serviceTier = typeof usage.service_tier === 'string' ? usage.service_tier : undefined;
 
         } else if (event.type === 'content_block_start') {
           currentBlockIndex = event.index;
@@ -324,6 +341,14 @@ export class AnthropicAdapter implements ProviderAdapter {
             output_tokens: outputTokens,
             cache_creation_input_tokens: cacheCreationTokens,
             cache_read_input_tokens: cacheReadTokens,
+            ...(hasCacheCreationBreakdown ? {
+              cache_creation: {
+                ephemeral_5m_input_tokens: cacheCreation5mTokens ?? 0,
+                ephemeral_1h_input_tokens: cacheCreation1hTokens ?? 0,
+              },
+            } : {}),
+            ...(inferenceGeo ? { inference_geo: inferenceGeo } : {}),
+            ...(serviceTier ? { service_tier: serviceTier } : {}),
           },
         },
       };

package/src/providers/index.ts

@@ -60,3 +60,14 @@ export {
   OpenAIResponsesAdapter,
   type OpenAIResponsesAdapterConfig,
 } from './openai-responses.js';
+
+export {
+  OpenAIResponsesAPIAdapter,
+  type OpenAIResponsesAPIAdapterConfig,
+  type OpenAIResponsesAPIContentBlock,
+  type OpenAIResponsesAPIProviderResponse,
+  type OpenAIResponsesAPIRequest,
+  type OpenAIResponsesAPIResponse,
+  type OpenAIResponsesInputItem,
+  type OpenAIResponsesOutputItem,
+} from './openai-responses-api.js';