lossless anthropic conversion

mattapperson · mattapperson · commit 0a63dd570598 · 2025-12-17T14:35:44.000-05:00
diff --git a/src/index.ts b/src/index.ts
@@ -11,3 +11,4 @@ export * from "./sdk/sdk.js";
 // Message format compatibility helpers
 export { fromClaudeMessages, toClaudeMessage } from "./lib/anthropic-compat.js";
 export { fromChatMessages, toChatMessage } from "./lib/chat-compat.js";
+export { extractUnsupportedContent, hasUnsupportedContent, getUnsupportedContentSummary } from "./lib/stream-transformers.js";
diff --git a/src/lib/anthropic-compat.ts b/src/lib/anthropic-compat.ts
@@ -45,15 +45,6 @@ function createFunctionCallOutput(
   };
 }
 
-/**
- * Type guard for Claude text block params
- */
-function isTextBlock(
-  block: models.ClaudeContentBlockParam
-): block is models.ClaudeTextBlockParam {
-  return block.type === "text";
-}
-
 /**
  * Convert Anthropic Claude-style messages to OpenResponses input format.
  *
@@ -86,32 +77,56 @@ export function fromClaudeMessages(
   for (const msg of messages) {
     const { role, content } = msg;
 
-    // Handle string content directly
     if (typeof content === "string") {
       result.push(createEasyInputMessage(role, content));
       continue;
     }
 
-    // Handle array content - extract text and handle tool results
     const textParts: string[] = [];
+
     for (const block of content) {
-      if (isTextBlock(block)) {
-        textParts.push(block.text);
-      } else if (block.type === "tool_result") {
-        // Tool results need special handling - convert to function_call_output
-        const toolContent =
-          typeof block.content === "string"
-            ? block.content
-            : block.content.filter(isTextBlock).map((b: models.ClaudeTextBlockParam) => b.text).join("");
-        result.push(createFunctionCallOutput(block.tool_use_id, toolContent));
+      switch (block.type) {
+        case 'text': {
+          const textBlock = block as models.ClaudeTextBlockParam;
+          textParts.push(textBlock.text);
+          // Note: cache_control is lost in conversion (OpenRouter doesn't support it)
+          break;
+        }
+
+        case 'image': {
+          // Images in input cannot be mapped to OpenRouter easy format
+          // Add text marker to preserve conversation flow
+          textParts.push('[Image content - not supported in OpenRouter format]');
+          break;
+        }
+
+        case 'tool_use': {
+          // Tool use blocks in input are conversation history, skip
+          break;
+        }
+
+        case 'tool_result': {
+          const toolResultBlock = block as models.ClaudeToolResultBlockParam;
+
+          let toolOutput = '';
+          if (typeof toolResultBlock.content === 'string') {
+            toolOutput = toolResultBlock.content;
+          } else {
+            // Extract text, skip images (OpenRouter function_call_output only supports text)
+            toolOutput = toolResultBlock.content
+              .filter((part): part is models.ClaudeTextBlockParam => part.type === 'text')
+              .map(part => part.text)
+              .join('');
+          }
+
+          result.push(createFunctionCallOutput(toolResultBlock.tool_use_id, toolOutput));
+          break;
+        }
       }
-      // Note: tool_use and image blocks in input are typically part of conversation history
-      // They would come from previous assistant responses, we skip them for now
     }
 
-    // If we collected text parts, add them as a message
     if (textParts.length > 0) {
-      result.push(createEasyInputMessage(role, textParts.join("")));
+      result.push(createEasyInputMessage(role, textParts.join('')));
     }
   }
 
diff --git a/src/lib/stream-transformers.ts b/src/lib/stream-transformers.ts
@@ -449,6 +449,69 @@ export function responseHasToolCalls(response: models.OpenResponsesNonStreamingR
   return response.output.some((item) => 'type' in item && item.type === 'function_call');
 }
 
+/**
+ * Convert OpenRouter annotations to Claude citations
+ */
+function mapAnnotationsToCitations(
+  annotations?: Array<models.OpenAIResponsesAnnotation>
+): models.ClaudeTextCitation[] | undefined {
+  if (!annotations || annotations.length === 0) {
+    return undefined;
+  }
+
+  const citations: models.ClaudeTextCitation[] = [];
+
+  for (const annotation of annotations) {
+    if (!('type' in annotation)) {
+      continue;
+    }
+
+    switch (annotation.type) {
+      case 'file_citation': {
+        const fileCite = annotation as models.FileCitation;
+        citations.push({
+          type: 'char_location',
+          cited_text: '',
+          document_index: fileCite.index,
+          document_title: fileCite.filename,
+          file_id: fileCite.fileId,
+          start_char_index: 0,
+          end_char_index: 0,
+        });
+        break;
+      }
+
+      case 'url_citation': {
+        const urlCite = annotation as models.URLCitation;
+        citations.push({
+          type: 'web_search_result_location',
+          cited_text: '',
+          title: urlCite.title,
+          url: urlCite.url,
+          encrypted_index: '',
+        });
+        break;
+      }
+
+      case 'file_path': {
+        const pathCite = annotation as models.FilePath;
+        citations.push({
+          type: 'char_location',
+          cited_text: '',
+          document_index: pathCite.index,
+          document_title: '',
+          file_id: pathCite.fileId,
+          start_char_index: 0,
+          end_char_index: 0,
+        });
+        break;
+      }
+    }
+  }
+
+  return citations.length > 0 ? citations : undefined;
+}
+
 /**
  * Map OpenResponses status to Claude stop reason
  */
@@ -489,59 +552,126 @@ export function convertToClaudeMessage(
   response: models.OpenResponsesNonStreamingResponse,
 ): models.ClaudeMessage {
   const content: models.ClaudeContentBlock[] = [];
+  const unsupportedContent: models.UnsupportedContent[] = [];
 
   for (const item of response.output) {
     if (!('type' in item)) {
       continue;
     }
 
-    // Handle message output items
-    if (item.type === 'message') {
-      const msgItem = item as models.ResponsesOutputMessage;
-      for (const part of msgItem.content) {
-        if ('type' in part && part.type === 'output_text') {
-          const textPart = part as models.ResponseOutputText;
-          content.push({
-            type: 'text',
-            text: textPart.text,
-          });
+    switch (item.type) {
+      case 'message': {
+        const msgItem = item as models.ResponsesOutputMessage;
+        for (const part of msgItem.content) {
+          if (!('type' in part)) {
+            continue;
+          }
+
+          if (part.type === 'output_text') {
+            const textPart = part as models.ResponseOutputText;
+            const citations = mapAnnotationsToCitations(textPart.annotations);
+
+            content.push({
+              type: 'text',
+              text: textPart.text,
+              ...(citations && { citations }),
+            });
+          } else if (part.type === 'refusal') {
+            const refusalPart = part as models.OpenAIResponsesRefusalContent;
+            unsupportedContent.push({
+              original_type: 'refusal',
+              data: { refusal: refusalPart.refusal },
+              reason: 'Claude does not have a native refusal content type',
+            });
+          }
         }
+        break;
       }
-    }
 
-    // Handle function call output items (tool use)
-    if (item.type === 'function_call') {
-      const fnCall = item as models.ResponsesOutputItemFunctionCall;
-      let parsedInput: Record<string, unknown> = {};
+      case 'function_call': {
+        const fnCall = item as models.ResponsesOutputItemFunctionCall;
+        let parsedInput: Record<string, unknown> = {};
 
-      try {
-        parsedInput = JSON.parse(fnCall.arguments);
-      } catch {
-        // If parsing fails, keep as empty object
-        parsedInput = {};
-      }
+        try {
+          parsedInput = JSON.parse(fnCall.arguments);
+        } catch {
+          parsedInput = {};
+        }
 
-      content.push({
-        type: 'tool_use',
-        id: fnCall.callId,
-        name: fnCall.name,
-        input: parsedInput,
-      });
-    }
+        content.push({
+          type: 'tool_use',
+          id: fnCall.callId,
+          name: fnCall.name,
+          input: parsedInput,
+        });
+        break;
+      }
 
-    // Handle reasoning output items (thinking)
-    if (item.type === 'reasoning') {
-      const reasoningItem = item as models.ResponsesOutputItemReasoning;
-      if (reasoningItem.summary && reasoningItem.summary.length > 0) {
-        for (const summaryItem of reasoningItem.summary) {
-          if (summaryItem.type === 'summary_text' && summaryItem.text) {
-            content.push({
-              type: 'thinking',
-              thinking: summaryItem.text,
-              signature: '',
-            });
+      case 'reasoning': {
+        const reasoningItem = item as models.ResponsesOutputItemReasoning;
+
+        if (reasoningItem.summary && reasoningItem.summary.length > 0) {
+          for (const summaryItem of reasoningItem.summary) {
+            if (summaryItem.type === 'summary_text' && summaryItem.text) {
+              content.push({
+                type: 'thinking',
+                thinking: summaryItem.text,
+                signature: '',
+              });
+            }
           }
         }
+
+        if (reasoningItem.encryptedContent) {
+          unsupportedContent.push({
+            original_type: 'reasoning_encrypted',
+            data: {
+              id: reasoningItem.id,
+              encrypted_content: reasoningItem.encryptedContent,
+            },
+            reason: 'Encrypted reasoning content preserved for round-trip',
+          });
+        }
+        break;
+      }
+
+      case 'web_search_call': {
+        const webSearchItem = item as models.ResponsesWebSearchCallOutput;
+        content.push({
+          type: 'server_tool_use',
+          id: webSearchItem.id,
+          name: 'web_search',
+          input: { status: webSearchItem.status },
+        });
+        break;
+      }
+
+      case 'file_search_call': {
+        const fileSearchItem = item as models.ResponsesOutputItemFileSearchCall;
+        content.push({
+          type: 'tool_use',
+          id: fileSearchItem.id,
+          name: 'file_search',
+          input: {
+            queries: fileSearchItem.queries,
+            status: fileSearchItem.status,
+          },
+        });
+        break;
+      }
+
+      case 'image_generation_call': {
+        const imageGenItem = item as models.ResponsesImageGenerationCall;
+        unsupportedContent.push({
+          original_type: 'image_generation_call',
+          data: {
+            id: imageGenItem.id,
+            result: imageGenItem.result,
+            status: imageGenItem.status,
+          },
+          reason: 'Claude does not support image outputs in assistant messages',
+        });
+        break;
       }
     }
   }
@@ -560,5 +690,49 @@ export function convertToClaudeMessage(
       cache_creation_input_tokens: response.usage?.inputTokensDetails?.cachedTokens ?? 0,
       cache_read_input_tokens: 0,
     },
+    ...(unsupportedContent.length > 0 && { unsupported_content: unsupportedContent }),
   };
 }
+
+/**
+ * Extract unsupported content by original type
+ */
+export function extractUnsupportedContent(
+  message: models.ClaudeMessage,
+  originalType: string
+): models.UnsupportedContent[] {
+  if (!message.unsupported_content) {
+    return [];
+  }
+
+  return message.unsupported_content.filter(
+    item => item.original_type === originalType
+  );
+}
+
+/**
+ * Check if message has any unsupported content
+ */
+export function hasUnsupportedContent(
+  message: models.ClaudeMessage
+): boolean {
+  return !!(message.unsupported_content && message.unsupported_content.length > 0);
+}
+
+/**
+ * Get summary of unsupported content types
+ */
+export function getUnsupportedContentSummary(
+  message: models.ClaudeMessage
+): Record<string, number> {
+  if (!message.unsupported_content) {
+    return {};
+  }
+
+  const summary: Record<string, number> = {};
+  for (const item of message.unsupported_content) {
+    summary[item.original_type] = (summary[item.original_type] || 0) + 1;
+  }
+
+  return summary;
+}
diff --git a/src/models/claude-message.ts b/src/models/claude-message.ts
