shortcutxl 0.3.76 → 0.3.78

package/dist/embedded-agent/anthropic-messages-transport.js

@@ -1,181 +1,9 @@
-import { anthropicTerminalStopErrorDetails, streamSimpleAnthropic } from '../ai/providers/anthropic.js';
-import { createShortcutXLModelCallError, ShortcutXLModelCallErrorCategory, ShortcutXLModelCallErrorEnvelope, ShortcutXLModelCallTransportKind, ShortcutXLProviderUsageStatus } from '../contracts/model-call.js';
-import { isModelAccessDeniedErrorMessage, MODEL_ACCESS_DENIED_PROVIDER_ERROR_TYPE, networkErrorDetails, providerErrorDetailsFromRawType, safeModelStreamErrorMessage, ShortcutXLAgentAssistantContentKind, ShortcutXLModelStreamEventKind, ShortcutXLModelStreamFetchStage, ShortcutXLModelStreamMessageRole, ShortcutXLModelStreamStopReason } from '../contracts/model-stream.js';
-import { aiUserContentToAnthropicContent } from './ai-content.js';
-import { withoutV1Segment } from './gateway-base-url.js';
-import { shortcutProviderFastModeFromRequest, withProviderFastModeHeaders, withProviderFastModePayload, withProviderFastModePayloadOverride } from './provider-fast-mode.js';
-import { normalizeTransportFetchError, normalizeTransportStreamError, throwInvalidResponse, throwTransportHttpError } from './transport-errors.js';
-function incompleteStreamError() {
-    return new ShortcutXLModelCallErrorEnvelope(createShortcutXLModelCallError(ShortcutXLModelCallErrorCategory.TransientNetwork, 'Anthropic Messages stream ended before terminal message_stop; the upstream stream may have been interrupted or timed out.', networkErrorDetails(ShortcutXLModelStreamFetchStage.ResponseBody)));
-}
-const MODEL_ACCESS_DENIED_DETAILS = {
-    providerErrorType: MODEL_ACCESS_DENIED_PROVIDER_ERROR_TYPE,
-    retryable: false,
-    status: 403
-};
-function streamErrorCategory(details) {
-    switch (details.providerErrorType) {
-        case 'rate_limit':
-            return ShortcutXLModelCallErrorCategory.RateLimited;
-        case 'unauthorized':
-            return ShortcutXLModelCallErrorCategory.Auth;
-        case MODEL_ACCESS_DENIED_PROVIDER_ERROR_TYPE:
-        case 'invalid_request':
-            return ShortcutXLModelCallErrorCategory.ProviderRejected;
-        default:
-            return ShortcutXLModelCallErrorCategory.TransientNetwork;
-    }
-}
-/**
- * Fall back to matching the free-text message when the structured `error.type`
- * (https://docs.anthropic.com/en/api/errors) is absent or unrecognized. Returns
- * a raw type the shared mapping understands; unknown text is treated as a
- * retryable provider-internal failure.
- */
-function rawErrorTypeFromText(text) {
-    if (text.includes('overload'))
-        return 'overloaded_error';
-    if (text.includes('rate_limit') || text.includes('rate limit') || text.includes('429')) {
-        return 'rate_limit_error';
-    }
-    if (text.includes('authentication') || text.includes('unauthorized') || text.includes('401')) {
-        return 'authentication_error';
-    }
-    if (text.includes('invalid_request') ||
-        text.includes('invalid request') ||
-        text.includes('bad_request') ||
-        text.includes('not_found') ||
-        text.includes('not found') ||
-        text.includes('400') ||
-        text.includes('422')) {
-        return 'invalid_request_error';
-    }
-    return 'api_error';
-}
-function normalizeAnthropicStreamError(error) {
-    const rawType = error?.type?.trim().toLowerCase() ?? '';
-    const rawMessage = error?.message?.trim();
-    const text = `${rawType} ${rawMessage ?? ''}`.toLowerCase();
-    const details = isModelAccessDeniedErrorMessage(rawMessage, undefined)
-        ? MODEL_ACCESS_DENIED_DETAILS
-        : (providerErrorDetailsFromRawType(rawType) ??
-            providerErrorDetailsFromRawType(rawErrorTypeFromText(text)) ??
-            // Unreachable: rawErrorTypeFromText only returns mapped types.
-            networkErrorDetails());
-    return {
-        category: streamErrorCategory(details),
-        details,
-        message: safeModelStreamErrorMessage(details)
-    };
-}
-function throwProviderStreamError(normalized) {
-    throw new ShortcutXLModelCallErrorEnvelope(createShortcutXLModelCallError(normalized.category, normalized.message, normalized.details));
-}
-const AnthropicRuntimeApi = 'anthropic-messages';
-function normalizeBaseUrl(baseUrl) {
-    return baseUrl.replace(/\/+$/, '');
-}
-function createAuthHeader(auth) {
-    if (auth.headerName === 'Authorization') {
-        return {
-            Authorization: auth.token.startsWith('Bearer ') ? auth.token : `Bearer ${auth.token}`
-        };
-    }
-    return { 'x-api-key': auth.token };
-}
-const normalizeAiAnthropicBaseUrl = withoutV1Segment;
-function buildGatewayAiModel(request, baseUrl) {
-    return {
-        api: 'anthropic-messages',
-        baseUrl: normalizeAiAnthropicBaseUrl(baseUrl),
-        contextWindow: request.model.contextWindow,
-        cost: { cacheRead: 0, cacheWrite: 0, input: 0, output: 0 },
-        id: request.model.id,
-        input: request.model.input,
-        maxTokens: request.model.maxTokens,
-        name: request.model.name,
-        provider: request.model.provider,
-        reasoning: request.model.reasoning
-    };
-}
-function buildGatewayAiStreamOptions(request, options) {
-    const fastMode = shortcutProviderFastModeFromRequest('anthropic', request);
-    const configuredHeaders = withProviderFastModeHeaders({
-        ...request.options?.headers,
-        ...options.headers
-    }, fastMode);
-    const apiKey = options.auth.token;
-    if (options.auth.headerName === 'Authorization') {
-        configuredHeaders.Authorization = options.auth.token.startsWith('Bearer ')
-            ? options.auth.token
-            : `Bearer ${options.auth.token}`;
-        configuredHeaders['x-api-key'] = null;
-    }
-    return withProviderFastModePayloadOverride({
-        apiKey,
-        cacheRetention: request.options?.cacheRetention,
-        fetch: options.fetchImpl,
-        fetchOptions: options.fetchOptions,
-        headers: configuredHeaders,
-        maxRetryDelayMs: request.options?.maxRetryDelayMs,
-        maxTokens: request.options?.maxTokens,
-        metadata: request.options?.metadata,
-        reasoning: request.options?.reasoning,
-        signal: options.signal,
-        temperature: request.options?.temperature,
-        transport: request.options?.transport
-    }, fastMode);
-}
-function mapGatewayThinkingEffort(reasoning, _modelId) {
-    switch (reasoning) {
-        case 'minimal':
-        case 'low':
-            return 'low';
-        case 'medium':
-            return 'medium';
-        case 'xhigh':
-            return 'max';
-        case 'high':
-            return 'high';
-    }
-}
-function withAdaptiveGatewayThinkingPayloadOverride(modelId, options) {
-    // Every served Claude model uses adaptive thinking; legacy budget-based
-    // thinking (pre-4 Claude) has been retired.
-    if (!options.reasoning)
-        return options;
-    const effort = mapGatewayThinkingEffort(options.reasoning, modelId);
-    const onPayload = options.onPayload;
-    return {
-        ...options,
-        onPayload: (payload) => {
-            if (payload && typeof payload === 'object') {
-                Object.assign(payload, {
-                    output_config: { effort },
-                    thinking: { type: 'adaptive', display: 'summarized' }
-                });
-            }
-            onPayload?.(payload);
-        }
-    };
-}
-function streamGatewayAiAnthropic(model, request, options) {
-    return streamSimpleAnthropic(model, request.context, withAdaptiveGatewayThinkingPayloadOverride(model.id, options));
-}
-function buildUsage(usage) {
-    const output = usage?.output_tokens ?? 0;
-    const cacheRead = usage?.cache_read_input_tokens ?? 0;
-    const cacheWrite = usage?.cache_creation_input_tokens ?? 0;
-    const input = (usage?.input_tokens ?? 0) + cacheRead + cacheWrite;
-    return {
-        cacheRead,
-        cacheWrite,
-        cost: { cacheRead: 0, cacheWrite: 0, input: 0, output: 0, total: 0 },
-        input,
-        output,
-        totalTokens: input + output
-    };
-}
+import { buildAnthropicMessagesRequest, streamSimpleAnthropic } from '../ai/providers/anthropic.js';
+import { ShortcutXLModelCallTransportKind, ShortcutXLProviderUsageStatus } from '../contracts/model-call.js';
+import { ShortcutXLAgentAssistantContentKind, ShortcutXLModelStreamEventKind, ShortcutXLModelStreamStopReason } from '../contracts/model-stream.js';
+import { shortcutProviderFastModeFromRequest, withProviderFastModeHeaders, withProviderFastModePayload } from './provider-fast-mode.js';
+import { concreteProviderHeaders, createGatewayProviderModel, createGatewayProviderOptions } from './provider-native-request.js';
+import { normalizeTransportFetchError, throwInvalidResponse, throwTransportHttpError } from './transport-errors.js';
 function buildUsageFromAi(usage) {
     return {
         cacheRead: usage?.cacheRead ?? 0,
@@ -211,15 +39,8 @@ export function toProviderUsageFromAi(usage) {
         totalTokens: usage.totalTokens
     };
 }
-function cloneMessage(message) {
-    return {
-        ...message,
-        content: message.content.map((content) => ({ ...content })),
-        usage: {
-            ...message.usage,
-            cost: { ...message.usage.cost }
-        }
-    };
+async function emitProviderUsage(logger, event) {
+    await logger?.recordProviderUsage(event);
 }
 function toShortcutXLAssistantContent(content) {
     switch (content.type) {
@@ -375,545 +196,6 @@ export function toShortcutXLModelStreamEvent(event) {
         }
     }
 }
-function normalizeStopReason(stopReason) {
-    if (stopReason === 'tool_use')
-        return ShortcutXLModelStreamStopReason.ToolUse;
-    if (stopReason === 'max_tokens')
-        return ShortcutXLModelStreamStopReason.Length;
-    return ShortcutXLModelStreamStopReason.Stop;
-}
-function toAnthropicRole(role) {
-    return role === ShortcutXLModelStreamMessageRole.Ai ? 'assistant' : 'user';
-}
-function buildMessages(messages) {
-    const system = messages
-        .filter((message) => message.role === ShortcutXLModelStreamMessageRole.System)
-        .map((message) => message.content)
-        .join('\n\n');
-    const anthropicMessages = messages
-        .filter((message) => message.role !== ShortcutXLModelStreamMessageRole.System)
-        .map((message) => ({
-        content: message.content,
-        role: toAnthropicRole(message.role)
-    }));
-    return {
-        messages: anthropicMessages,
-        ...(system ? { system } : {})
-    };
-}
-function buildRequestBody(call) {
-    const messages = buildMessages(call.payload.messages);
-    return {
-        max_tokens: call.payload.maxTokens ?? 4096,
-        ...messages,
-        model: call.payload.model,
-        stream: true,
-        ...(call.payload.tools
-            ? {
-                tools: call.payload.tools.map((tool) => ({
-                    description: tool.description,
-                    input_schema: tool.parameters,
-                    name: tool.name
-                }))
-            }
-            : {})
-    };
-}
-function parseToolArguments(inputJson) {
-    if (!inputJson)
-        return {};
-    const parsed = JSON.parse(inputJson);
-    return parsed && typeof parsed === 'object' && !Array.isArray(parsed)
-        ? parsed
-        : {};
-}
-async function readSseEvents(response, onEvent) {
-    if (!response.body)
-        throwInvalidResponse('Anthropic Messages stream response had no body.');
-    const decoder = new TextDecoder();
-    const reader = response.body.getReader();
-    let buffer = '';
-    for (;;) {
-        const { done, value } = await reader.read();
-        if (done)
-            break;
-        buffer += decoder.decode(value, { stream: true });
-        for (;;) {
-            const boundary = buffer.indexOf('\n\n');
-            if (boundary === -1)
-                break;
-            const frame = buffer.slice(0, boundary);
-            buffer = buffer.slice(boundary + 2);
-            const data = frame
-                .split('\n')
-                .find((line) => line.startsWith('data:'))
-                ?.slice('data:'.length)
-                .trim();
-            if (!data || data === '[DONE]')
-                continue;
-            try {
-                await onEvent(JSON.parse(data));
-            }
-            catch (error) {
-                if (error instanceof ShortcutXLModelCallErrorEnvelope)
-                    throw error;
-                throwInvalidResponse(error instanceof SyntaxError
-                    ? 'Anthropic Messages stream emitted malformed JSON.'
-                    : error instanceof Error
-                        ? error.message
-                        : String(error));
-            }
-        }
-    }
-}
-async function emitProviderUsage(logger, event) {
-    await logger?.recordProviderUsage(event);
-}
-async function streamAnthropicMessagesResponse(options) {
-    const blocks = new Map();
-    let latestUsage;
-    let stopReason;
-    let sawMessageStop = false;
-    const emit = (event) => options.onEvent(event);
-    emit({
-        kind: ShortcutXLModelStreamEventKind.Start,
-        partial: cloneMessage(options.message)
-    });
-    await readSseEvents(options.response, async (event) => {
-        switch (event.type) {
-            case 'message_start':
-                latestUsage = { ...latestUsage, ...event.message?.usage };
-                return;
-            case 'content_block_start': {
-                const block = event.content_block;
-                if (!block)
-                    return;
-                if (block.type === 'text') {
-                    blocks.set(event.index, {
-                        inputJson: '',
-                        signature: '',
-                        text: block.text ?? '',
-                        type: 'text'
-                    });
-                    options.message.content[event.index] = {
-                        text: block.text ?? '',
-                        type: ShortcutXLAgentAssistantContentKind.Text
-                    };
-                    emit({
-                        contentIndex: event.index,
-                        kind: ShortcutXLModelStreamEventKind.TextStart,
-                        partial: cloneMessage(options.message)
-                    });
-                    return;
-                }
-                if (block.type === 'tool_use') {
-                    blocks.set(event.index, {
-                        id: block.id,
-                        inputJson: '',
-                        name: block.name,
-                        signature: '',
-                        text: '',
-                        type: 'tool_use'
-                    });
-                    options.message.content[event.index] = {
-                        arguments: {},
-                        id: block.id ?? '',
-                        name: block.name ?? '',
-                        type: ShortcutXLAgentAssistantContentKind.ToolCall
-                    };
-                    emit({
-                        contentIndex: event.index,
-                        kind: ShortcutXLModelStreamEventKind.ToolCallStart,
-                        partial: cloneMessage(options.message)
-                    });
-                    return;
-                }
-                if (block.type === 'thinking') {
-                    blocks.set(event.index, {
-                        inputJson: '',
-                        signature: '',
-                        text: block.thinking ?? '',
-                        type: 'thinking'
-                    });
-                    options.message.content[event.index] = {
-                        redacted: false,
-                        thinking: block.thinking ?? '',
-                        thinkingSignature: '',
-                        type: ShortcutXLAgentAssistantContentKind.Thinking
-                    };
-                    emit({
-                        contentIndex: event.index,
-                        kind: ShortcutXLModelStreamEventKind.ThinkingStart,
-                        partial: cloneMessage(options.message)
-                    });
-                }
-                return;
-            }
-            case 'content_block_delta': {
-                const block = blocks.get(event.index);
-                if (!block || !event.delta)
-                    return;
-                if (event.delta.type === 'text_delta') {
-                    const delta = event.delta.text ?? '';
-                    block.text += delta;
-                    options.message.content[event.index] = {
-                        text: block.text,
-                        type: ShortcutXLAgentAssistantContentKind.Text
-                    };
-                    emit({
-                        contentIndex: event.index,
-                        delta,
-                        kind: ShortcutXLModelStreamEventKind.TextDelta,
-                        partial: cloneMessage(options.message)
-                    });
-                    return;
-                }
-                if (event.delta.type === 'input_json_delta') {
-                    const delta = event.delta.partial_json ?? '';
-                    block.inputJson += delta;
-                    emit({
-                        contentIndex: event.index,
-                        delta,
-                        kind: ShortcutXLModelStreamEventKind.ToolCallDelta,
-                        partial: cloneMessage(options.message)
-                    });
-                    return;
-                }
-                if (event.delta.type === 'thinking_delta') {
-                    const delta = event.delta.thinking ?? '';
-                    block.text += delta;
-                    options.message.content[event.index] = {
-                        redacted: false,
-                        thinking: block.text,
-                        thinkingSignature: block.signature,
-                        type: ShortcutXLAgentAssistantContentKind.Thinking
-                    };
-                    emit({
-                        contentIndex: event.index,
-                        delta,
-                        kind: ShortcutXLModelStreamEventKind.ThinkingDelta,
-                        partial: cloneMessage(options.message)
-                    });
-                    return;
-                }
-                if (event.delta.type === 'signature_delta') {
-                    block.signature += event.delta.signature ?? '';
-                }
-                return;
-            }
-            case 'content_block_stop': {
-                const block = blocks.get(event.index);
-                if (!block)
-                    return;
-                const content = options.message.content[event.index];
-                if (block.type === 'text') {
-                    emit({
-                        contentIndex: event.index,
-                        kind: ShortcutXLModelStreamEventKind.TextEnd,
-                        partial: cloneMessage(options.message)
-                    });
-                    return;
-                }
-                if (block.type === 'tool_use') {
-                    const toolCall = {
-                        arguments: parseToolArguments(block.inputJson),
-                        id: block.id ?? '',
-                        name: block.name ?? '',
-                        type: ShortcutXLAgentAssistantContentKind.ToolCall
-                    };
-                    options.message.content[event.index] = toolCall;
-                    emit({
-                        contentIndex: event.index,
-                        kind: ShortcutXLModelStreamEventKind.ToolCallEnd,
-                        partial: cloneMessage(options.message),
-                        toolCall
-                    });
-                    return;
-                }
-                if (block.type === 'thinking' &&
-                    content?.type === ShortcutXLAgentAssistantContentKind.Thinking) {
-                    options.message.content[event.index] = { ...content, thinkingSignature: block.signature };
-                    emit({
-                        content: block.text,
-                        contentIndex: event.index,
-                        kind: ShortcutXLModelStreamEventKind.ThinkingEnd,
-                        partial: cloneMessage(options.message)
-                    });
-                }
-                return;
-            }
-            case 'message_delta':
-                stopReason = event.delta?.stop_reason ?? stopReason;
-                latestUsage = { ...latestUsage, ...event.usage };
-                return;
-            case 'message_stop':
-                sawMessageStop = true;
-                options.message.usage = buildUsage(latestUsage);
-                await emitProviderUsage(options.usageStatusLogger, {
-                    callId: options.callId,
-                    model: options.model,
-                    status: latestUsage
-                        ? ShortcutXLProviderUsageStatus.UsageAvailable
-                        : ShortcutXLProviderUsageStatus.Unavailable,
-                    transport: ShortcutXLModelCallTransportKind.AnthropicMessages,
-                    usage: toProviderUsage(latestUsage)
-                });
-                const errorDetails = anthropicTerminalStopErrorDetails(stopReason);
-                if (errorDetails) {
-                    const normalized = {
-                        category: ShortcutXLModelCallErrorCategory.ProviderRejected,
-                        details: errorDetails,
-                        message: safeModelStreamErrorMessage(errorDetails)
-                    };
-                    options.message.stopReason = ShortcutXLModelStreamStopReason.Error;
-                    options.message.errorDetails = normalized.details;
-                    options.message.errorMessage = normalized.message;
-                    emit({
-                        error: cloneMessage(options.message),
-                        kind: ShortcutXLModelStreamEventKind.Error,
-                        partial: cloneMessage(options.message),
-                        reason: ShortcutXLModelStreamStopReason.Error
-                    });
-                    throwProviderStreamError(normalized);
-                }
-                options.message.stopReason = normalizeStopReason(stopReason);
-                emit({
-                    kind: ShortcutXLModelStreamEventKind.Done,
-                    message: cloneMessage(options.message),
-                    partial: cloneMessage(options.message),
-                    reason: options.message.stopReason
-                });
-                return;
-            case 'error': {
-                const normalized = normalizeAnthropicStreamError(event.error);
-                options.message.stopReason = ShortcutXLModelStreamStopReason.Error;
-                options.message.errorDetails = normalized.details;
-                options.message.errorMessage = normalized.message;
-                emit({
-                    error: cloneMessage(options.message),
-                    kind: ShortcutXLModelStreamEventKind.Error,
-                    partial: cloneMessage(options.message),
-                    reason: ShortcutXLModelStreamStopReason.Error
-                });
-                throwProviderStreamError(normalized);
-            }
-        }
-    });
-    if (!sawMessageStop) {
-        const error = incompleteStreamError();
-        options.message.stopReason = ShortcutXLModelStreamStopReason.Error;
-        // The emitted event is the terminal the host forwards (the thrown envelope
-        // below is dropped as a duplicate), so it must carry the structured
-        // details itself or classification falls back to message text.
-        options.message.errorDetails = networkErrorDetails(ShortcutXLModelStreamFetchStage.ResponseBody);
-        options.message.errorMessage = error.message;
-        emit({
-            error: cloneMessage(options.message),
-            kind: ShortcutXLModelStreamEventKind.Error,
-            partial: cloneMessage(options.message),
-            reason: ShortcutXLModelStreamStopReason.Error
-        });
-        await emitProviderUsage(options.usageStatusLogger, {
-            callId: options.callId,
-            model: options.model,
-            status: ShortcutXLProviderUsageStatus.Unavailable,
-            transport: ShortcutXLModelCallTransportKind.AnthropicMessages,
-            usage: undefined
-        });
-        throw error;
-    }
-}
-function aiToolResultContentToAnthropic(content) {
-    const hasMedia = content.some((block) => block.type === 'image' || block.type === 'document');
-    if (!hasMedia) {
-        return content
-            .filter((block) => block.type === 'text')
-            .map((block) => block.text)
-            .join('\n');
-    }
-    const blocks = content.map((block) => {
-        if (block.type === 'text') {
-            return { text: block.text, type: 'text' };
-        }
-        if (block.type === 'document') {
-            return {
-                source: {
-                    data: block.data,
-                    media_type: block.mimeType,
-                    type: 'base64'
-                },
-                type: 'document'
-            };
-        }
-        return {
-            source: {
-                data: block.data,
-                media_type: block.mimeType,
-                type: 'base64'
-            },
-            type: 'image'
-        };
-    });
-    if (!blocks.some((block) => block.type === 'text')) {
-        blocks.unshift({ text: '(see attached media)', type: 'text' });
-    }
-    return blocks.length > 0 ? blocks : [{ text: '', type: 'text' }];
-}
-function aiAssistantContentToAnthropic(content) {
-    return content
-        .map((block) => {
-        if (block.type === 'text') {
-            const text = block.text;
-            return text.trim().length > 0 ? { text, type: 'text' } : undefined;
-        }
-        if (block.type === 'toolCall') {
-            const toolCall = block;
-            return {
-                id: toolCall.id,
-                input: toolCall.arguments,
-                name: toolCall.name,
-                type: 'tool_use'
-            };
-        }
-        return undefined;
-    })
-        .filter((block) => block !== undefined);
-}
-function getAnthropicCacheControl(baseUrl, cacheRetention) {
-    const retention = cacheRetention ??
-        (typeof process !== 'undefined' && process.env.PI_CACHE_RETENTION === 'long'
-            ? 'long'
-            : 'short');
-    if (retention === 'none')
-        return undefined;
-    return {
-        type: 'ephemeral',
-        ...(retention === 'long' && normalizeBaseUrl(baseUrl).includes('api.anthropic.com')
-            ? { ttl: '1h' }
-            : {})
-    };
-}
-function buildInvokeRequestBody(request, baseUrl) {
-    const messages = [];
-    for (let i = 0; i < request.context.messages.length; i += 1) {
-        const message = request.context.messages[i];
-        if (message.role === 'user') {
-            const content = aiUserContentToAnthropicContent(message.content, request.model.input);
-            if (typeof content === 'string' && content.trim().length === 0)
-                continue;
-            if (Array.isArray(content) && content.length === 0)
-                continue;
-            messages.push({
-                content,
-                role: 'user'
-            });
-            continue;
-        }
-        if (message.role === 'assistant') {
-            const content = aiAssistantContentToAnthropic(message.content);
-            if (content.length > 0) {
-                messages.push({ content, role: 'assistant' });
-            }
-            continue;
-        }
-        const toolResults = [
-            {
-                content: aiToolResultContentToAnthropic(message.content),
-                is_error: message.isError,
-                tool_use_id: message.toolCallId,
-                type: 'tool_result'
-            }
-        ];
-        let nextIndex = i + 1;
-        while (nextIndex < request.context.messages.length &&
-            request.context.messages[nextIndex]?.role === 'toolResult') {
-            const nextMessage = request.context.messages[nextIndex];
-            toolResults.push({
-                content: aiToolResultContentToAnthropic(nextMessage.content),
-                is_error: nextMessage.isError,
-                tool_use_id: nextMessage.toolCallId,
-                type: 'tool_result'
-            });
-            nextIndex += 1;
-        }
-        i = nextIndex - 1;
-        messages.push({
-            content: toolResults,
-            role: 'user'
-        });
-    }
-    const cacheControl = getAnthropicCacheControl(baseUrl, request.options?.cacheRetention);
-    if (cacheControl && messages.length > 0) {
-        const lastMessage = messages[messages.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;
-                }
-            }
-            else if (typeof lastMessage.content === 'string') {
-                lastMessage.content = [
-                    {
-                        cache_control: cacheControl,
-                        text: lastMessage.content,
-                        type: 'text'
-                    }
-                ];
-            }
-        }
-    }
-    return withProviderFastModePayload({
-        max_tokens: request.options?.maxTokens ?? 4096,
-        messages,
-        model: request.model.id,
-        stream: false,
-        ...(request.context.systemPrompt
-            ? {
-                system: [
-                    {
-                        ...(cacheControl ? { cache_control: cacheControl } : {}),
-                        text: request.context.systemPrompt,
-                        type: 'text'
-                    }
-                ]
-            }
-            : {}),
-        ...(request.context.tools
-            ? {
-                tools: request.context.tools.map((tool) => ({
-                    description: tool.description,
-                    input_schema: {
-                        properties: 'properties' in tool.parameters && tool.parameters.properties
-                            ? tool.parameters.properties
-                            : {},
-                        required: 'required' in tool.parameters && Array.isArray(tool.parameters.required)
-                            ? tool.parameters.required
-                            : [],
-                        type: 'object'
-                    },
-                    name: tool.name
-                }))
-            }
-            : {}),
-        ...(typeof request.options?.toolChoice === 'object'
-            ? { tool_choice: request.options.toolChoice }
-            : typeof request.options?.toolChoice === 'string'
-                ? { tool_choice: { type: request.options.toolChoice } }
-                : {})
-    }, shortcutProviderFastModeFromRequest('anthropic', request));
-}
-function concreteHeaders(headers) {
-    const result = {};
-    for (const [key, value] of Object.entries(headers ?? {})) {
-        if (value !== null)
-            result[key] = value;
-    }
-    return result;
-}
 function parseInvokeResponse(data) {
     if (!data || typeof data !== 'object') {
         throwInvalidResponse('Anthropic Messages invoke response must be a JSON object.');
@@ -946,16 +228,21 @@ function parseInvokeResponse(data) {
 }
 export async function invokeAnthropicMessagesModel(request, options) {
     const fetchImpl = options.fetchImpl ?? fetch;
+    const model = createGatewayProviderModel(request, 'anthropic-messages', options.baseUrl);
+    const requestOptions = createGatewayProviderOptions(request, 'anthropic-messages', options, {
+        maxTokens: 4096,
+        signal: options.signal
+    });
+    const fastMode = shortcutProviderFastModeFromRequest('anthropic', request);
     let response;
     try {
-        response = await fetchImpl(`${normalizeBaseUrl(options.baseUrl)}/v1/messages`, {
-            body: JSON.stringify(buildInvokeRequestBody(request, options.baseUrl)),
-            headers: concreteHeaders(withProviderFastModeHeaders({
+        response = await fetchImpl(`${model.baseUrl}/v1/messages`, {
+            body: JSON.stringify(withProviderFastModePayload(buildAnthropicMessagesRequest(model, request.context, requestOptions, false), fastMode)),
+            headers: concreteProviderHeaders(withProviderFastModeHeaders({
                 'anthropic-version': '2023-06-01',
                 'content-type': 'application/json',
-                ...options.headers,
-                ...createAuthHeader(options.auth)
-            }, shortcutProviderFastModeFromRequest('anthropic', request))),
+                ...requestOptions.headers
+            }, fastMode)),
             method: 'POST',
             credentials: options.fetchOptions?.credentials,
             signal: options.signal
@@ -986,8 +273,10 @@ export async function invokeAnthropicMessagesModel(request, options) {
     return parsed;
 }
 export async function streamAiAnthropicMessagesModelRequest(request, options) {
-    const model = buildGatewayAiModel(request, options.baseUrl);
-    const stream = streamGatewayAiAnthropic(model, request, buildGatewayAiStreamOptions(request, options));
+    const model = createGatewayProviderModel(request, 'anthropic-messages', options.baseUrl);
+    const stream = streamSimpleAnthropic(model, request.context, createGatewayProviderOptions(request, 'anthropic-messages', options, {
+        signal: options.signal
+    }));
     let finalMessage;
     for await (const event of stream) {
         if (event.type === 'done') {
@@ -1011,56 +300,4 @@ export async function streamAiAnthropicMessagesModelRequest(request, options) {
         usage: toProviderUsageFromAi(result?.usage)
     });
 }
-export function createAnthropicMessagesModelStreamTransport(options) {
-    const fetchImpl = options.fetchImpl ?? fetch;
-    return {
-        kind: ShortcutXLModelCallTransportKind.AnthropicMessages,
-        async stream(call, streamOptions) {
-            const message = {
-                api: AnthropicRuntimeApi,
-                content: [],
-                model: call.payload.model,
-                provider: ShortcutXLModelCallTransportKind.AnthropicMessages,
-                role: 'assistant',
-                stopReason: ShortcutXLModelStreamStopReason.Stop,
-                timestamp: Date.now(),
-                usage: buildUsage(undefined)
-            };
-            let response;
-            try {
-                response = await fetchImpl(`${normalizeBaseUrl(options.baseUrl)}/v1/messages`, {
-                    body: JSON.stringify(buildRequestBody(call)),
-                    headers: {
-                        'anthropic-version': '2023-06-01',
-                        'content-type': 'application/json',
-                        ...concreteHeaders(options.headers),
-                        ...createAuthHeader(options.auth)
-                    },
-                    method: 'POST',
-                    credentials: options.fetchOptions?.credentials,
-                    signal: streamOptions.signal
-                });
-            }
-            catch (error) {
-                normalizeTransportFetchError(error, 'Anthropic Messages stream');
-            }
-            if (!response.ok) {
-                await throwTransportHttpError(response);
-            }
-            try {
-                await streamAnthropicMessagesResponse({
-                    callId: call.context.requestId,
-                    message,
-                    model: call.payload.model,
-                    onEvent: streamOptions.onEvent,
-                    response,
-                    usageStatusLogger: options.usageStatusLogger
-                });
-            }
-            catch (error) {
-                normalizeTransportStreamError(error, 'Anthropic Messages stream');
-            }
-        }
-    };
-}
 //# sourceMappingURL=anthropic-messages-transport.js.map