@truefoundry/ai-gateway-sdk 0.0.0-stage → 0.0.1

package/dist/providers/anthropic/chatComplete.js

@@ -0,0 +1,1395 @@
+/**
+ * ================================
+ * Inherited upstream file
+ * But needs few custom changes for TFY
+ * 1. Remove the !! from the if condition for linting
+ * 2. Add additionalProperties to the AnthropicTool interface and export it
+ * 3. Remove stream_options from the request body
+ * 4. Handle tool_choice in the request body
+ * ================================
+ */
+import { ValidationError } from '../../errors.js';
+import { ANTHROPIC, ANTHROPIC_SERVER_TOOL_CALL_ID_PREFIX, fileExtensionMimeTypeMap, isClaudeAdaptiveThinkingModel, } from '../../globals.js';
+import { SYSTEM_MESSAGE_ROLES } from '../../types/requestBody.js';
+import { calculateBudgetTokens } from '../../utils/reasoningUtils.js';
+import { generateInvalidProviderResponseError, transformFinishReason } from '../utils.js';
+import { decodeUrlIfEncoded, parseFileData } from '../utils/fileUtils.js';
+import { ANTHROPIC_MAX_TOKENS_FALLBACK, AnthropicErrorResponseTransform, hashUserId, parseToolArgumentsForAnthropic, } from './utils.js';
+const transformAssistantMessage = (msg, isCursor = false) => {
+    const m = msg;
+    const transformedContent = [];
+    const inputContent = msg.content_blocks ?? msg.content;
+    const toolCalls = msg.tool_calls ?? [];
+    // Anthropic requires thinking blocks to appear FIRST in the content array, before any
+    // text or tool_use blocks. Prefer the explicit thinking_blocks field (which carries
+    // per-block signatures needed for multi-turn) over extracting from content_blocks.
+    // We only use thinking_blocks if content_blocks does NOT already contain thinking items
+    // to avoid double-adding when the client echoes back raw content_blocks.
+    const hasThinkingInContentBlocks = Array.isArray(inputContent) &&
+        inputContent.some((item) => {
+            const t = item.type;
+            return t === 'thinking' || t === 'redacted_thinking';
+        });
+    const incomingThinkingBlocks = m.thinking_blocks ?? [];
+    // Filter to only blocks that can be echoed back (thinking requires a signature for multi-turn).
+    const validThinkingBlocks = incomingThinkingBlocks.filter(block => {
+        if (block.type === 'thinking')
+            return !!(block.thinking && block.signature);
+        if (block.type === 'redacted_thinking')
+            return !!block.data;
+        return false;
+    });
+    // Detect server-side tool calls (web search, code execution, etc.) — IDs start with "srvtoolu_".
+    const serverToolCalls = toolCalls.filter((tc) => tc.id?.startsWith(ANTHROPIC_SERVER_TOOL_CALL_ID_PREFIX));
+    const hasServerToolCalls = serverToolCalls.length > 0;
+    if (!hasThinkingInContentBlocks && hasServerToolCalls && validThinkingBlocks.length > 0) {
+        // ── INTERLEAVED MODE ──────────────────────────────────────────────────────
+        // When Anthropic's server-side tools (web search, code execution, etc.) are present
+        // alongside extended thinking, the original Anthropic response interleaves them:
+        //   [thinking_1, server_tool_use_1, result_1, thinking_2, text, ...]
+        // Anthropic's API validates thinking-block signatures against their *position*, so we
+        // must preserve this exact interleaved order when echoing the message back.
+        //
+        // This path is taken when the client uses the structured fields (thinking_blocks,
+        // tool_calls, provider_specific_fields) rather than echoing raw content_blocks.
+        // When raw content_blocks are echoed (hasThinkingInContentBlocks=true), the sequential
+        // path below handles the ordering by iterating content_blocks directly.
+        const regularToolCalls = toolCalls.filter((tc) => !tc.id?.startsWith(ANTHROPIC_SERVER_TOOL_CALL_ID_PREFIX));
+        // Retrieve tool results from the previous turn. Both the top-level fields and the
+        // nested provider_specific_fields location are checked so either client convention works.
+        const webSearchResults = m.provider_specific_fields?.web_search_results ?? m.web_search_results ?? [];
+        const otherToolResults = m.provider_specific_fields?.tool_results ?? m.tool_results ?? [];
+        const allToolResults = [...webSearchResults, ...otherToolResults];
+        // Build one group per server tool call: [server_tool_use_block, matching_result_block?]
+        const serverToolGroups = serverToolCalls.map((tc) => {
+            const group = [
+                {
+                    type: 'server_tool_use',
+                    id: tc.id,
+                    name: tc.function?.name,
+                    input: parseToolArgumentsForAnthropic(tc.function?.arguments),
+                },
+            ];
+            const result = allToolResults.find((r) => r.tool_use_id === tc.id);
+            if (result)
+                group.push(result);
+            return group;
+        });
+        // Interleave: thinking[i] → server_tool_group[i] → thinking[i+1] → server_tool_group[i+1] → ...
+        // Any surplus thinking blocks precede the text; any surplus groups are appended at the end.
+        const numTb = validThinkingBlocks.length;
+        const numGrp = serverToolGroups.length;
+        let tbIdx = 0;
+        let grpIdx = 0;
+        while (tbIdx < numTb || grpIdx < numGrp) {
+            if (tbIdx < numTb && grpIdx < numGrp) {
+                transformedContent.push(validThinkingBlocks[tbIdx++]);
+                serverToolGroups[grpIdx++].forEach(block => transformedContent.push(block));
+            }
+            else if (tbIdx < numTb) {
+                transformedContent.push(validThinkingBlocks[tbIdx++]);
+            }
+            else {
+                serverToolGroups[grpIdx++].forEach(block => transformedContent.push(block));
+            }
+        }
+        // Text content comes after the interleaved blocks.
+        // Handle all three shapes: string inputContent, array inputContent (extract text blocks),
+        // and string msg.content as a last fallback.
+        if (typeof inputContent === 'string') {
+            transformedContent.push({ type: 'text', text: inputContent });
+        }
+        else if (Array.isArray(inputContent)) {
+            inputContent.forEach((item) => {
+                if (item.type === 'text' && item.text) {
+                    transformedContent.push({ type: 'text', text: item.text });
+                }
+            });
+        }
+        else if (typeof msg.content === 'string' && msg.content) {
+            transformedContent.push({ type: 'text', text: msg.content });
+        }
+        // Regular (non-server) tool calls come last.
+        regularToolCalls.forEach((toolCall) => {
+            transformedContent.push({
+                type: 'tool_use',
+                id: toolCall.id ?? '',
+                name: toolCall.function?.name,
+                input: parseToolArgumentsForAnthropic(toolCall.function?.arguments),
+            });
+        });
+    }
+    else {
+        // ── SEQUENTIAL MODE ───────────────────────────────────────────────────────
+        // Used when:
+        //  a) content_blocks (with inline thinking) is echoed back unchanged — we just stream it
+        //     through and the ordering is already correct; OR
+        //  b) no server tool calls are present — standard thinking-before-content layout.
+        // Build the set of server_tool_use IDs already embedded in content_blocks so we can
+        // skip them in the tool_calls loop below and avoid duplicates.
+        const serverToolUseIdsInContent = new Set(Array.isArray(inputContent)
+            ? inputContent
+                .filter((item) => item.type === 'server_tool_use' &&
+                item.id)
+                .map((item) => item.id)
+            : []);
+        if (!hasThinkingInContentBlocks && validThinkingBlocks.length > 0) {
+            validThinkingBlocks.forEach(block => {
+                if (block.type === 'thinking') {
+                    transformedContent.push({ type: 'thinking', thinking: block.thinking, signature: block.signature });
+                }
+                else if (block.type === 'redacted_thinking') {
+                    transformedContent.push({ type: 'redacted_thinking', data: block.data });
+                }
+            });
+        }
+        if (inputContent && typeof inputContent === 'string') {
+            transformedContent.push({ type: 'text', text: inputContent });
+        }
+        else if (inputContent && typeof inputContent === 'object' && inputContent.length) {
+            inputContent.forEach(item => {
+                // Skip tool_use — it is re-added from msg.tool_calls below.
+                // server_tool_use blocks whose IDs are tracked in serverToolUseIdsInContent are also
+                // kept here (they are NOT skipped); the tool_calls loop below will skip them.
+                if (item.type !== 'tool_use') {
+                    transformedContent.push(item);
+                }
+                else if (isCursor && toolCalls.length === 0) {
+                    // Cursor replays a previous call inline in the content, e.g.
+                    //   { role: 'assistant', content: [{ type: 'tool_use', id: 'x', name: 'Read', ... }] }
+                    // with no `tool_calls`. The skip above expects the loop below to re-add it, so with
+                    // none the only copy was dropped and the message went up without the call.
+                    transformedContent.push(item);
+                }
+            });
+        }
+        if (toolCalls.length > 0) {
+            toolCalls.forEach((toolCall) => {
+                const tcId = toolCall.id ?? '';
+                // Skip server tool calls already present in content_blocks to avoid duplication.
+                if (serverToolUseIdsInContent.has(tcId))
+                    return;
+                // Use the correct block type based on whether this is a server tool call.
+                const blockType = tcId.startsWith(ANTHROPIC_SERVER_TOOL_CALL_ID_PREFIX) ? 'server_tool_use' : 'tool_use';
+                transformedContent.push({
+                    type: blockType,
+                    id: tcId,
+                    name: toolCall.function?.name,
+                    input: parseToolArgumentsForAnthropic(toolCall.function?.arguments),
+                });
+            });
+        }
+    }
+    return {
+        role: msg.role,
+        content: transformedContent,
+    };
+};
+const transformToolMessage = (msg) => {
+    const tool_use_id = msg.tool_call_id ?? '';
+    return {
+        role: 'user',
+        content: [
+            {
+                type: 'tool_result',
+                tool_use_id,
+                content: msg.content,
+            },
+        ],
+    };
+};
+const transformAndAppendImageContentItem = (item, transformedMessage) => {
+    if (!item?.image_url?.url || typeof transformedMessage.content === 'string')
+        return;
+    const url = item.image_url.url;
+    const isBase64EncodedImage = url.startsWith('data:');
+    if (!isBase64EncodedImage) {
+        transformedMessage.content.push({
+            type: 'image',
+            source: {
+                type: 'url',
+                url,
+            },
+        });
+    }
+    else {
+        const parts = url.split(';');
+        if (parts.length === 2) {
+            const base64ImageParts = parts[1].split(',');
+            const base64Image = base64ImageParts[1];
+            const mediaTypeParts = parts[0].split(':');
+            if (mediaTypeParts.length === 2 && base64Image) {
+                const mediaType = mediaTypeParts[1];
+                transformedMessage.content.push({
+                    type: mediaType === fileExtensionMimeTypeMap.pdf ? 'document' : 'image',
+                    source: {
+                        type: 'base64',
+                        media_type: mediaType,
+                        data: base64Image,
+                    },
+                    ...(item.cache_control && {
+                        cache_control: {
+                            type: 'ephemeral',
+                            ...(item.cache_control.ttl && { ttl: item.cache_control.ttl }),
+                        },
+                    }),
+                });
+            }
+        }
+    }
+};
+/**
+ * Determine Anthropic content block type from format or file_id
+ */
+const determineAnthropicContentBlockType = (mimeType, fileId) => {
+    if (mimeType) {
+        if (mimeType === 'application/pdf' || mimeType === 'text/plain') {
+            return 'document';
+        }
+        if (['image/jpeg', 'image/png', 'image/gif', 'image/webp'].includes(mimeType)) {
+            return 'image';
+        }
+        return 'container_upload';
+    }
+    const decodedFileId = decodeUrlIfEncoded(fileId);
+    return decodedFileId.startsWith('http://') || decodedFileId.startsWith('https://')
+        ? 'document_url'
+        : 'container_upload';
+};
+/**
+ * Create Anthropic content item from file_id based on content block type
+ */
+const createAnthropicFileIdContentItem = (fileId, contentBlockType) => {
+    switch (contentBlockType) {
+        case 'document':
+            return {
+                type: 'document',
+                source: { type: 'file', file_id: fileId },
+            };
+        case 'document_url':
+            return {
+                type: 'document',
+                source: { type: 'url', url: fileId },
+            };
+        case 'image':
+            return {
+                type: 'image',
+                source: { type: 'file', file_id: fileId },
+            };
+        case 'container_upload':
+            return {
+                type: 'container_upload',
+                file_id: fileId,
+            };
+    }
+};
+const transformAndAppendFileContentItem = (item, transformedMessage) => {
+    if (!item.file) {
+        return;
+    }
+    const { file_data: fileData, file_id, file_url, mime_type } = item.file;
+    const fileId = file_id || file_url;
+    const mimeType = mime_type;
+    // Process file_data first (takes priority)
+    if (fileData) {
+        const { base64String, mimeType: parsedMimeType } = parseFileData(fileData);
+        // For plain base64 (parsedMimeType is null), mimeType must be provided
+        if (!parsedMimeType && !mimeType) {
+            throw new ValidationError(`Unable to determine mime type for file_data. Please provide file.mime_type explicitly.`);
+        }
+        const finalMimeType = mimeType || parsedMimeType || fileExtensionMimeTypeMap.pdf;
+        const contentType = finalMimeType === fileExtensionMimeTypeMap.txt ? 'text' : 'base64';
+        transformedMessage.content.push({
+            type: 'document',
+            source: {
+                type: contentType,
+                media_type: finalMimeType,
+                data: base64String,
+            },
+            ...(item.cache_control && {
+                cache_control: {
+                    type: 'ephemeral',
+                    ...(item.cache_control.ttl && { ttl: item.cache_control.ttl }),
+                },
+            }),
+        });
+        return;
+    }
+    if (!fileId) {
+        return;
+    }
+    const contentBlockType = determineAnthropicContentBlockType(mimeType, fileId);
+    const contentItem = createAnthropicFileIdContentItem(fileId, contentBlockType);
+    transformedMessage.content.push({
+        ...contentItem,
+        ...(item.cache_control && {
+            cache_control: {
+                type: 'ephemeral',
+                ...(item.cache_control.ttl && { ttl: item.cache_control.ttl }),
+            },
+        }),
+    });
+};
+export const AnthropicChatCompleteConfig = {
+    model: {
+        param: 'model',
+        default: 'claude-2.1',
+        required: true,
+    },
+    messages: [
+        {
+            param: 'messages',
+            required: true,
+            transform: (params, transformInput) => {
+                const messages = [];
+                const isCursor = !!transformInput.callConfig.isCursorEndpoint;
+                // Transform the chat messages into a simple prompt
+                if (params.messages) {
+                    params.messages.forEach((msg) => {
+                        if (SYSTEM_MESSAGE_ROLES.includes(msg.role))
+                            return;
+                        if (msg.role === 'assistant') {
+                            messages.push(transformAssistantMessage(msg, isCursor));
+                        }
+                        else if (msg.role === 'tool') {
+                            // even though anthropic supports images in tool results, openai doesn't support it yet
+                            messages.push(transformToolMessage(msg));
+                        }
+                        else if (msg.content && Array.isArray(msg.content) && msg.content.length) {
+                            const transformedMessage = {
+                                role: msg.role,
+                                content: [],
+                            };
+                            msg.content.forEach(item => {
+                                if (item.type === 'text') {
+                                    const cc = item.cache_control;
+                                    transformedMessage.content.push({
+                                        type: item.type,
+                                        text: item.text ?? '',
+                                        ...(cc && {
+                                            cache_control: {
+                                                type: 'ephemeral',
+                                                ...(cc.ttl && { ttl: cc.ttl }),
+                                            },
+                                        }),
+                                    });
+                                }
+                                else if (item.type === 'image_url') {
+                                    transformAndAppendImageContentItem(item, transformedMessage);
+                                }
+                                else if (item.type === 'file') {
+                                    transformAndAppendFileContentItem(item, transformedMessage);
+                                }
+                                else if (isCursor && item.type === 'tool_result') {
+                                    // Cursor puts a tool result in the user message's content, e.g.
+                                    //   { role: 'user', content: [{ type: 'tool_result', tool_use_id: 'x', ... }] }
+                                    // rather than as a `role: 'tool'` message. Unhandled, it was dropped and the
+                                    // message went up with empty content, which Anthropic 400s. It is already in
+                                    // Anthropic's shape, so it passes straight through.
+                                    transformedMessage.content.push(item);
+                                }
+                            });
+                            messages.push(transformedMessage);
+                        }
+                        else {
+                            messages.push({
+                                role: msg.role,
+                                content: msg.content,
+                            });
+                        }
+                    });
+                }
+                return messages;
+            },
+        },
+        {
+            param: 'system',
+            required: false,
+            transform: (params) => {
+                const systemMessages = [];
+                // Transform the chat messages into a simple prompt
+                if (params.messages) {
+                    params.messages.forEach((msg) => {
+                        if (SYSTEM_MESSAGE_ROLES.includes(msg.role) &&
+                            msg.content &&
+                            Array.isArray(msg.content) &&
+                            msg.content[0]?.text) {
+                            msg.content.forEach(_msg => {
+                                const cc = _msg.cache_control;
+                                systemMessages.push({
+                                    text: _msg.text ?? '',
+                                    type: 'text',
+                                    ...(cc && {
+                                        cache_control: {
+                                            type: 'ephemeral',
+                                            ...(cc.ttl && { ttl: cc.ttl }),
+                                        },
+                                    }),
+                                });
+                            });
+                        }
+                        else if (SYSTEM_MESSAGE_ROLES.includes(msg.role) && typeof msg.content === 'string') {
+                            systemMessages.push({
+                                text: msg.content,
+                                type: 'text',
+                            });
+                        }
+                    });
+                }
+                return systemMessages;
+            },
+        },
+    ],
+    tools: {
+        param: 'tools',
+        required: false,
+        transform: (params, transformInput) => {
+            const tools = [];
+            if (params.tools) {
+                params.tools.forEach(tool => {
+                    if (tool.function) {
+                        // Accepted both at the tool level and nested under `function`, since clients port
+                        // tool-search payloads over from the Anthropic shape either way.
+                        const deferLoading = tool.defer_loading ?? tool.function.defer_loading;
+                        tools.push({
+                            name: tool.function.name,
+                            description: tool.function?.description || '',
+                            input_schema: {
+                                type: tool.function.parameters?.type || 'object',
+                                properties: tool.function.parameters?.properties || {},
+                                required: tool.function.parameters?.required || [],
+                                $defs: tool.function.parameters?.['$defs'] || {},
+                            },
+                            ...(tool.eager_input_streaming != null && {
+                                eager_input_streaming: tool.eager_input_streaming,
+                            }),
+                            ...(deferLoading != null && { defer_loading: deferLoading }),
+                            ...(tool.cache_control && {
+                                cache_control: {
+                                    type: 'ephemeral',
+                                    ...(tool.cache_control.ttl && { ttl: tool.cache_control.ttl }),
+                                },
+                            }),
+                        });
+                    }
+                    else if (transformInput.callConfig.isCursorEndpoint &&
+                        tool.name &&
+                        tool.input_schema) {
+                        // Cursor sends Anthropic-shaped tools in an OpenAI envelope, e.g.
+                        //   { name: 'Read', description: '...', input_schema: { type: 'object', ... } }
+                        // With no `function` and no `type`, both branches above skip it, so the model used to
+                        // get zero tools and narrate calls as text. Copying it across sends them as-is.
+                        const anthropicShaped = tool;
+                        const { cache_control: rawCacheControl, ...passthrough } = anthropicShaped;
+                        tools.push({
+                            ...passthrough,
+                            description: anthropicShaped.description ?? '',
+                            ...(rawCacheControl && {
+                                cache_control: {
+                                    type: 'ephemeral',
+                                    ...(rawCacheControl.ttl && { ttl: rawCacheControl.ttl }),
+                                },
+                            }),
+                        });
+                    }
+                    else if (tool.type) {
+                        // Anthropic-native tool in flat format — pass through directly.
+                        // Covers all non-function Anthropic tools: web_search, bash, text_editor,
+                        // computer use, code_execution, web_fetch, memory, etc.
+                        // The Anthropic API wire format is always flat, e.g.:
+                        //   { type: "web_search_20250305" }
+                        //   { type: "computer_20241022", name: "computer", display_width_px: 1024, display_height_px: 768 }
+                        const nativeTool = tool;
+                        const { cache_control: rawCacheControl, function: _fn, ...passthrough } = nativeTool;
+                        tools.push({
+                            ...passthrough,
+                            ...(rawCacheControl && {
+                                cache_control: {
+                                    type: 'ephemeral',
+                                    ...(rawCacheControl.ttl && { ttl: rawCacheControl.ttl }),
+                                },
+                            }),
+                        });
+                    }
+                });
+            }
+            return tools;
+        },
+    },
+    /**
+     * ================================
+     * NOTE: Handle tool_choice in the request body
+     * ================================
+     */
+    // None is not supported by Anthropic, defaults to auto
+    tool_choice: {
+        param: 'tool_choice',
+        required: false,
+        transform: (params) => {
+            let toolChoiceResult = null;
+            // Handle tool_choice transformation
+            if (params.tool_choice) {
+                if (typeof params.tool_choice === 'string') {
+                    if (params.tool_choice === 'required')
+                        toolChoiceResult = { type: 'any' };
+                    else if (params.tool_choice === 'auto')
+                        toolChoiceResult = { type: 'auto' };
+                    else if (params.tool_choice === 'none')
+                        toolChoiceResult = { type: 'none' };
+                }
+                else if (typeof params.tool_choice === 'object' && params.tool_choice.function?.name) {
+                    toolChoiceResult = { type: 'tool', name: params.tool_choice.function.name };
+                }
+                else if (typeof params.tool_choice === 'object') {
+                    toolChoiceResult = { ...params.tool_choice };
+                }
+            }
+            if (params.parallel_tool_calls === false && toolChoiceResult?.type !== 'none') {
+                if (!toolChoiceResult) {
+                    toolChoiceResult = { type: 'auto', disable_parallel_tool_use: true };
+                }
+                else {
+                    toolChoiceResult = { ...toolChoiceResult, disable_parallel_tool_use: true };
+                }
+            }
+            return toolChoiceResult;
+        },
+    },
+    max_tokens: {
+        param: 'max_tokens',
+        required: true,
+        default: ANTHROPIC_MAX_TOKENS_FALLBACK,
+    },
+    max_completion_tokens: {
+        param: 'max_tokens',
+    },
+    temperature: {
+        param: 'temperature',
+        default: 1,
+        min: 0,
+        max: 1,
+    },
+    top_p: {
+        param: 'top_p',
+        default: -1,
+        min: -1,
+    },
+    top_k: {
+        param: 'top_k',
+        default: -1,
+    },
+    stop: {
+        param: 'stop_sequences',
+    },
+    stream: {
+        param: 'stream',
+        default: false,
+    },
+    user: {
+        param: 'metadata.user_id',
+        transform: (params) => hashUserId(params.user),
+    },
+    thinking: {
+        param: 'thinking',
+        required: false,
+    },
+    reasoning_effort: {
+        param: 'thinking',
+        required: false,
+        transform: (params) => {
+            const effort = params.reasoning_effort;
+            if (!effort) {
+                // reasoning_effort not provided — preserve whatever the `thinking` param already set.
+                return params.thinking;
+            }
+            if (effort === 'none') {
+                return { type: 'disabled' };
+            }
+            // Claude 4-6+ models require {type: 'adaptive'} (no budget_tokens).
+            // Anthropic will reject {type:'enabled', budget_tokens} on these model families.
+            const model = params.model ?? '';
+            if (isClaudeAdaptiveThinkingModel(model)) {
+                const callerDisplay = params.thinking?.display;
+                return { type: 'adaptive', display: callerDisplay ?? 'summarized' };
+            }
+            const maxTokens = params.max_completion_tokens || params.max_tokens || ANTHROPIC_MAX_TOKENS_FALLBACK;
+            // Anthropic enforces a minimum budget_tokens of 1024 for thinking-enabled models.
+            const budgetTokens = Math.max(1024, calculateBudgetTokens(maxTokens, effort));
+            return { type: 'enabled', budget_tokens: budgetTokens };
+        },
+    },
+    /**
+     * ================================
+     * NOTE: Handle parallel_tool_calls in the request body
+     * ================================
+     */
+    parallel_tool_calls: {
+        param: 'tool_choice',
+        required: false,
+        removeFromParams: (params) => params.parallel_tool_calls !== false || !params.tools?.length || 'tool_choice' in params,
+        transform: () => ({ type: 'auto', disable_parallel_tool_use: true }),
+    },
+    /**
+     * ================================
+     * NOTE: Handle response_format in the request body
+     * ================================
+     */
+    response_format: {
+        param: 'response_format',
+        required: false,
+        removeFromParams: true, // Handled by universal response format transform
+    },
+    /**
+     * Native structured output (output_config.format). Set by universal transform when response_format.type === 'json_schema'.
+     */
+    // Required for Claude 4.6+ adaptive thinking — Anthropic ignores `thinking: { type: "adaptive" }` and returns no thinking blocks unless `output_config.effort` is sent alongside it.
+    output_config: {
+        param: 'output_config',
+        required: (params) => !!params.reasoning_effort &&
+            params.reasoning_effort !== 'none' &&
+            isClaudeAdaptiveThinkingModel(params.model ?? ''),
+        default: (params) => {
+            const effort = params.reasoning_effort;
+            const effortMap = {
+                minimal: 'low',
+                low: 'low',
+                medium: 'medium',
+                high: 'high',
+                xhigh: 'xhigh',
+                max: 'max',
+            };
+            return { effort: effortMap[effort] ?? effort };
+        },
+        transform: (params) => {
+            // If explicitly passed by the caller, use it as-is.
+            if (params.output_config)
+                return params.output_config;
+            // For Claude 4.6 models, reasoning_effort must also populate output_config.effort
+            const effort = params.reasoning_effort;
+            const model = params.model ?? '';
+            if (effort && effort !== 'none' && isClaudeAdaptiveThinkingModel(model)) {
+                const effortMap = {
+                    minimal: 'low',
+                    low: 'low',
+                    medium: 'medium',
+                    high: 'high',
+                    xhigh: 'xhigh',
+                    max: 'max',
+                };
+                return { effort: effortMap[effort] ?? effort };
+            }
+            return undefined;
+        },
+    },
+    /**
+     * ================================
+     * NOTE: Remove stream_options from the request body
+     * ================================
+     */
+    stream_options: {
+        param: 'stream_options',
+        removeFromParams: true,
+    },
+};
+// TODO: The token calculation is wrong atm
+export const AnthropicChatCompleteResponseTransform = (response, responseStatus, _responseHeaders, strictOpenAiCompliance) => {
+    if (responseStatus !== 200 && 'error' in response) {
+        return AnthropicErrorResponseTransform(response, ANTHROPIC);
+    }
+    if ('content' in response) {
+        const { input_tokens = 0, output_tokens = 0, cache_creation_input_tokens, cache_read_input_tokens, iterations, } = response?.usage ?? {};
+        const shouldSendCacheUsage = cache_creation_input_tokens || cache_read_input_tokens;
+        let content = '';
+        response.content.forEach(item => {
+            if (item.type === 'text') {
+                content += item.text;
+            }
+        });
+        // Extract tool calls: both regular tool_use and server-side server_tool_use (web search, etc.).
+        // Server tool call IDs start with "srvtoolu_". We expose them as regular tool_calls entries
+        // so clients can reference them in multi-turn via provider_specific_fields.
+        const toolCalls = [];
+        response.content.forEach(item => {
+            if (item.type === 'tool_use' || item.type === 'server_tool_use') {
+                toolCalls.push({
+                    id: item.id,
+                    type: 'function',
+                    function: {
+                        name: item.name,
+                        arguments: JSON.stringify(item.input),
+                    },
+                });
+            }
+        });
+        // Extract structured thinking blocks (with signatures) for multi-turn support.
+        // Each element: { type: 'thinking', thinking: '...', signature: '...' }
+        //            or { type: 'redacted_thinking', data: '...' }
+        const thinking_blocks = response.content.reduce((acc, item) => {
+            if (item.type === 'thinking') {
+                acc.push({ type: 'thinking', thinking: item.thinking, ...(item.signature && { signature: item.signature }) });
+            }
+            else if (item.type === 'redacted_thinking') {
+                acc.push({ type: 'redacted_thinking', data: item.data });
+            }
+            return acc;
+        }, []);
+        // Aggregate reasoning text for the convenience reasoning_content field (backward compat)
+        const reasoning_content = thinking_blocks
+            .filter((b) => b.type === 'thinking')
+            .map(b => b.thinking)
+            .join('');
+        // Extract server-side tool results for multi-turn reconstruction.
+        // Clients receive these as top-level fields on the message (web_search_results, tool_results)
+        // and should echo them back the same way on the next turn; transformAssistantMessage reads
+        // from both the top-level and provider_specific_fields.
+        // tool_search_tool_result is Anthropic-internal metadata and is silently skipped.
+        const web_search_results = [];
+        const tool_results = [];
+        response.content.forEach(item => {
+            if (item.type === 'web_search_tool_result' || item.type === 'web_fetch_tool_result') {
+                web_search_results.push(item);
+            }
+            else if (item.type === 'bash_code_execution_tool_result' ||
+                item.type === 'text_editor_code_execution_tool_result') {
+                tool_results.push(item);
+            }
+        });
+        return {
+            id: response.id,
+            object: 'chat.completion',
+            created: Math.floor(Date.now() / 1000),
+            model: response.model,
+            provider: ANTHROPIC,
+            choices: [
+                {
+                    message: {
+                        role: 'assistant',
+                        content,
+                        tool_calls: toolCalls.length ? toolCalls : undefined,
+                        ...(reasoning_content && { reasoning_content }),
+                        // thinking_blocks carries per-block signatures required for multi-turn conversations
+                        ...(thinking_blocks.length > 0 && { thinking_blocks }),
+                        // Server-side tool results for interleaved-mode multi-turn reconstruction.
+                        // Clients should echo these back in provider_specific_fields of the assistant message.
+                        ...(web_search_results.length > 0 && { web_search_results }),
+                        ...(tool_results.length > 0 && { tool_results }),
+                    },
+                    index: 0,
+                    logprobs: null,
+                    finish_reason: transformFinishReason(response.stop_reason, strictOpenAiCompliance),
+                },
+            ],
+            usage: {
+                prompt_tokens: input_tokens + (cache_read_input_tokens ?? 0) + (cache_creation_input_tokens ?? 0),
+                completion_tokens: output_tokens,
+                total_tokens: input_tokens + output_tokens + (cache_read_input_tokens ?? 0) + (cache_creation_input_tokens ?? 0),
+                ...(shouldSendCacheUsage && {
+                    cache_read_input_tokens: cache_read_input_tokens,
+                    cache_creation_input_tokens: cache_creation_input_tokens,
+                }),
+                // Per-attempt billing record; top-level counts cover only the served attempt.
+                ...(iterations?.length && { iterations }),
+            },
+        };
+    }
+    return generateInvalidProviderResponseError(response, ANTHROPIC);
+};
+export const AnthropicChatCompleteStreamChunkTransform = (responseChunk, fallbackId, streamState, strictOpenAiCompliance) => {
+    let chunk = responseChunk.trim();
+    if (chunk.startsWith('event: ping')) {
+        return;
+    }
+    if (chunk.startsWith('event: message_stop')) {
+        return 'data: [DONE]\n\n';
+    }
+    chunk = chunk.replace(/^event: content_block_stop[\r\n]*/, '');
+    chunk = chunk.replace(/^event: content_block_delta[\r\n]*/, '');
+    chunk = chunk.replace(/^event: content_block_start[\r\n]*/, '');
+    chunk = chunk.replace(/^event: message_delta[\r\n]*/, '');
+    chunk = chunk.replace(/^event: message_start[\r\n]*/, '');
+    chunk = chunk.replace(/^event: error[\r\n]*/, '');
+    chunk = chunk.replace(/^data: /, '');
+    chunk = chunk.trim();
+    const parsedChunk = JSON.parse(chunk);
+    if (parsedChunk.type === 'error' && parsedChunk.error) {
+        return (`data: ${JSON.stringify({
+            id: fallbackId,
+            object: 'chat.completion.chunk',
+            created: Math.floor(Date.now() / 1000),
+            model: '',
+            provider: ANTHROPIC,
+            choices: [
+                {
+                    finish_reason: parsedChunk.error.type,
+                    delta: {
+                        content: '',
+                    },
+                },
+            ],
+        })}` +
+            '\n\n' +
+            'data: [DONE]\n\n');
+    }
+    const shouldSendCacheUsage = parsedChunk.message?.usage?.cache_read_input_tokens || parsedChunk.message?.usage?.cache_creation_input_tokens;
+    if (parsedChunk.type === 'message_start' && parsedChunk.message?.usage) {
+        streamState.model = parsedChunk?.message?.model ?? '';
+        streamState.usage = {
+            prompt_tokens: parsedChunk.message?.usage?.input_tokens,
+            ...(shouldSendCacheUsage && {
+                cache_read_input_tokens: parsedChunk.message?.usage?.cache_read_input_tokens,
+                cache_creation_input_tokens: parsedChunk.message?.usage?.cache_creation_input_tokens,
+            }),
+        };
+        // Kept off the wire: billing reads it from the stream state once the stream ends.
+        streamState.promptTokensWithCache =
+            (parsedChunk.message?.usage?.input_tokens ?? 0) +
+                (parsedChunk.message?.usage?.cache_read_input_tokens ?? 0) +
+                (parsedChunk.message?.usage?.cache_creation_input_tokens ?? 0);
+        return (`data: ${JSON.stringify({
+            id: fallbackId,
+            object: 'chat.completion.chunk',
+            created: Math.floor(Date.now() / 1000),
+            model: streamState.model,
+            provider: ANTHROPIC,
+            choices: [
+                {
+                    delta: {
+                        /*
+                        ================================
+                        NOTE: Keep the message role from the response
+                        ================================
+                        */
+                        role: parsedChunk.message?.role,
+                        content: '',
+                    },
+                    index: 0,
+                    logprobs: null,
+                    finish_reason: null,
+                },
+            ],
+        })}` + '\n\n');
+    }
+    if (parsedChunk.type === 'message_delta' && parsedChunk.usage) {
+        // streamState.usage.prompt_tokens = raw input_tokens (set at message_start, without cache).
+        // Compute the fully-adjusted prompt_tokens so total_tokens stays consistent with it.
+        const adjustedPromptTokens = (streamState?.usage?.prompt_tokens ?? 0) +
+            (streamState?.usage?.cache_read_input_tokens ?? 0) +
+            (streamState?.usage?.cache_creation_input_tokens ?? 0);
+        const totalTokens = adjustedPromptTokens + (parsedChunk.usage.output_tokens ?? 0);
+        // message_delta: emit finish_reason, usage, and the assembled thinking_blocks.
+        // web_search_results / tool_results are emitted immediately on their content_block_start
+        // chunk so they arrive as early as possible during the stream.
+        return (`data: ${JSON.stringify({
+            id: fallbackId,
+            object: 'chat.completion.chunk',
+            created: Math.floor(Date.now() / 1000),
+            model: streamState.model,
+            provider: ANTHROPIC,
+            choices: [
+                {
+                    index: 0,
+                    delta: {
+                        // Complete assembled thinking_blocks (text + signature) so clients can echo
+                        // them back for multi-turn without needing to reconstruct from partial deltas.
+                        ...(streamState.thinkingBlocks?.length && { thinking_blocks: streamState.thinkingBlocks }),
+                    },
+                    finish_reason: transformFinishReason(parsedChunk.delta?.stop_reason, strictOpenAiCompliance),
+                },
+            ],
+            usage: {
+                // spread streamState.usage first (has prompt_tokens = raw input_tokens from message_start)
+                ...streamState.usage,
+                completion_tokens: parsedChunk.usage?.output_tokens ?? 0,
+                total_tokens: totalTokens,
+                // Override prompt_tokens to include cache tokens (streamState.usage.prompt_tokens
+                // only stores the raw input_tokens; parsedChunk.usage.input_tokens is always
+                // undefined in message_delta events — only output_tokens is present there).
+                prompt_tokens: (streamState?.usage?.prompt_tokens ?? 0) +
+                    (streamState?.usage?.cache_read_input_tokens ?? 0) +
+                    (streamState?.usage?.cache_creation_input_tokens ?? 0),
+                // Per-attempt billing record; only the final message_delta carries it.
+                ...(parsedChunk.usage?.iterations?.length && { iterations: parsedChunk.usage.iterations }),
+            },
+        })}` + '\n\n');
+    }
+    const toolCalls = [];
+    // Track the current content block type across chunks.
+    // This guards against web_search_tool_result input_json_delta events being
+    // incorrectly forwarded as tool_calls (those blocks also emit partial_json deltas).
+    if (parsedChunk.type === 'content_block_start') {
+        streamState.currentContentBlockType = parsedChunk.content_block?.type;
+        streamState.currentToolBlockHasArgs = false;
+    }
+    else if (parsedChunk.type === 'content_block_stop') {
+        // Tool block completed with no argument deltas — emit `{}` so the client
+        // receives valid JSON instead of an empty string.
+        if ((streamState.currentContentBlockType === 'tool_use' ||
+            streamState.currentContentBlockType === 'server_tool_use') &&
+            !streamState.currentToolBlockHasArgs) {
+            toolCalls.push({
+                index: streamState.toolIndex,
+                function: { arguments: '{}' },
+            });
+        }
+        streamState.currentContentBlockType = undefined;
+        streamState.currentToolBlockHasArgs = false;
+        // Only emit a chunk if there's a zero-arg tool call to send; all other block stops are silent.
+        if (!toolCalls.length)
+            return;
+    }
+    // server_tool_use blocks (web search, code execution, etc.) are treated the same as tool_use:
+    // they produce a tool_calls entry and accept input_json_delta events. Their IDs start with
+    // "srvtoolu_" so clients/transformAssistantMessage can identify them in subsequent turns.
+    const isToolBlockStart = parsedChunk.type === 'content_block_start' &&
+        (parsedChunk.content_block?.type === 'tool_use' || parsedChunk.content_block?.type === 'server_tool_use');
+    if (isToolBlockStart) {
+        // Increment tool call index for parallel tool calls. The streamState persists across chunks,
+        // so toolIndex tracks the sequential index: undefined → 0 → 1 → 2 → ...
+        // First tool: (undefined ?? -1) + 1 = 0
+        // Second tool: (0 ?? -1) + 1 = 1
+        // Third tool: (1 ?? -1) + 1 = 2
+        // Use nullish coalescing (??) instead of ternary (? : ) because 0 is a valid tool index.
+        // A ternary would treat 0 as falsy and reset to 0, causing all tool calls after the first
+        // to incorrectly get index 0. Nullish coalescing only treats null/undefined as missing.
+        streamState.toolIndex = (streamState.toolIndex ?? -1) + 1;
+    }
+    // Only emit tool_calls for partial_json deltas when inside a tool_use or server_tool_use block.
+    // web_search_tool_result blocks also emit input_json_delta and must not become tool_calls.
+    const isToolBlockDelta = parsedChunk.type === 'content_block_delta' &&
+        parsedChunk.delta?.partial_json != undefined &&
+        (streamState.currentContentBlockType === 'tool_use' || streamState.currentContentBlockType === 'server_tool_use');
+    if (isToolBlockStart && parsedChunk.content_block) {
+        toolCalls.push({
+            index: streamState.toolIndex,
+            id: parsedChunk.content_block.id,
+            type: 'function',
+            function: {
+                name: parsedChunk.content_block.name,
+                arguments: '',
+            },
+        });
+    }
+    else if (isToolBlockDelta) {
+        streamState.currentToolBlockHasArgs = true;
+        toolCalls.push({
+            index: streamState.toolIndex,
+            function: {
+                arguments: parsedChunk.delta.partial_json ?? '',
+            },
+        });
+    }
+    // Server-side tool results and thinking blocks — accumulated in streamState and
+    // emitted on the chunk where the data first arrives, not deferred to message_delta.
+    let immediateWebSearchResults;
+    let immediateToolResults;
+    if (parsedChunk.type === 'content_block_start' && parsedChunk.content_block) {
+        const cbType = parsedChunk.content_block.type ?? '';
+        if (cbType === 'web_search_tool_result' || cbType === 'web_fetch_tool_result') {
+            if (!streamState.webSearchResults)
+                streamState.webSearchResults = [];
+            const newWebResult = parsedChunk.content_block;
+            streamState.webSearchResults.push(newWebResult);
+            immediateWebSearchResults = [newWebResult];
+        }
+        else if (cbType.endsWith('_tool_result') && cbType !== 'tool_search_tool_result') {
+            if (!streamState.toolResults)
+                streamState.toolResults = [];
+            const newToolResult = parsedChunk.content_block;
+            streamState.toolResults.push(newToolResult);
+            immediateToolResults = [newToolResult];
+        }
+        else if (cbType === 'thinking') {
+            streamState.currentThinkingText = '';
+        }
+        else if (cbType === 'redacted_thinking' && parsedChunk.content_block.data) {
+            if (!streamState.thinkingBlocks)
+                streamState.thinkingBlocks = [];
+            streamState.thinkingBlocks.push({ type: 'redacted_thinking', data: parsedChunk.content_block.data });
+        }
+    }
+    if (parsedChunk.delta?.thinking) {
+        streamState.currentThinkingText = (streamState.currentThinkingText ?? '') + parsedChunk.delta.thinking;
+    }
+    // signature_delta finalises a thinking block — push the complete (text + signature) block.
+    const incomingSignature = parsedChunk.delta?.signature;
+    if (incomingSignature) {
+        if (!streamState.thinkingBlocks)
+            streamState.thinkingBlocks = [];
+        streamState.thinkingBlocks.push({
+            type: 'thinking',
+            thinking: streamState.currentThinkingText ?? '',
+            signature: incomingSignature,
+        });
+        streamState.currentThinkingText = undefined;
+    }
+    // ──────────────────────────────────────────────────────────────────────────
+    const content = parsedChunk.delta?.text;
+    return (`data: ${JSON.stringify({
+        id: fallbackId,
+        object: 'chat.completion.chunk',
+        created: Math.floor(Date.now() / 1000),
+        model: streamState.model,
+        provider: ANTHROPIC,
+        choices: [
+            {
+                delta: {
+                    content,
+                    // Emit reasoning_content for thinking text deltas
+                    ...(parsedChunk.delta?.thinking && {
+                        reasoning_content: parsedChunk.delta.thinking,
+                    }),
+                    // Emit reasoning_signature when the signature_delta arrives
+                    ...(incomingSignature && {
+                        reasoning_signature: incomingSignature,
+                    }),
+                    tool_calls: toolCalls.length ? toolCalls : undefined,
+                    // Emit web_search_results / tool_results on the chunk where they arrive.
+                    ...(immediateWebSearchResults && { web_search_results: immediateWebSearchResults }),
+                    ...(immediateToolResults && { tool_results: immediateToolResults }),
+                },
+                index: 0,
+                logprobs: null,
+                finish_reason: null,
+            },
+        ],
+    })}` + '\n\n');
+};
+export const getAzureAnthropicChatCompleteResponseTransform = (provider) => {
+    const AnthropicChatCompleteResponseTransform = (response, responseStatus, _responseHeaders, strictOpenAiCompliance) => {
+        if (responseStatus !== 200 && 'error' in response) {
+            return AnthropicErrorResponseTransform(response, provider);
+        }
+        if ('content' in response) {
+            const { input_tokens = 0, output_tokens = 0, cache_creation_input_tokens, cache_read_input_tokens, } = response?.usage ?? {};
+            const shouldSendCacheUsage = cache_creation_input_tokens || cache_read_input_tokens;
+            let content = '';
+            response.content.forEach(item => {
+                if (item.type === 'text') {
+                    content += item.text;
+                }
+            });
+            // Extract tool calls: both regular tool_use and server-side server_tool_use (web search, etc.).
+            const toolCalls = [];
+            response.content.forEach(item => {
+                if (item.type === 'tool_use' || item.type === 'server_tool_use') {
+                    toolCalls.push({
+                        id: item.id,
+                        type: 'function',
+                        function: {
+                            name: item.name,
+                            arguments: JSON.stringify(item.input),
+                        },
+                    });
+                }
+            });
+            // Extract structured thinking blocks (with signatures) for multi-turn support.
+            const thinking_blocks = response.content.reduce((acc, item) => {
+                if (item.type === 'thinking') {
+                    acc.push({
+                        type: 'thinking',
+                        thinking: item.thinking,
+                        ...(item.signature && { signature: item.signature }),
+                    });
+                }
+                else if (item.type === 'redacted_thinking') {
+                    acc.push({ type: 'redacted_thinking', data: item.data });
+                }
+                return acc;
+            }, []);
+            // Aggregate reasoning text for the convenience reasoning_content field (backward compat)
+            const reasoning_content = thinking_blocks
+                .filter((b) => b.type === 'thinking')
+                .map(b => b.thinking)
+                .join('');
+            // Extract server-side tool results for multi-turn reconstruction.
+            const web_search_results = [];
+            const tool_results = [];
+            response.content.forEach(item => {
+                if (item.type === 'web_search_tool_result' || item.type === 'web_fetch_tool_result') {
+                    web_search_results.push(item);
+                }
+                else if (item.type === 'bash_code_execution_tool_result' ||
+                    item.type === 'text_editor_code_execution_tool_result') {
+                    tool_results.push(item);
+                }
+            });
+            return {
+                id: response.id,
+                object: 'chat.completion',
+                created: Math.floor(Date.now() / 1000),
+                model: response.model,
+                provider: provider,
+                choices: [
+                    {
+                        message: {
+                            role: 'assistant',
+                            content,
+                            ...(!strictOpenAiCompliance && {
+                                content_blocks: response.content.filter(item => item.type !== 'tool_use'),
+                            }),
+                            tool_calls: toolCalls.length ? toolCalls : undefined,
+                            ...(reasoning_content && { reasoning_content }),
+                            // thinking_blocks carries per-block signatures required for multi-turn conversations
+                            ...(thinking_blocks.length > 0 && { thinking_blocks }),
+                            ...(web_search_results.length > 0 && { web_search_results }),
+                            ...(tool_results.length > 0 && { tool_results }),
+                        },
+                        index: 0,
+                        logprobs: null,
+                        finish_reason: transformFinishReason(response.stop_reason, strictOpenAiCompliance),
+                    },
+                ],
+                usage: {
+                    prompt_tokens: input_tokens + (cache_read_input_tokens ?? 0) + (cache_creation_input_tokens ?? 0),
+                    completion_tokens: output_tokens,
+                    total_tokens: input_tokens + output_tokens + (cache_creation_input_tokens ?? 0) + (cache_read_input_tokens ?? 0),
+                    prompt_tokens_details: {
+                        cached_tokens: cache_read_input_tokens ?? 0,
+                    },
+                    ...(shouldSendCacheUsage && {
+                        cache_read_input_tokens: cache_read_input_tokens,
+                        cache_creation_input_tokens: cache_creation_input_tokens,
+                    }),
+                },
+            };
+        }
+        return generateInvalidProviderResponseError(response, provider);
+    };
+    return AnthropicChatCompleteResponseTransform;
+};
+export const getAzureAnthropicStreamChunkTransform = (provider) => {
+    const AnthropicChatCompleteStreamChunkTransform = (responseChunk, fallbackId, streamState, strictOpenAiCompliance) => {
+        if (streamState.toolIndex == undefined) {
+            streamState.toolIndex = -1;
+        }
+        let chunk = responseChunk.trim();
+        if (chunk.startsWith('event: ping')) {
+            return;
+        }
+        if (chunk.startsWith('event: message_stop')) {
+            return 'data: [DONE]\n\n';
+        }
+        chunk = chunk.replace(/^event: content_block_stop[\r\n]*/, '');
+        chunk = chunk.replace(/^event: content_block_delta[\r\n]*/, '');
+        chunk = chunk.replace(/^event: content_block_start[\r\n]*/, '');
+        chunk = chunk.replace(/^event: message_delta[\r\n]*/, '');
+        chunk = chunk.replace(/^event: message_start[\r\n]*/, '');
+        chunk = chunk.replace(/^event: error[\r\n]*/, '');
+        chunk = chunk.replace(/^data: /, '');
+        chunk = chunk.trim();
+        const parsedChunk = JSON.parse(chunk);
+        if (parsedChunk.type === 'error' && parsedChunk.error) {
+            return (`data: ${JSON.stringify({
+                id: fallbackId,
+                object: 'chat.completion.chunk',
+                created: Math.floor(Date.now() / 1000),
+                model: '',
+                provider: provider,
+                choices: [
+                    {
+                        finish_reason: parsedChunk.error.type,
+                        delta: {
+                            content: '',
+                        },
+                    },
+                ],
+            })}` +
+                '\n\n' +
+                'data: [DONE]\n\n');
+        }
+        const shouldSendCacheUsage = parsedChunk.message?.usage?.cache_read_input_tokens || parsedChunk.message?.usage?.cache_creation_input_tokens;
+        if (parsedChunk.type === 'message_start' && parsedChunk.message?.usage) {
+            streamState.model = parsedChunk?.message?.model ?? '';
+            streamState.usage = {
+                prompt_tokens: (parsedChunk.message?.usage?.input_tokens ?? 0) +
+                    (parsedChunk.message?.usage?.cache_read_input_tokens ?? 0) +
+                    (parsedChunk.message?.usage?.cache_creation_input_tokens ?? 0),
+                ...(shouldSendCacheUsage && {
+                    cache_read_input_tokens: parsedChunk.message?.usage?.cache_read_input_tokens,
+                    cache_creation_input_tokens: parsedChunk.message?.usage?.cache_creation_input_tokens,
+                }),
+            };
+            // Already cache-inclusive on this path. Kept off the wire; billing reads it from the stream state.
+            streamState.promptTokensWithCache = streamState.usage.prompt_tokens;
+            return (`data: ${JSON.stringify({
+                id: fallbackId,
+                object: 'chat.completion.chunk',
+                created: Math.floor(Date.now() / 1000),
+                model: streamState.model,
+                provider: provider,
+                choices: [
+                    {
+                        delta: {
+                            content: '',
+                            role: 'assistant',
+                        },
+                        index: 0,
+                        logprobs: null,
+                        finish_reason: null,
+                    },
+                ],
+            })}` + '\n\n');
+        }
+        // Server-side tool results and thinking blocks — same accumulation and emit pattern as above.
+        let immediateWebSearchResults;
+        let immediateToolResults;
+        if (parsedChunk.type === 'content_block_start' && parsedChunk.content_block) {
+            const cbType = parsedChunk.content_block.type ?? '';
+            if (cbType === 'web_search_tool_result' || cbType === 'web_fetch_tool_result') {
+                if (!streamState.webSearchResults)
+                    streamState.webSearchResults = [];
+                const newWebResult = parsedChunk.content_block;
+                streamState.webSearchResults.push(newWebResult);
+                immediateWebSearchResults = [newWebResult];
+            }
+            else if (cbType.endsWith('_tool_result') && cbType !== 'tool_search_tool_result') {
+                if (!streamState.toolResults)
+                    streamState.toolResults = [];
+                const newToolResult = parsedChunk.content_block;
+                streamState.toolResults.push(newToolResult);
+                immediateToolResults = [newToolResult];
+            }
+            else if (cbType === 'thinking') {
+                streamState.currentThinkingText = '';
+            }
+            else if (cbType === 'redacted_thinking' && parsedChunk.content_block.data) {
+                if (!streamState.thinkingBlocks)
+                    streamState.thinkingBlocks = [];
+                streamState.thinkingBlocks.push({ type: 'redacted_thinking', data: parsedChunk.content_block.data });
+            }
+        }
+        if (parsedChunk.delta?.thinking) {
+            streamState.currentThinkingText = (streamState.currentThinkingText ?? '') + parsedChunk.delta.thinking;
+        }
+        const incomingSignature = parsedChunk.delta?.signature;
+        if (incomingSignature) {
+            if (!streamState.thinkingBlocks)
+                streamState.thinkingBlocks = [];
+            streamState.thinkingBlocks.push({
+                type: 'thinking',
+                thinking: streamState.currentThinkingText ?? '',
+                signature: incomingSignature,
+            });
+            streamState.currentThinkingText = undefined;
+        }
+        // ──────────────────────────────────────────────────────────────────────────
+        // message_delta: emit finish_reason, usage, and accumulated thinking_blocks only.
+        if (parsedChunk.type === 'message_delta' && parsedChunk.usage) {
+            // Azure streamState.usage.prompt_tokens already includes input + cache_read + cache_creation
+            // (set at message_start, lines 1560-1563). Do NOT add cache tokens again here.
+            const totalTokens = (streamState?.usage?.prompt_tokens ?? 0) + (parsedChunk.usage.output_tokens ?? 0);
+            return (`data: ${JSON.stringify({
+                id: fallbackId,
+                object: 'chat.completion.chunk',
+                created: Math.floor(Date.now() / 1000),
+                model: streamState.model,
+                provider: provider,
+                choices: [
+                    {
+                        index: 0,
+                        delta: {
+                            ...(streamState.thinkingBlocks?.length && { thinking_blocks: streamState.thinkingBlocks }),
+                        },
+                        finish_reason: transformFinishReason(parsedChunk.delta?.stop_reason, strictOpenAiCompliance),
+                    },
+                ],
+                usage: {
+                    ...streamState.usage,
+                    completion_tokens: parsedChunk.usage?.output_tokens ?? 0,
+                    total_tokens: totalTokens,
+                    prompt_tokens_details: {
+                        cached_tokens: streamState.usage?.cache_read_input_tokens ?? 0,
+                    },
+                },
+            })}` + '\n\n');
+        }
+        const toolCalls = [];
+        // Track the current content block type — same guard logic as the Anthropic transform above.
+        if (parsedChunk.type === 'content_block_start') {
+            streamState.currentContentBlockType = parsedChunk.content_block?.type;
+            streamState.currentToolBlockHasArgs = false;
+        }
+        else if (parsedChunk.type === 'content_block_stop') {
+            if ((streamState.currentContentBlockType === 'tool_use' ||
+                streamState.currentContentBlockType === 'server_tool_use') &&
+                !streamState.currentToolBlockHasArgs) {
+                toolCalls.push({
+                    index: streamState.toolIndex,
+                    function: { arguments: '{}' },
+                });
+            }
+            streamState.currentContentBlockType = undefined;
+            streamState.currentToolBlockHasArgs = false;
+            // Only emit a chunk if there's a zero-arg tool call to send; all other block stops are silent.
+            if (!toolCalls.length)
+                return;
+        }
+        // server_tool_use blocks are treated the same as tool_use for streaming tool call creation.
+        const isToolBlockStart = parsedChunk.type === 'content_block_start' &&
+            (parsedChunk.content_block?.type === 'tool_use' || parsedChunk.content_block?.type === 'server_tool_use');
+        if (isToolBlockStart) {
+            streamState.toolIndex = streamState.toolIndex + 1;
+        }
+        // Guard: only emit tool_calls for partial_json inside tool_use / server_tool_use blocks.
+        const isToolBlockDelta = parsedChunk.type === 'content_block_delta' &&
+            parsedChunk.delta?.partial_json != undefined &&
+            (streamState.currentContentBlockType === 'tool_use' || streamState.currentContentBlockType === 'server_tool_use');
+        if (isToolBlockStart && parsedChunk.content_block) {
+            toolCalls.push({
+                index: streamState.toolIndex,
+                id: parsedChunk.content_block.id,
+                type: 'function',
+                function: {
+                    name: parsedChunk.content_block.name,
+                    arguments: '',
+                },
+            });
+        }
+        else if (isToolBlockDelta) {
+            streamState.currentToolBlockHasArgs = true;
+            toolCalls.push({
+                index: streamState.toolIndex,
+                function: {
+                    arguments: parsedChunk.delta.partial_json ?? '',
+                },
+            });
+        }
+        const content = parsedChunk.delta?.text;
+        const { type: _omitType, ...deltaFields } = parsedChunk.delta ?? parsedChunk.content_block ?? {};
+        const contentBlockObject = { index: parsedChunk.index, delta: deltaFields };
+        return (`data: ${JSON.stringify({
+            id: fallbackId,
+            object: 'chat.completion.chunk',
+            created: Math.floor(Date.now() / 1000),
+            model: streamState.model,
+            provider: provider,
+            choices: [
+                {
+                    delta: {
+                        content,
+                        // Emit reasoning_content for thinking text deltas
+                        ...(parsedChunk.delta?.thinking && {
+                            reasoning_content: parsedChunk.delta.thinking,
+                        }),
+                        // Emit reasoning_signature when the signature_delta arrives
+                        ...(incomingSignature && {
+                            reasoning_signature: incomingSignature,
+                        }),
+                        tool_calls: toolCalls.length ? toolCalls : undefined,
+                        ...(immediateWebSearchResults && { web_search_results: immediateWebSearchResults }),
+                        ...(immediateToolResults && { tool_results: immediateToolResults }),
+                        ...(!strictOpenAiCompliance &&
+                            !toolCalls.length && {
+                            content_blocks: [contentBlockObject],
+                        }),
+                    },
+                    index: 0,
+                    logprobs: null,
+                    finish_reason: null,
+                },
+            ],
+        })}` + '\n\n');
+    };
+    return AnthropicChatCompleteStreamChunkTransform;
+};
+//# sourceMappingURL=chatComplete.js.map