@fleetagent/pi-ai 0.1.8 → 0.2.0

package/dist/providers/anthropic.js

@@ -4,6 +4,7 @@ import { calculateCost } from "../models.js";
 import { AssistantMessageEventStream } from "../utils/event-stream.js";
 import { headersToRecord } from "../utils/headers.js";
 import { parseJsonWithRepair, parseStreamingJson } from "../utils/json-parse.js";
+import { retryProviderRequest } from "../utils/provider-retry.js";
 import { sanitizeSurrogates } from "../utils/sanitize-unicode.js";
 import { resolveCloudflareBaseUrl } from "./cloudflare.js";
 import { buildCopilotDynamicHeaders, hasCopilotVisionInput } from "./github-copilot-headers.js";
@@ -69,9 +70,6 @@ const fromClaudeCodeName = (name, tools) => {
     }
     return name;
 };
-/**
- * Convert content blocks to Anthropic API format
- */
 function convertContentBlocks(content) {
     // If only text blocks, return as concatenated string for simplicity
     const hasImages = content.some((c) => c.type === "image");
@@ -199,6 +197,17 @@ function consumeLine(text) {
         rest: text.slice(nextIndex),
     };
 }
+function* decodeCompleteSseLines(buffer, state) {
+    let consumed = consumeLine(buffer);
+    while (consumed) {
+        buffer = consumed.rest;
+        const event = decodeSseLine(consumed.line, state);
+        if (event)
+            yield event;
+        consumed = consumeLine(buffer);
+    }
+    return buffer;
+}
 async function* iterateSseMessages(body, signal) {
     const reader = body.getReader();
     const decoder = new TextDecoder();
@@ -214,26 +223,10 @@ async function* iterateSseMessages(body, signal) {
                 break;
             }
             buffer += decoder.decode(value, { stream: true });
-            let consumed = consumeLine(buffer);
-            while (consumed) {
-                buffer = consumed.rest;
-                const event = decodeSseLine(consumed.line, state);
-                if (event) {
-                    yield event;
-                }
-                consumed = consumeLine(buffer);
-            }
+            buffer = (yield* decodeCompleteSseLines(buffer, state));
         }
         buffer += decoder.decode();
-        let consumed = consumeLine(buffer);
-        while (consumed) {
-            buffer = consumed.rest;
-            const event = decodeSseLine(consumed.line, state);
-            if (event) {
-                yield event;
-            }
-            consumed = consumeLine(buffer);
-        }
+        buffer = (yield* decodeCompleteSseLines(buffer, state));
         if (buffer.length > 0) {
             const event = decodeSseLine(buffer, state);
             if (event) {
@@ -249,12 +242,25 @@ async function* iterateSseMessages(body, signal) {
         reader.releaseLock();
     }
 }
+function* decodeAnthropicSseEvent(sse, lifecycle) {
+    try {
+        const event = parseJsonWithRepair(sse.data);
+        if (event.type === "message_start")
+            lifecycle.sawStart = true;
+        else if (event.type === "message_stop")
+            lifecycle.sawEnd = true;
+        yield event;
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`Could not parse Anthropic SSE event ${sse.event}: ${message}; data=${sse.data}; raw=${sse.raw.join("\\n")}`);
+    }
+}
 async function* iterateAnthropicEvents(response, signal) {
     if (!response.body) {
         throw new Error("Attempted to iterate over an Anthropic response with no body");
     }
-    let sawMessageStart = false;
-    let sawMessageEnd = false;
+    const lifecycle = { sawStart: false, sawEnd: false };
     for await (const sse of iterateSseMessages(response.body, signal)) {
         if (sse.event === "error") {
             throw new Error(sse.data);
@@ -262,270 +268,283 @@ async function* iterateAnthropicEvents(response, signal) {
         if (!ANTHROPIC_MESSAGE_EVENTS.has(sse.event ?? "")) {
             continue;
         }
-        try {
-            const event = parseJsonWithRepair(sse.data);
-            if (event.type === "message_start") {
-                sawMessageStart = true;
-            }
-            else if (event.type === "message_stop") {
-                sawMessageEnd = true;
-            }
-            yield event;
+        yield* decodeAnthropicSseEvent(sse, lifecycle);
+    }
+    if (lifecycle.sawStart && !lifecycle.sawEnd) {
+        throw new Error("Anthropic stream ended before message_stop");
+    }
+}
+function createAnthropicStreamState(model, context, stream) {
+    const output = {
+        role: "assistant",
+        content: [],
+        api: model.api,
+        provider: model.provider,
+        model: model.id,
+        usage: {
+            input: 0,
+            output: 0,
+            cacheRead: 0,
+            cacheWrite: 0,
+            totalTokens: 0,
+            cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
+        },
+        stopReason: "stop",
+        timestamp: Date.now(),
+    };
+    return { output, blocks: output.content, stream, model, context, isOAuth: false };
+}
+function handleAnthropicMessageStart(event, state) {
+    state.output.responseId = event.message.id;
+    state.output.usage.input = event.message.usage.input_tokens || 0;
+    state.output.usage.output = event.message.usage.output_tokens || 0;
+    state.output.usage.cacheRead = event.message.usage.cache_read_input_tokens || 0;
+    state.output.usage.cacheWrite = event.message.usage.cache_creation_input_tokens || 0;
+    state.output.usage.totalTokens =
+        state.output.usage.input +
+            state.output.usage.output +
+            state.output.usage.cacheRead +
+            state.output.usage.cacheWrite;
+    calculateCost(state.model, state.output.usage);
+}
+function handleAnthropicContentBlockStart(event, state) {
+    const contentIndex = state.output.content.length;
+    switch (event.content_block.type) {
+        case "text": {
+            const block = {
+                type: "text",
+                text: event.content_block.text ?? "",
+                index: event.index,
+            };
+            state.output.content.push(block);
+            state.stream.push({ type: "text_start", contentIndex, partial: state.output });
+            return;
         }
-        catch (error) {
-            const message = error instanceof Error ? error.message : String(error);
-            throw new Error(`Could not parse Anthropic SSE event ${sse.event}: ${message}; data=${sse.data}; raw=${sse.raw.join("\\n")}`);
+        case "thinking": {
+            const block = {
+                type: "thinking",
+                thinking: event.content_block.thinking ?? "",
+                thinkingSignature: event.content_block.signature ?? "",
+                index: event.index,
+            };
+            state.output.content.push(block);
+            state.stream.push({ type: "thinking_start", contentIndex, partial: state.output });
+            return;
+        }
+        case "redacted_thinking": {
+            const block = {
+                type: "thinking",
+                thinking: "[Reasoning redacted]",
+                thinkingSignature: event.content_block.data,
+                redacted: true,
+                index: event.index,
+            };
+            state.output.content.push(block);
+            state.stream.push({ type: "thinking_start", contentIndex, partial: state.output });
+            return;
+        }
+        case "tool_use": {
+            const block = {
+                type: "toolCall",
+                id: event.content_block.id,
+                name: state.isOAuth
+                    ? fromClaudeCodeName(event.content_block.name, state.context.tools)
+                    : event.content_block.name,
+                arguments: event.content_block.input ?? {},
+                partialJson: "",
+                index: event.index,
+            };
+            state.output.content.push(block);
+            state.stream.push({ type: "toolcall_start", contentIndex, partial: state.output });
         }
     }
-    if (sawMessageStart && !sawMessageEnd) {
-        throw new Error("Anthropic stream ended before message_stop");
+}
+function handleAnthropicContentBlockDelta(event, state) {
+    const index = state.blocks.findIndex((block) => block.index === event.index);
+    const block = state.blocks[index];
+    if (!block)
+        return;
+    switch (event.delta.type) {
+        case "text_delta":
+            if (block.type === "text") {
+                block.text += event.delta.text;
+                state.stream.push({
+                    type: "text_delta",
+                    contentIndex: index,
+                    delta: event.delta.text,
+                    partial: state.output,
+                });
+            }
+            return;
+        case "thinking_delta":
+            if (block.type === "thinking") {
+                block.thinking += event.delta.thinking;
+                state.stream.push({
+                    type: "thinking_delta",
+                    contentIndex: index,
+                    delta: event.delta.thinking,
+                    partial: state.output,
+                });
+            }
+            return;
+        case "input_json_delta":
+            if (block.type === "toolCall") {
+                block.partialJson = (block.partialJson ?? "") + event.delta.partial_json;
+                block.arguments = parseStreamingJson(block.partialJson);
+                state.stream.push({
+                    type: "toolcall_delta",
+                    contentIndex: index,
+                    delta: event.delta.partial_json,
+                    partial: state.output,
+                });
+            }
+            return;
+        case "signature_delta":
+            if (block.type === "thinking") {
+                block.thinkingSignature = (block.thinkingSignature || "") + event.delta.signature;
+            }
+    }
+}
+function handleAnthropicContentBlockStop(event, state) {
+    const index = state.blocks.findIndex((block) => block.index === event.index);
+    const block = state.blocks[index];
+    if (!block)
+        return;
+    delete block.index;
+    switch (block.type) {
+        case "text":
+            state.stream.push({
+                type: "text_end",
+                contentIndex: index,
+                content: block.text,
+                partial: state.output,
+            });
+            return;
+        case "thinking":
+            state.stream.push({
+                type: "thinking_end",
+                contentIndex: index,
+                content: block.thinking,
+                partial: state.output,
+            });
+            return;
+        case "toolCall":
+            block.arguments = parseStreamingJson(block.partialJson ?? "");
+            delete block.partialJson;
+            state.stream.push({
+                type: "toolcall_end",
+                contentIndex: index,
+                toolCall: block,
+                partial: state.output,
+            });
+    }
+}
+function handleAnthropicMessageDelta(event, state) {
+    if (event.delta.stop_reason)
+        state.output.stopReason = mapStopReason(event.delta.stop_reason);
+    if (event.usage.input_tokens != null)
+        state.output.usage.input = event.usage.input_tokens;
+    if (event.usage.output_tokens != null)
+        state.output.usage.output = event.usage.output_tokens;
+    if (event.usage.cache_read_input_tokens != null) {
+        state.output.usage.cacheRead = event.usage.cache_read_input_tokens;
+    }
+    if (event.usage.cache_creation_input_tokens != null) {
+        state.output.usage.cacheWrite = event.usage.cache_creation_input_tokens;
+    }
+    state.output.usage.totalTokens =
+        state.output.usage.input +
+            state.output.usage.output +
+            state.output.usage.cacheRead +
+            state.output.usage.cacheWrite;
+    calculateCost(state.model, state.output.usage);
+}
+function handleAnthropicStreamEvent(event, state) {
+    switch (event.type) {
+        case "message_start":
+            handleAnthropicMessageStart(event, state);
+            return;
+        case "content_block_start":
+            handleAnthropicContentBlockStart(event, state);
+            return;
+        case "content_block_delta":
+            handleAnthropicContentBlockDelta(event, state);
+            return;
+        case "content_block_stop":
+            handleAnthropicContentBlockStop(event, state);
+            return;
+        case "message_delta":
+            handleAnthropicMessageDelta(event, state);
     }
 }
+function resolveAnthropicStreamClient(model, context, options) {
+    if (options?.client)
+        return { client: options.client, isOAuthToken: false };
+    const apiKey = options?.apiKey ?? getEnvApiKey(model.provider) ?? "";
+    const copilotDynamicHeaders = model.provider === "github-copilot"
+        ? buildCopilotDynamicHeaders({
+            messages: context.messages,
+            hasImages: hasCopilotVisionInput(context.messages),
+        })
+        : undefined;
+    const cacheRetention = options?.cacheRetention ?? resolveCacheRetention();
+    const cacheSessionId = cacheRetention === "none" ? undefined : options?.sessionId;
+    return createClient(model, apiKey, options?.interleavedThinking ?? true, shouldUseFineGrainedToolStreamingBeta(model, context), options?.headers, copilotDynamicHeaders, cacheSessionId);
+}
+function validateAnthropicStreamCompletion(output, signal) {
+    if (signal?.aborted)
+        throw new Error("Request was aborted");
+    if (output.stopReason === "pending")
+        throw new Error("Anthropic stream ended without a stop reason");
+    if (output.stopReason === "aborted" || output.stopReason === "error")
+        throw new Error("An unknown error occurred");
+}
+async function executeAnthropicStream(state, options) {
+    const configuredClient = resolveAnthropicStreamClient(state.model, state.context, options);
+    state.isOAuth = configuredClient.isOAuthToken;
+    let params = buildParams(state.model, state.context, state.isOAuth, options);
+    const nextParams = await options?.onPayload?.(params, state.model);
+    if (nextParams !== undefined)
+        params = nextParams;
+    const requestOptions = {
+        ...(options?.signal ? { signal: options.signal } : {}),
+        ...(options?.timeoutMs !== undefined ? { timeout: options.timeoutMs } : {}),
+        maxRetries: 0,
+    };
+    const response = await retryProviderRequest(() => configuredClient.client.messages.create({ ...params, stream: true }, requestOptions).asResponse(), {
+        maxRetries: options?.maxRetries,
+        maxRetryDelayMs: options?.maxRetryDelayMs,
+        signal: options?.signal,
+    });
+    await options?.onResponse?.({ status: response.status, headers: headersToRecord(response.headers) }, state.model);
+    state.stream.push({ type: "start", partial: state.output });
+    for await (const event of iterateAnthropicEvents(response, options?.signal)) {
+        handleAnthropicStreamEvent(event, state);
+    }
+    validateAnthropicStreamCompletion(state.output, options?.signal);
+    state.stream.push({ type: "done", reason: state.output.stopReason, message: state.output });
+    state.stream.end();
+}
+function handleAnthropicStreamFailure(error, options, state) {
+    for (const block of state.blocks) {
+        delete block.index;
+        if (block.type === "toolCall")
+            delete block.partialJson;
+    }
+    state.output.stopReason = options?.signal?.aborted ? "aborted" : "error";
+    state.output.errorMessage = error instanceof Error ? error.message : JSON.stringify(error);
+    state.stream.push({ type: "error", reason: state.output.stopReason, error: state.output });
+    state.stream.end();
+}
 export const streamAnthropic = (model, context, options) => {
     const stream = new AssistantMessageEventStream();
+    const state = createAnthropicStreamState(model, context, stream);
     (async () => {
-        const output = {
-            role: "assistant",
-            content: [],
-            api: model.api,
-            provider: model.provider,
-            model: model.id,
-            usage: {
-                input: 0,
-                output: 0,
-                cacheRead: 0,
-                cacheWrite: 0,
-                totalTokens: 0,
-                cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
-            },
-            stopReason: "stop",
-            timestamp: Date.now(),
-        };
         try {
-            let client;
-            let isOAuth;
-            if (options?.client) {
-                client = options.client;
-                isOAuth = false;
-            }
-            else {
-                const apiKey = options?.apiKey ?? getEnvApiKey(model.provider) ?? "";
-                let copilotDynamicHeaders;
-                if (model.provider === "github-copilot") {
-                    const hasImages = hasCopilotVisionInput(context.messages);
-                    copilotDynamicHeaders = buildCopilotDynamicHeaders({
-                        messages: context.messages,
-                        hasImages,
-                    });
-                }
-                const cacheRetention = options?.cacheRetention ?? resolveCacheRetention();
-                const cacheSessionId = cacheRetention === "none" ? undefined : options?.sessionId;
-                const created = createClient(model, apiKey, options?.interleavedThinking ?? true, shouldUseFineGrainedToolStreamingBeta(model, context), options?.headers, copilotDynamicHeaders, cacheSessionId);
-                client = created.client;
-                isOAuth = created.isOAuthToken;
-            }
-            let params = buildParams(model, context, isOAuth, options);
-            const nextParams = await options?.onPayload?.(params, model);
-            if (nextParams !== undefined) {
-                params = nextParams;
-            }
-            const requestOptions = {
-                ...(options?.signal ? { signal: options.signal } : {}),
-                ...(options?.timeoutMs !== undefined ? { timeout: options.timeoutMs } : {}),
-                maxRetries: options?.maxRetries ?? 0,
-            };
-            const response = await client.messages.create({ ...params, stream: true }, requestOptions).asResponse();
-            await options?.onResponse?.({ status: response.status, headers: headersToRecord(response.headers) }, model);
-            stream.push({ type: "start", partial: output });
-            const blocks = output.content;
-            for await (const event of iterateAnthropicEvents(response, options?.signal)) {
-                if (event.type === "message_start") {
-                    output.responseId = event.message.id;
-                    // Capture initial token usage from message_start event
-                    // This ensures we have input token counts even if the stream is aborted early
-                    output.usage.input = event.message.usage.input_tokens || 0;
-                    output.usage.output = event.message.usage.output_tokens || 0;
-                    output.usage.cacheRead = event.message.usage.cache_read_input_tokens || 0;
-                    output.usage.cacheWrite = event.message.usage.cache_creation_input_tokens || 0;
-                    // Anthropic doesn't provide total_tokens, compute from components
-                    output.usage.totalTokens =
-                        output.usage.input + output.usage.output + output.usage.cacheRead + output.usage.cacheWrite;
-                    calculateCost(model, output.usage);
-                }
-                else if (event.type === "content_block_start") {
-                    if (event.content_block.type === "text") {
-                        const block = {
-                            type: "text",
-                            text: "",
-                            index: event.index,
-                        };
-                        output.content.push(block);
-                        stream.push({ type: "text_start", contentIndex: output.content.length - 1, partial: output });
-                    }
-                    else if (event.content_block.type === "thinking") {
-                        const block = {
-                            type: "thinking",
-                            thinking: "",
-                            thinkingSignature: "",
-                            index: event.index,
-                        };
-                        output.content.push(block);
-                        stream.push({ type: "thinking_start", contentIndex: output.content.length - 1, partial: output });
-                    }
-                    else if (event.content_block.type === "redacted_thinking") {
-                        const block = {
-                            type: "thinking",
-                            thinking: "[Reasoning redacted]",
-                            thinkingSignature: event.content_block.data,
-                            redacted: true,
-                            index: event.index,
-                        };
-                        output.content.push(block);
-                        stream.push({ type: "thinking_start", contentIndex: output.content.length - 1, partial: output });
-                    }
-                    else if (event.content_block.type === "tool_use") {
-                        const block = {
-                            type: "toolCall",
-                            id: event.content_block.id,
-                            name: isOAuth
-                                ? fromClaudeCodeName(event.content_block.name, context.tools)
-                                : event.content_block.name,
-                            arguments: event.content_block.input ?? {},
-                            partialJson: "",
-                            index: event.index,
-                        };
-                        output.content.push(block);
-                        stream.push({ type: "toolcall_start", contentIndex: output.content.length - 1, partial: output });
-                    }
-                }
-                else if (event.type === "content_block_delta") {
-                    if (event.delta.type === "text_delta") {
-                        const index = blocks.findIndex((b) => b.index === event.index);
-                        const block = blocks[index];
-                        if (block && block.type === "text") {
-                            block.text += event.delta.text;
-                            stream.push({
-                                type: "text_delta",
-                                contentIndex: index,
-                                delta: event.delta.text,
-                                partial: output,
-                            });
-                        }
-                    }
-                    else if (event.delta.type === "thinking_delta") {
-                        const index = blocks.findIndex((b) => b.index === event.index);
-                        const block = blocks[index];
-                        if (block && block.type === "thinking") {
-                            block.thinking += event.delta.thinking;
-                            stream.push({
-                                type: "thinking_delta",
-                                contentIndex: index,
-                                delta: event.delta.thinking,
-                                partial: output,
-                            });
-                        }
-                    }
-                    else if (event.delta.type === "input_json_delta") {
-                        const index = blocks.findIndex((b) => b.index === event.index);
-                        const block = blocks[index];
-                        if (block && block.type === "toolCall") {
-                            block.partialJson += event.delta.partial_json;
-                            block.arguments = parseStreamingJson(block.partialJson);
-                            stream.push({
-                                type: "toolcall_delta",
-                                contentIndex: index,
-                                delta: event.delta.partial_json,
-                                partial: output,
-                            });
-                        }
-                    }
-                    else if (event.delta.type === "signature_delta") {
-                        const index = blocks.findIndex((b) => b.index === event.index);
-                        const block = blocks[index];
-                        if (block && block.type === "thinking") {
-                            block.thinkingSignature = block.thinkingSignature || "";
-                            block.thinkingSignature += event.delta.signature;
-                        }
-                    }
-                }
-                else if (event.type === "content_block_stop") {
-                    const index = blocks.findIndex((b) => b.index === event.index);
-                    const block = blocks[index];
-                    if (block) {
-                        delete block.index;
-                        if (block.type === "text") {
-                            stream.push({
-                                type: "text_end",
-                                contentIndex: index,
-                                content: block.text,
-                                partial: output,
-                            });
-                        }
-                        else if (block.type === "thinking") {
-                            stream.push({
-                                type: "thinking_end",
-                                contentIndex: index,
-                                content: block.thinking,
-                                partial: output,
-                            });
-                        }
-                        else if (block.type === "toolCall") {
-                            block.arguments = parseStreamingJson(block.partialJson);
-                            // Finalize in-place and strip the scratch buffer so replay only
-                            // carries parsed arguments.
-                            delete block.partialJson;
-                            stream.push({
-                                type: "toolcall_end",
-                                contentIndex: index,
-                                toolCall: block,
-                                partial: output,
-                            });
-                        }
-                    }
-                }
-                else if (event.type === "message_delta") {
-                    if (event.delta.stop_reason) {
-                        output.stopReason = mapStopReason(event.delta.stop_reason);
-                    }
-                    // Only update usage fields if present (not null).
-                    // Preserves input_tokens from message_start when proxies omit it in message_delta.
-                    if (event.usage.input_tokens != null) {
-                        output.usage.input = event.usage.input_tokens;
-                    }
-                    if (event.usage.output_tokens != null) {
-                        output.usage.output = event.usage.output_tokens;
-                    }
-                    if (event.usage.cache_read_input_tokens != null) {
-                        output.usage.cacheRead = event.usage.cache_read_input_tokens;
-                    }
-                    if (event.usage.cache_creation_input_tokens != null) {
-                        output.usage.cacheWrite = event.usage.cache_creation_input_tokens;
-                    }
-                    // Anthropic doesn't provide total_tokens, compute from components
-                    output.usage.totalTokens =
-                        output.usage.input + output.usage.output + output.usage.cacheRead + output.usage.cacheWrite;
-                    calculateCost(model, output.usage);
-                }
-            }
-            if (options?.signal?.aborted) {
-                throw new Error("Request was aborted");
-            }
-            if (output.stopReason === "aborted" || output.stopReason === "error") {
-                throw new Error("An unknown error occurred");
-            }
-            stream.push({ type: "done", reason: output.stopReason, message: output });
-            stream.end();
+            await executeAnthropicStream(state, options);
         }
         catch (error) {
-            for (const block of output.content) {
-                delete block.index;
-                // partialJson is only a streaming scratch buffer; never persist it.
-                delete block.partialJson;
-            }
-            output.stopReason = options?.signal?.aborted ? "aborted" : "error";
-            output.errorMessage = error instanceof Error ? error.message : JSON.stringify(error);
-            stream.push({ type: "error", reason: output.stopReason, error: output });
-            stream.end();
+            handleAnthropicStreamFailure(error, options, state);
         }
     })();
     return stream;
@@ -669,16 +688,7 @@ function createClient(model, apiKey, interleavedThinking, useFineGrainedToolStre
     });
     return { client, isOAuthToken: false };
 }
-function buildParams(model, context, isOAuthToken, options) {
-    const { cacheControl } = getCacheControl(model, options?.cacheRetention);
-    const compat = getAnthropicCompat(model);
-    const params = {
-        model: model.id,
-        messages: convertMessages(context.messages, model, isOAuthToken, cacheControl, compat.allowEmptySignature),
-        max_tokens: options?.maxTokens ?? model.maxTokens,
-        stream: true,
-    };
-    // For OAuth tokens, we MUST include Claude Code identity
+function applyAnthropicSystemPrompt(params, context, isOAuthToken, cacheControl) {
     if (isOAuthToken) {
         params.system = [
             {
@@ -694,237 +704,220 @@ function buildParams(model, context, isOAuthToken, options) {
                 ...(cacheControl ? { cache_control: cacheControl } : {}),
             });
         }
+        return;
     }
-    else if (context.systemPrompt) {
-        // Add cache control to system prompt for non-OAuth tokens
-        params.system = [
-            {
-                type: "text",
-                text: sanitizeSurrogates(context.systemPrompt),
-                ...(cacheControl ? { cache_control: cacheControl } : {}),
-            },
-        ];
-    }
-    // Temperature is incompatible with extended thinking and unsupported on Claude Opus 4.7+.
-    if (options?.temperature !== undefined && !options?.thinkingEnabled && compat.supportsTemperature) {
+    if (!context.systemPrompt)
+        return;
+    params.system = [
+        {
+            type: "text",
+            text: sanitizeSurrogates(context.systemPrompt),
+            ...(cacheControl ? { cache_control: cacheControl } : {}),
+        },
+    ];
+}
+function applyAnthropicTemperature(params, options, compat) {
+    if (options?.temperature !== undefined && !options.thinkingEnabled && compat.supportsTemperature) {
         params.temperature = options.temperature;
     }
-    if (context.tools && context.tools.length > 0) {
-        params.tools = convertTools(context.tools, isOAuthToken, compat.supportsEagerToolInputStreaming, compat.supportsCacheControlOnTools ? cacheControl : undefined);
-    }
-    // Configure thinking mode: adaptive (Opus 4.6+ and Sonnet 4.6),
-    // budget-based (older models), or explicitly disabled.
-    if (model.reasoning) {
-        if (options?.thinkingEnabled) {
-            // Default to "summarized" so Opus 4.7 and Mythos Preview behave like
-            // older Claude 4 models (whose API default is also "summarized").
-            const display = options.thinkingDisplay ?? "summarized";
-            if (supportsAdaptiveThinking(model.id)) {
-                // Adaptive thinking: Claude decides when and how much to think.
-                params.thinking = { type: "adaptive", display };
-                if (options.effort) {
-                    // The Anthropic SDK types can lag newly supported effort values such as "xhigh".
-                    params.output_config =
-                        options.effort === "xhigh"
-                            ? { effort: options.effort }
-                            : { effort: options.effort };
-                }
-            }
-            else {
-                // Budget-based thinking for older models
-                params.thinking = {
-                    type: "enabled",
-                    budget_tokens: options.thinkingBudgetTokens || 1024,
-                    display,
-                };
-            }
-        }
-        else if (options?.thinkingEnabled === false) {
-            params.thinking = { type: "disabled" };
-        }
-    }
-    if (options?.metadata) {
-        const userId = options.metadata.user_id;
-        if (typeof userId === "string") {
-            params.metadata = { user_id: userId };
-        }
-    }
-    if (options?.toolChoice) {
-        if (typeof options.toolChoice === "string") {
-            params.tool_choice = { type: options.toolChoice };
-        }
-        else {
-            params.tool_choice = options.toolChoice;
-        }
-    }
+}
+function applyAnthropicTools(params, context, isOAuthToken, cacheControl, compat) {
+    if (!context.tools || context.tools.length === 0)
+        return;
+    params.tools = convertTools(context.tools, isOAuthToken, compat.supportsEagerToolInputStreaming, compat.supportsCacheControlOnTools ? cacheControl : undefined);
+}
+function applyAdaptiveThinkingEffort(params, effort) {
+    if (!effort)
+        return;
+    // The Anthropic SDK types can lag newly supported effort values such as "xhigh".
+    params.output_config =
+        effort === "xhigh"
+            ? { effort }
+            : { effort };
+}
+function applyEnabledAnthropicThinking(params, model, options) {
+    const display = options.thinkingDisplay ?? "summarized";
+    if (supportsAdaptiveThinking(model.id)) {
+        params.thinking = { type: "adaptive", display };
+        applyAdaptiveThinkingEffort(params, options.effort);
+        return;
+    }
+    params.thinking = {
+        type: "enabled",
+        budget_tokens: options.thinkingBudgetTokens || 1024,
+        display,
+    };
+}
+function applyAnthropicThinking(params, model, options) {
+    if (!model.reasoning)
+        return;
+    if (options?.thinkingEnabled) {
+        applyEnabledAnthropicThinking(params, model, options);
+        return;
+    }
+    if (options?.thinkingEnabled === false)
+        params.thinking = { type: "disabled" };
+}
+function applyAnthropicMetadata(params, options) {
+    const userId = options?.metadata?.user_id;
+    if (typeof userId === "string")
+        params.metadata = { user_id: userId };
+}
+function applyAnthropicToolChoice(params, options) {
+    if (!options?.toolChoice)
+        return;
+    params.tool_choice = typeof options.toolChoice === "string" ? { type: options.toolChoice } : options.toolChoice;
+}
+function buildParams(model, context, isOAuthToken, options) {
+    const { cacheControl } = getCacheControl(model, options?.cacheRetention);
+    const compat = getAnthropicCompat(model);
+    const params = {
+        model: model.id,
+        messages: convertMessages(context.messages, model, isOAuthToken, cacheControl, compat.allowEmptySignature),
+        max_tokens: options?.maxTokens ?? model.maxTokens,
+        stream: true,
+    };
+    applyAnthropicSystemPrompt(params, context, isOAuthToken, cacheControl);
+    applyAnthropicTemperature(params, options, compat);
+    applyAnthropicTools(params, context, isOAuthToken, cacheControl, compat);
+    applyAnthropicThinking(params, model, options);
+    applyAnthropicMetadata(params, options);
+    applyAnthropicToolChoice(params, options);
     return params;
 }
 // Normalize tool call IDs to match Anthropic's required pattern and length
 function normalizeToolCallId(id) {
     return id.replace(/[^a-zA-Z0-9_-]/g, "_").slice(0, 64);
 }
-function convertMessages(messages, model, isOAuthToken, cacheControl, allowEmptySignature = false) {
-    const params = [];
-    // Transform messages for cross-provider compatibility
-    const transformedMessages = transformMessages(messages, model, normalizeToolCallId);
-    for (let i = 0; i < transformedMessages.length; i++) {
-        const msg = transformedMessages[i];
-        if (msg.role === "user") {
-            if (typeof msg.content === "string") {
-                if (msg.content.trim().length > 0) {
-                    params.push({
-                        role: "user",
-                        content: sanitizeSurrogates(msg.content),
-                    });
-                }
-            }
-            else {
-                const blocks = msg.content.map((item) => {
-                    if (item.type === "text") {
-                        return {
-                            type: "text",
-                            text: sanitizeSurrogates(item.text),
-                        };
-                    }
-                    else {
-                        return {
-                            type: "image",
-                            source: {
-                                type: "base64",
-                                media_type: item.mimeType,
-                                data: item.data,
-                            },
-                        };
-                    }
-                });
-                const filteredBlocks = blocks.filter((b) => {
-                    if (b.type === "text") {
-                        return b.text.trim().length > 0;
-                    }
-                    return true;
-                });
-                if (filteredBlocks.length === 0)
-                    continue;
-                params.push({
-                    role: "user",
-                    content: filteredBlocks,
-                });
-            }
+function convertAnthropicUserMessage(message) {
+    if (typeof message.content === "string") {
+        return message.content.trim().length > 0
+            ? { role: "user", content: sanitizeSurrogates(message.content) }
+            : undefined;
+    }
+    const content = [];
+    for (const block of message.content) {
+        if (block.type === "text") {
+            if (block.text.trim().length > 0)
+                content.push({ type: "text", text: sanitizeSurrogates(block.text) });
         }
-        else if (msg.role === "assistant") {
-            const blocks = [];
-            for (const block of msg.content) {
-                if (block.type === "text") {
-                    if (block.text.trim().length === 0)
-                        continue;
-                    blocks.push({
-                        type: "text",
-                        text: sanitizeSurrogates(block.text),
-                    });
-                }
-                else if (block.type === "thinking") {
-                    // Redacted thinking: pass the opaque payload back as redacted_thinking
-                    if (block.redacted) {
-                        blocks.push({
-                            type: "redacted_thinking",
-                            data: block.thinkingSignature,
-                        });
-                        continue;
-                    }
-                    if (block.thinking.trim().length === 0)
-                        continue;
-                    // If thinking signature is missing/empty (e.g., from aborted stream),
-                    // convert to plain text for Anthropic. Some compatible providers emit
-                    // and accept empty signatures, so let marked models preserve the block.
-                    if (!block.thinkingSignature || block.thinkingSignature.trim().length === 0) {
-                        blocks.push(allowEmptySignature
-                            ? {
-                                type: "thinking",
-                                thinking: sanitizeSurrogates(block.thinking),
-                                signature: "",
-                            }
-                            : {
-                                type: "text",
-                                text: sanitizeSurrogates(block.thinking),
-                            });
-                    }
-                    else {
-                        blocks.push({
-                            type: "thinking",
-                            thinking: sanitizeSurrogates(block.thinking),
-                            signature: block.thinkingSignature,
-                        });
-                    }
-                }
-                else if (block.type === "toolCall") {
-                    blocks.push({
-                        type: "tool_use",
-                        id: block.id,
-                        name: isOAuthToken ? toClaudeCodeName(block.name) : block.name,
-                        input: block.arguments ?? {},
-                    });
-                }
-            }
-            if (blocks.length === 0)
-                continue;
-            params.push({
-                role: "assistant",
-                content: blocks,
+        else {
+            content.push({
+                type: "image",
+                source: {
+                    type: "base64",
+                    media_type: block.mimeType,
+                    data: block.data,
+                },
             });
         }
-        else if (msg.role === "toolResult") {
-            // Collect all consecutive toolResult messages, needed for z.ai Anthropic endpoint
-            const toolResults = [];
-            // Add the current tool result
-            toolResults.push({
-                type: "tool_result",
-                tool_use_id: msg.toolCallId,
-                content: convertContentBlocks(msg.content),
-                is_error: msg.isError,
-            });
-            // Look ahead for consecutive toolResult messages
-            let j = i + 1;
-            while (j < transformedMessages.length && transformedMessages[j].role === "toolResult") {
-                const nextMsg = transformedMessages[j]; // We know it's a toolResult
-                toolResults.push({
-                    type: "tool_result",
-                    tool_use_id: nextMsg.toolCallId,
-                    content: convertContentBlocks(nextMsg.content),
-                    is_error: nextMsg.isError,
-                });
-                j++;
-            }
-            // Skip the messages we've already processed
-            i = j - 1;
-            // Add a single user message with all tool results
-            params.push({
-                role: "user",
-                content: toolResults,
-            });
+    }
+    return content.length > 0 ? { role: "user", content } : undefined;
+}
+function convertAnthropicThinkingBlock(block, allowEmptySignature) {
+    if (block.redacted)
+        return { type: "redacted_thinking", data: block.thinkingSignature };
+    if (block.thinking.trim().length === 0)
+        return undefined;
+    if (!block.thinkingSignature || block.thinkingSignature.trim().length === 0) {
+        return allowEmptySignature
+            ? { type: "thinking", thinking: sanitizeSurrogates(block.thinking), signature: "" }
+            : { type: "text", text: sanitizeSurrogates(block.thinking) };
+    }
+    return {
+        type: "thinking",
+        thinking: sanitizeSurrogates(block.thinking),
+        signature: block.thinkingSignature,
+    };
+}
+function convertAnthropicAssistantBlock(block, isOAuthToken, allowEmptySignature) {
+    switch (block.type) {
+        case "text":
+            return block.text.trim().length > 0 ? { type: "text", text: sanitizeSurrogates(block.text) } : undefined;
+        case "thinking":
+            return convertAnthropicThinkingBlock(block, allowEmptySignature);
+        case "toolCall":
+            return {
+                type: "tool_use",
+                id: block.id,
+                name: isOAuthToken ? toClaudeCodeName(block.name) : block.name,
+                input: block.arguments ?? {},
+            };
+    }
+}
+function convertAnthropicAssistantMessage(message, isOAuthToken, allowEmptySignature) {
+    const content = [];
+    for (const block of message.content) {
+        const converted = convertAnthropicAssistantBlock(block, isOAuthToken, allowEmptySignature);
+        if (converted)
+            content.push(converted);
+    }
+    return content.length > 0 ? { role: "assistant", content } : undefined;
+}
+function convertAnthropicToolResult(message) {
+    return {
+        type: "tool_result",
+        tool_use_id: message.toolCallId,
+        content: convertContentBlocks(message.content),
+        is_error: message.isError,
+    };
+}
+function collectAnthropicToolResultBatch(messages, startIndex) {
+    const content = [];
+    let lastIndex = startIndex;
+    for (let index = startIndex; index < messages.length; index++) {
+        const message = messages[index];
+        if (message.role !== "toolResult")
+            break;
+        content.push(convertAnthropicToolResult(message));
+        lastIndex = index;
+    }
+    return { content, lastIndex };
+}
+function applyAnthropicConversationCacheControl(params, cacheControl) {
+    if (!cacheControl || params.length === 0)
+        return;
+    const lastMessage = params[params.length - 1];
+    if (lastMessage.role !== "user")
+        return;
+    if (Array.isArray(lastMessage.content)) {
+        const lastBlock = lastMessage.content[lastMessage.content.length - 1];
+        if (lastBlock && (lastBlock.type === "text" || lastBlock.type === "image" || lastBlock.type === "tool_result")) {
+            lastBlock.cache_control = cacheControl;
         }
+        return;
     }
-    // Add cache_control to the last user message to cache conversation history
-    if (cacheControl && params.length > 0) {
-        const lastMessage = params[params.length - 1];
-        if (lastMessage.role === "user") {
-            if (Array.isArray(lastMessage.content)) {
-                const lastBlock = lastMessage.content[lastMessage.content.length - 1];
-                if (lastBlock &&
-                    (lastBlock.type === "text" || lastBlock.type === "image" || lastBlock.type === "tool_result")) {
-                    lastBlock.cache_control = cacheControl;
-                }
+    if (typeof lastMessage.content === "string") {
+        lastMessage.content = [{ type: "text", text: lastMessage.content, cache_control: cacheControl }];
+    }
+}
+function convertMessages(messages, model, isOAuthToken, cacheControl, allowEmptySignature = false) {
+    const params = [];
+    const transformedMessages = transformMessages(messages, model, normalizeToolCallId);
+    for (let index = 0; index < transformedMessages.length; index++) {
+        const message = transformedMessages[index];
+        switch (message.role) {
+            case "user": {
+                const converted = convertAnthropicUserMessage(message);
+                if (converted)
+                    params.push(converted);
+                break;
+            }
+            case "assistant": {
+                const converted = convertAnthropicAssistantMessage(message, isOAuthToken, allowEmptySignature);
+                if (converted)
+                    params.push(converted);
+                break;
             }
-            else if (typeof lastMessage.content === "string") {
-                lastMessage.content = [
-                    {
-                        type: "text",
-                        text: lastMessage.content,
-                        cache_control: cacheControl,
-                    },
-                ];
+            case "toolResult": {
+                const batch = collectAnthropicToolResultBatch(transformedMessages, index);
+                params.push({ role: "user", content: batch.content });
+                index = batch.lastIndex;
+                break;
             }
         }
     }
+    applyAnthropicConversationCacheControl(params, cacheControl);
     return params;
 }
 function shouldUseFineGrainedToolStreamingBeta(model, context) {