Feat: Add native Anthropic format adapter

- Implement dedicated 'anthropic' format adapter in lib/fetch-wrapper/formats/anthropic.ts.
- Handle top-level 'system' field injection (supports string and array).
- Handle 'tool_result' content blocks in user messages.
- Update fetch wrapper detection order to prioritize Anthropic over OpenAI-compatible.
- Fixes incompatibility where OpenAI adapter would inject invalid 'system' role messages into Anthropic requests.

Author: Tarquinen

lib/fetch-wrapper/formats/anthropic.ts

@@ -0,0 +1,116 @@
+import type { FormatDescriptor, ToolOutput } from "../types"
+import type { PluginState } from "../../state"
+
+/**
+ * Anthropic Messages API format with top-level `system` array.
+ * Tool calls: `tool_use` blocks in assistant content with `id`
+ * Tool results: `tool_result` blocks in user content with `tool_use_id`
+ */
+export const anthropicFormat: FormatDescriptor = {
+    name: 'anthropic',
+
+    detect(body: any): boolean {
+        // Anthropic has top-level `system` field (can be string or array) AND messages array
+        // This distinguishes it from OpenAI (no top-level system) and Bedrock (has inferenceConfig)
+        return (
+            body.system !== undefined &&
+            Array.isArray(body.messages)
+        )
+    },
+
+    getDataArray(body: any): any[] | undefined {
+        return body.messages
+    },
+
+    injectSystemMessage(body: any, injection: string): boolean {
+        if (!injection) return false
+        
+        // Anthropic system can be:
+        // 1. A string: "You are a helpful assistant"
+        // 2. An array of blocks: [{"type": "text", "text": "...", "cache_control": {...}}]
+        
+        // Convert to array if needed
+        if (typeof body.system === 'string') {
+            body.system = [{ type: 'text', text: body.system }]
+        } else if (!Array.isArray(body.system)) {
+            body.system = []
+        }
+        
+        // Append the injection as a text block
+        body.system.push({ type: 'text', text: injection })
+        return true
+    },
+
+    extractToolOutputs(data: any[], state: PluginState): ToolOutput[] {
+        const outputs: ToolOutput[] = []
+
+        for (const m of data) {
+            // Tool results are in user messages with type='tool_result'
+            if (m.role === 'user' && Array.isArray(m.content)) {
+                for (const block of m.content) {
+                    if (block.type === 'tool_result' && block.tool_use_id) {
+                        const toolUseId = block.tool_use_id.toLowerCase()
+                        const metadata = state.toolParameters.get(toolUseId)
+                        outputs.push({
+                            id: toolUseId,
+                            toolName: metadata?.tool
+                        })
+                    }
+                }
+            }
+        }
+
+        return outputs
+    },
+
+    replaceToolOutput(data: any[], toolId: string, prunedMessage: string, _state: PluginState): boolean {
+        const toolIdLower = toolId.toLowerCase()
+        let replaced = false
+
+        for (let i = 0; i < data.length; i++) {
+            const m = data[i]
+
+            if (m.role === 'user' && Array.isArray(m.content)) {
+                let messageModified = false
+                const newContent = m.content.map((block: any) => {
+                    if (block.type === 'tool_result' && block.tool_use_id?.toLowerCase() === toolIdLower) {
+                        messageModified = true
+                        // Anthropic tool_result content can be string or array of content blocks
+                        // Replace with simple string
+                        return {
+                            ...block,
+                            content: prunedMessage
+                        }
+                    }
+                    return block
+                })
+                if (messageModified) {
+                    data[i] = { ...m, content: newContent }
+                    replaced = true
+                }
+            }
+        }
+
+        return replaced
+    },
+
+    hasToolOutputs(data: any[]): boolean {
+        for (const m of data) {
+            if (m.role === 'user' && Array.isArray(m.content)) {
+                for (const block of m.content) {
+                    if (block.type === 'tool_result') return true
+                }
+            }
+        }
+        return false
+    },
+
+    getLogMetadata(data: any[], replacedCount: number, inputUrl: string): Record<string, any> {
+        return {
+            url: inputUrl,
+            replacedCount,
+            totalMessages: data.length,
+            format: 'anthropic'
+        }
+    }
+}

lib/fetch-wrapper/formats/index.ts

@@ -2,3 +2,4 @@ export { openaiChatFormat } from './openai-chat'
 export { openaiResponsesFormat } from './openai-responses'
 export { geminiFormat } from './gemini'
 export { bedrockFormat } from './bedrock'
+export { anthropicFormat } from './anthropic'

lib/fetch-wrapper/index.ts

@@ -3,7 +3,7 @@ import type { Logger } from "../logger"
 import type { FetchHandlerContext } from "./types"
 import type { ToolTracker } from "./types"
 import type { PluginConfig } from "../config"
-import { openaiChatFormat, openaiResponsesFormat, geminiFormat, bedrockFormat } from "./formats"
+import { openaiChatFormat, openaiResponsesFormat, geminiFormat, bedrockFormat, anthropicFormat } from "./formats"
 import { handleFormat } from "./handler"
 import { runStrategies } from "../core/strategies"
 import { accumulateGCStats } from "./gc-tracker"
@@ -17,7 +17,7 @@ export type { FetchHandlerContext, FetchHandlerResult } from "./types"
  * 
  * Supports five API formats:
  * 1. OpenAI Chat Completions (body.messages with role='tool')
- * 2. Anthropic (body.messages with role='user' containing tool_result)
+ * 2. Anthropic Messages API (body.system + body.messages with tool_result)
  * 3. Google/Gemini (body.contents with functionResponse parts)
  * 4. OpenAI Responses API (body.input with function_call_output items)
  * 5. AWS Bedrock Converse API (body.system + body.messages with toolResult blocks)
@@ -56,8 +56,12 @@ export function installFetchWrapper(
                 const toolIdsBefore = new Set(state.toolParameters.keys())
 
                 // Mutually exclusive format handlers
-                // Note: bedrockFormat must be checked before openaiChatFormat since both have messages[]
-                // but Bedrock has distinguishing system[] array and inferenceConfig
+                // Order matters: More specific formats first to avoid incorrect detection
+                // 1. OpenAI Responses API: has body.input (not body.messages)
+                // 2. Bedrock: has body.system + body.inferenceConfig + body.messages
+                // 3. Anthropic: has body.system + body.messages (no inferenceConfig)
+                // 4. OpenAI Chat: has body.messages (no top-level system)
+                // 5. Gemini: has body.contents
                 if (openaiResponsesFormat.detect(body)) {
                     const result = await handleFormat(body, ctx, inputUrl, openaiResponsesFormat)
                     if (result.modified) {
@@ -70,6 +74,12 @@ export function installFetchWrapper(
                         modified = true
                     }
                 }
+                else if (anthropicFormat.detect(body)) {
+                    const result = await handleFormat(body, ctx, inputUrl, anthropicFormat)
+                    if (result.modified) {
+                        modified = true
+                    }
+                }
                 else if (openaiChatFormat.detect(body)) {
                     const result = await handleFormat(body, ctx, inputUrl, openaiChatFormat)
                     if (result.modified) {