@assemble-dev/providers 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,562 @@
+import { z } from 'zod';
+import { JsonValue } from '@assemble-dev/shared-types/json';
+import { TokenUsage } from '@assemble-dev/shared-types/runs';
+import { AppError } from '@assemble-dev/shared-utils/errors';
+import * as _assemble_dev_shared_types from '@assemble-dev/shared-types';
+
+declare const ChatMessageRoleSchema: z.ZodEnum<{
+    system: "system";
+    user: "user";
+    assistant: "assistant";
+    tool: "tool";
+}>;
+type ChatMessageRole = z.infer<typeof ChatMessageRoleSchema>;
+declare const MessageContentBlockSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"text">;
+    text: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"image">;
+    mediaType: z.ZodString;
+    dataBase64: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"document">;
+    mediaType: z.ZodString;
+    dataBase64: z.ZodString;
+}, z.core.$strip>], "type">;
+type MessageContentBlock = z.infer<typeof MessageContentBlockSchema>;
+declare const ModelToolCallSchema: z.ZodObject<{
+    id: z.ZodString;
+    toolName: z.ZodString;
+    input: z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>;
+}, z.core.$strip>;
+type ModelToolCall = z.infer<typeof ModelToolCallSchema>;
+declare const ChatMessageSchema: z.ZodObject<{
+    role: z.ZodEnum<{
+        system: "system";
+        user: "user";
+        assistant: "assistant";
+        tool: "tool";
+    }>;
+    content: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"text">;
+        text: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"image">;
+        mediaType: z.ZodString;
+        dataBase64: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"document">;
+        mediaType: z.ZodString;
+        dataBase64: z.ZodString;
+    }, z.core.$strip>], "type">>]>;
+    toolName: z.ZodOptional<z.ZodString>;
+    toolCallId: z.ZodOptional<z.ZodString>;
+    toolCalls: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        toolName: z.ZodString;
+        input: z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+type ChatMessage = z.infer<typeof ChatMessageSchema>;
+type ModelToolDefinition = {
+    name: string;
+    description: string;
+    inputJsonSchema: JsonValue;
+};
+type ModelToolChoice = "auto" | "required" | "none" | {
+    toolName: string;
+};
+declare const ChatStopReasonSchema: z.ZodEnum<{
+    end_turn: "end_turn";
+    tool_use: "tool_use";
+    max_tokens: "max_tokens";
+    stop_sequence: "stop_sequence";
+}>;
+type ChatStopReason = z.infer<typeof ChatStopReasonSchema>;
+type ChatCompletionRequest = {
+    messages: ChatMessage[];
+    temperature?: number;
+    maxOutputTokens?: number;
+    tools?: ModelToolDefinition[];
+    toolChoice?: ModelToolChoice;
+    abortSignal?: AbortSignal;
+};
+type ChatCompletionResult = {
+    content: string;
+    tokenUsage: TokenUsage;
+    latencyMs: number;
+    toolCalls?: ModelToolCall[];
+    stopReason?: ChatStopReason;
+};
+type ChatStreamEvent = {
+    type: "text_delta";
+    text: string;
+} | {
+    type: "tool_call_started";
+    id: string;
+    toolName: string;
+} | {
+    type: "tool_call_input_delta";
+    id: string;
+    inputJsonText: string;
+} | {
+    type: "completed";
+    result: ChatCompletionResult;
+};
+type StructuredOutputRequest<T> = {
+    messages: ChatMessage[];
+    schema: z.ZodType<T>;
+    temperature?: number;
+    maxOutputTokens?: number;
+    abortSignal?: AbortSignal;
+};
+type StructuredOutputResult<T> = {
+    value: T;
+    tokenUsage: TokenUsage;
+    latencyMs: number;
+};
+type ModelAdapter = {
+    name: string;
+    generateChatCompletion(request: ChatCompletionRequest): Promise<ChatCompletionResult>;
+    generateStructuredOutput<T>(request: StructuredOutputRequest<T>): Promise<StructuredOutputResult<T>>;
+    streamChatCompletion?(request: ChatCompletionRequest): AsyncIterable<ChatStreamEvent>;
+};
+declare function extractMessageText(message: ChatMessage): string;
+
+declare const defaultProviderRetryMaxAttempts = 3;
+declare const defaultProviderRetryInitialDelayMs = 500;
+declare const defaultProviderRetryMaxDelayMs = 8000;
+type ProviderRetryOptions = {
+    maxAttempts?: number;
+    initialDelayMs?: number;
+    maxDelayMs?: number;
+};
+declare function isRetryableProviderAppError(appError: AppError): boolean;
+declare function executeProviderCallWithRetry<T>(retryOptions: ProviderRetryOptions | undefined, executeCall: () => Promise<T>, waitFor?: (ms: number) => Promise<void>): Promise<T>;
+declare function calculateProviderRetryDelayMs(retryOptions: ProviderRetryOptions, attemptNumber: number): number;
+
+declare const defaultOpenAiBaseUrl = "https://api.openai.com/v1";
+type OpenAiAdapterOptions = {
+    model: string;
+    baseURL?: string;
+    apiKey?: string;
+    apiKeyName?: string;
+    fetchImplementation?: typeof fetch;
+    temperature?: number;
+    maxOutputTokens?: number;
+    retry?: ProviderRetryOptions;
+    fallbackModel?: string;
+};
+declare function openai(options: OpenAiAdapterOptions): ModelAdapter;
+
+type AnthropicPromptCachingMode = "auto" | "off";
+type AnthropicThinkingOptions = {
+    budgetTokens: number;
+};
+type AnthropicCacheControl = {
+    type: "ephemeral";
+};
+type AnthropicRequestContentBlock = {
+    type: "text";
+    text: string;
+} | {
+    type: "image";
+    source: {
+        type: "base64";
+        media_type: string;
+        data: string;
+    };
+} | {
+    type: "document";
+    source: {
+        type: "base64";
+        media_type: string;
+        data: string;
+    };
+} | {
+    type: "tool_use";
+    id: string;
+    name: string;
+    input: JsonValue;
+} | {
+    type: "tool_result";
+    tool_use_id: string;
+    content: string;
+};
+type AnthropicRequestMessage = {
+    role: "user" | "assistant";
+    content: string | AnthropicRequestContentBlock[];
+};
+type AnthropicSystemContentBlock = {
+    type: "text";
+    text: string;
+    cache_control?: AnthropicCacheControl;
+};
+type AnthropicToolDefinition = {
+    name: string;
+    description: string;
+    input_schema: JsonValue;
+    cache_control?: AnthropicCacheControl;
+};
+type AnthropicToolChoice = {
+    type: "auto";
+} | {
+    type: "any";
+} | {
+    type: "none";
+} | {
+    type: "tool";
+    name: string;
+};
+type AnthropicRequestBody = {
+    model: string;
+    max_tokens: number;
+    messages: AnthropicRequestMessage[];
+    system?: string | AnthropicSystemContentBlock[];
+    temperature?: number;
+    thinking?: {
+        type: "enabled";
+        budget_tokens: number;
+    };
+    tools?: AnthropicToolDefinition[];
+    tool_choice?: AnthropicToolChoice;
+    stream?: true;
+};
+type AnthropicRequestInput = {
+    messages: ChatMessage[];
+    temperature?: number;
+    maxOutputTokens?: number;
+    tools?: ModelToolDefinition[];
+    toolChoice?: ModelToolChoice;
+    abortSignal?: AbortSignal;
+};
+type AnthropicRequestSettings = {
+    model: string;
+    defaultMaxOutputTokens: number;
+    promptCaching?: AnthropicPromptCachingMode;
+    thinking?: AnthropicThinkingOptions;
+};
+declare function buildAnthropicRequestBody(settings: AnthropicRequestSettings, input: AnthropicRequestInput): AnthropicRequestBody;
+declare function mapModelToolDefinitionsToAnthropicTools(tools: ModelToolDefinition[], promptCaching: AnthropicPromptCachingMode | undefined): AnthropicToolDefinition[];
+declare function mapModelToolChoiceToAnthropicToolChoice(toolChoice: ModelToolChoice): AnthropicToolChoice;
+declare function joinSystemMessageText(messages: ChatMessage[]): string;
+declare function mapChatMessageToAnthropicRequestMessage(message: ChatMessage): AnthropicRequestMessage;
+
+declare const defaultAnthropicBaseUrl = "https://api.anthropic.com";
+declare const defaultAnthropicMaxOutputTokens = 1024;
+
+type AnthropicAdapterOptions = {
+    model: string;
+    baseURL?: string;
+    apiKey?: string;
+    apiKeyName?: string;
+    fetchImplementation?: typeof fetch;
+    temperature?: number;
+    maxOutputTokens?: number;
+    promptCaching?: AnthropicPromptCachingMode;
+    thinking?: AnthropicThinkingOptions;
+    retry?: ProviderRetryOptions;
+    fallbackModel?: string;
+};
+declare function anthropic(options: AnthropicAdapterOptions): ModelAdapter;
+
+declare const defaultGeminiBaseUrl = "https://generativelanguage.googleapis.com";
+type GeminiAdapterOptions = {
+    model: string;
+    baseURL?: string;
+    apiKey?: string;
+    apiKeyName?: string;
+    fetchImplementation?: typeof fetch;
+    temperature?: number;
+    maxOutputTokens?: number;
+    retry?: ProviderRetryOptions;
+    fallbackModel?: string;
+};
+declare function gemini(options: GeminiAdapterOptions): ModelAdapter;
+
+type MockModelOptions = {
+    name?: string;
+    scriptedResponses?: string[];
+    respond?: (request: ChatCompletionRequest) => string;
+};
+declare function mockModel(options?: MockModelOptions): ModelAdapter;
+
+type ResolveProviderApiKeyInput = {
+    providerLabel: string;
+    adapterFunctionName: string;
+    baseEnvVarName: string;
+    apiKey?: string;
+    apiKeyName?: string;
+};
+declare function resolveProviderApiKey(input: ResolveProviderApiKeyInput): string;
+
+declare function executeProviderCallWithModelFallback<T>(fallbackModel: string | undefined, executePrimaryCall: () => Promise<T>, executeFallbackCall: (fallbackModelId: string) => Promise<T>): Promise<T>;
+
+type ModelPricingUsdPerMillionTokens = {
+    inputUsdPerMillionTokens: number;
+    outputUsdPerMillionTokens: number;
+    cacheWriteUsdPerMillionTokens?: number;
+    cacheReadUsdPerMillionTokens?: number;
+};
+declare function estimateModelCallCostUsd(modelName: string, tokenUsage: TokenUsage): number | null;
+
+declare function isAbortError(error: Error): boolean;
+declare function buildProviderCanceledError(providerLabel: string): AppError;
+declare function executeAbortableProviderFetch(providerLabel: string, performFetch: () => Promise<Response>): Promise<Response>;
+
+declare const AnthropicUsageSchema: z.ZodObject<{
+    input_tokens: z.ZodNumber;
+    output_tokens: z.ZodNumber;
+    cache_creation_input_tokens: z.ZodOptional<z.ZodNumber>;
+    cache_read_input_tokens: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+type AnthropicUsage = z.infer<typeof AnthropicUsageSchema>;
+declare const AnthropicMessagesResponseSchema: z.ZodObject<{
+    content: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"text">;
+        text: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"tool_use">;
+        id: z.ZodString;
+        name: z.ZodString;
+        input: z.ZodType<_assemble_dev_shared_types.JsonValue, unknown, z.core.$ZodTypeInternals<_assemble_dev_shared_types.JsonValue, unknown>>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"thinking">;
+        thinking: z.ZodOptional<z.ZodString>;
+        signature: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"redacted_thinking">;
+        data: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>], "type">>;
+    stop_reason: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    usage: z.ZodObject<{
+        input_tokens: z.ZodNumber;
+        output_tokens: z.ZodNumber;
+        cache_creation_input_tokens: z.ZodOptional<z.ZodNumber>;
+        cache_read_input_tokens: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+type AnthropicMessagesResponse = z.infer<typeof AnthropicMessagesResponseSchema>;
+declare function mapAnthropicResponseToChatCompletionResult(response: AnthropicMessagesResponse, latencyMs: number): ChatCompletionResult;
+declare function extractAnthropicToolCalls(response: AnthropicMessagesResponse): ModelToolCall[];
+declare function extractAnthropicTextContent(response: AnthropicMessagesResponse, allowEmptyText: boolean): string;
+declare function normalizeAnthropicStopReason(providerStopReason: string): ChatStopReason;
+declare function mapAnthropicUsageToTokenUsage(usage: AnthropicUsage): TokenUsage;
+
+type AnthropicStreamRequestInput = {
+    url: string;
+    headers: Record<string, string>;
+    body: AnthropicRequestBody;
+    fetchImplementation: typeof fetch;
+    retry?: ProviderRetryOptions;
+    abortSignal?: AbortSignal;
+};
+declare function streamAnthropicChatCompletion(input: AnthropicStreamRequestInput): AsyncGenerator<ChatStreamEvent, void, void>;
+declare function parseAnthropicStreamEvents(body: ReadableStream<Uint8Array>, startedAt: number, abortSignal: AbortSignal | undefined): AsyncGenerator<ChatStreamEvent, void, void>;
+declare function parseAnthropicToolInputJson(inputJsonText: string): JsonValue;
+
+declare const AnthropicStreamEventSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"message_start">;
+    message: z.ZodObject<{
+        usage: z.ZodObject<{
+            input_tokens: z.ZodNumber;
+            output_tokens: z.ZodOptional<z.ZodNumber>;
+            cache_creation_input_tokens: z.ZodOptional<z.ZodNumber>;
+            cache_read_input_tokens: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"content_block_start">;
+    index: z.ZodNumber;
+    content_block: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"text">;
+        text: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"tool_use">;
+        id: z.ZodString;
+        name: z.ZodString;
+    }, z.core.$strip>], "type">;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"content_block_delta">;
+    index: z.ZodNumber;
+    delta: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"text_delta">;
+        text: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"input_json_delta">;
+        partial_json: z.ZodString;
+    }, z.core.$strip>], "type">;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"content_block_stop">;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"message_delta">;
+    delta: z.ZodObject<{
+        stop_reason: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strip>;
+    usage: z.ZodOptional<z.ZodObject<{
+        output_tokens: z.ZodNumber;
+    }, z.core.$strip>>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"message_stop">;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"ping">;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"error">;
+    error: z.ZodObject<{
+        message: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>], "type">;
+type AnthropicStreamEvent = z.infer<typeof AnthropicStreamEventSchema>;
+type AnthropicStreamStartUsage = Extract<AnthropicStreamEvent, {
+    type: "message_start";
+}>["message"]["usage"];
+
+type OpenAiContentPart = {
+    type: "text";
+    text: string;
+} | {
+    type: "image_url";
+    image_url: {
+        url: string;
+    };
+};
+type OpenAiRequestToolCall = {
+    id: string;
+    type: "function";
+    function: {
+        name: string;
+        arguments: string;
+    };
+};
+type OpenAiRequestMessage = {
+    role: ChatMessage["role"];
+    content: string | OpenAiContentPart[] | null;
+    name?: string;
+    tool_call_id?: string;
+    tool_calls?: OpenAiRequestToolCall[];
+};
+type OpenAiToolDefinition = {
+    type: "function";
+    function: {
+        name: string;
+        description: string;
+        parameters: JsonValue;
+    };
+};
+type OpenAiToolChoice = "auto" | "required" | "none" | {
+    type: "function";
+    function: {
+        name: string;
+    };
+};
+type OpenAiRequestBody = {
+    model: string;
+    messages: OpenAiRequestMessage[];
+    temperature?: number;
+    max_tokens?: number;
+    response_format?: {
+        type: "json_object";
+    };
+    tools?: OpenAiToolDefinition[];
+    tool_choice?: OpenAiToolChoice;
+};
+type OpenAiCallInput = {
+    messages: ChatMessage[];
+    temperature?: number;
+    maxOutputTokens?: number;
+    requireJsonObjectResponse: boolean;
+    tools?: ModelToolDefinition[];
+    toolChoice?: ModelToolChoice;
+    abortSignal?: AbortSignal;
+};
+declare function buildOpenAiRequestBody(model: string, input: OpenAiCallInput): OpenAiRequestBody;
+declare function mapModelToolDefinitionToOpenAiTool(tool: ModelToolDefinition): OpenAiToolDefinition;
+declare function mapModelToolChoiceToOpenAiToolChoice(toolChoice: ModelToolChoice): OpenAiToolChoice;
+declare function mapChatMessageToOpenAiRequestMessage(message: ChatMessage): OpenAiRequestMessage;
+
+declare const AnthropicMessageBatchResponseSchema: z.ZodObject<{
+    id: z.ZodString;
+    processing_status: z.ZodEnum<{
+        in_progress: "in_progress";
+        canceling: "canceling";
+        ended: "ended";
+    }>;
+    request_counts: z.ZodObject<{
+        processing: z.ZodNumber;
+        succeeded: z.ZodNumber;
+        errored: z.ZodNumber;
+        canceled: z.ZodNumber;
+        expired: z.ZodNumber;
+    }, z.core.$strip>;
+    results_url: z.ZodNullable<z.ZodString>;
+    created_at: z.ZodString;
+    ended_at: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+type AnthropicMessageBatchResponse = z.infer<typeof AnthropicMessageBatchResponseSchema>;
+type AnthropicMessageBatchProcessingStatus = AnthropicMessageBatchResponse["processing_status"];
+type AnthropicMessageBatchRequestCounts = {
+    processing: number;
+    succeeded: number;
+    errored: number;
+    canceled: number;
+    expired: number;
+};
+type AnthropicMessageBatch = {
+    id: string;
+    processingStatus: AnthropicMessageBatchProcessingStatus;
+    requestCounts: AnthropicMessageBatchRequestCounts;
+    resultsUrl: string | null;
+    createdAt: string;
+    endedAt: string | null;
+};
+type AnthropicBatchSucceededOutcome = {
+    type: "succeeded";
+    content: string;
+    tokenUsage: TokenUsage;
+};
+type AnthropicBatchErroredOutcome = {
+    type: "errored";
+    errorType: string;
+    errorMessage: string;
+};
+type AnthropicBatchCanceledOutcome = {
+    type: "canceled";
+};
+type AnthropicBatchExpiredOutcome = {
+    type: "expired";
+};
+type AnthropicBatchResultOutcome = AnthropicBatchSucceededOutcome | AnthropicBatchErroredOutcome | AnthropicBatchCanceledOutcome | AnthropicBatchExpiredOutcome;
+type AnthropicBatchResult = {
+    customId: string;
+    outcome: AnthropicBatchResultOutcome;
+};
+
+declare const defaultAnthropicBatchPollIntervalMs = 5000;
+declare const defaultAnthropicBatchTimeoutMs = 3600000;
+type AnthropicBatchClientOptions = {
+    apiKey?: string;
+    apiKeyName?: string;
+    baseURL?: string;
+    fetchImplementation?: typeof fetch;
+};
+type AnthropicBatchMessageRequest = {
+    customId: string;
+    model: string;
+    messages: ChatMessage[];
+    maxOutputTokens?: number;
+    temperature?: number;
+};
+type AnthropicBatchWaitOptions = {
+    pollIntervalMs?: number;
+    timeoutMs?: number;
+    waitFor?: (ms: number) => Promise<void>;
+};
+type AnthropicBatchClient = {
+    submitMessageBatch(requests: AnthropicBatchMessageRequest[]): Promise<AnthropicMessageBatch>;
+    fetchMessageBatch(batchId: string): Promise<AnthropicMessageBatch>;
+    listMessageBatchResults(batchId: string): Promise<AnthropicBatchResult[]>;
+    waitForMessageBatchCompletion(batchId: string, waitOptions?: AnthropicBatchWaitOptions): Promise<AnthropicMessageBatch>;
+};
+declare function createAnthropicBatchClient(options: AnthropicBatchClientOptions): AnthropicBatchClient;
+
+export { type AnthropicAdapterOptions, type AnthropicBatchCanceledOutcome, type AnthropicBatchClient, type AnthropicBatchClientOptions, type AnthropicBatchErroredOutcome, type AnthropicBatchExpiredOutcome, type AnthropicBatchMessageRequest, type AnthropicBatchResult, type AnthropicBatchResultOutcome, type AnthropicBatchSucceededOutcome, type AnthropicBatchWaitOptions, type AnthropicMessageBatch, type AnthropicMessageBatchProcessingStatus, type AnthropicMessageBatchRequestCounts, type AnthropicMessagesResponse, AnthropicMessagesResponseSchema, type AnthropicPromptCachingMode, type AnthropicRequestBody, type AnthropicRequestContentBlock, type AnthropicRequestInput, type AnthropicRequestMessage, type AnthropicRequestSettings, type AnthropicStreamEvent, AnthropicStreamEventSchema, type AnthropicStreamRequestInput, type AnthropicStreamStartUsage, type AnthropicSystemContentBlock, type AnthropicThinkingOptions, type AnthropicToolChoice, type AnthropicToolDefinition, type AnthropicUsage, type ChatCompletionRequest, type ChatCompletionResult, type ChatMessage, type ChatMessageRole, ChatMessageRoleSchema, ChatMessageSchema, type ChatStopReason, ChatStopReasonSchema, type ChatStreamEvent, type GeminiAdapterOptions, type MessageContentBlock, MessageContentBlockSchema, type MockModelOptions, type ModelAdapter, type ModelPricingUsdPerMillionTokens, type ModelToolCall, ModelToolCallSchema, type ModelToolChoice, type ModelToolDefinition, type OpenAiAdapterOptions, type OpenAiCallInput, type OpenAiContentPart, type OpenAiRequestBody, type OpenAiRequestMessage, type OpenAiRequestToolCall, type OpenAiToolChoice, type OpenAiToolDefinition, type ProviderRetryOptions, type ResolveProviderApiKeyInput, type StructuredOutputRequest, type StructuredOutputResult, anthropic, buildAnthropicRequestBody, buildOpenAiRequestBody, buildProviderCanceledError, calculateProviderRetryDelayMs, createAnthropicBatchClient, defaultAnthropicBaseUrl, defaultAnthropicBatchPollIntervalMs, defaultAnthropicBatchTimeoutMs, defaultAnthropicMaxOutputTokens, defaultGeminiBaseUrl, defaultOpenAiBaseUrl, defaultProviderRetryInitialDelayMs, defaultProviderRetryMaxAttempts, defaultProviderRetryMaxDelayMs, estimateModelCallCostUsd, executeAbortableProviderFetch, executeProviderCallWithModelFallback, executeProviderCallWithRetry, extractAnthropicTextContent, extractAnthropicToolCalls, extractMessageText, gemini, isAbortError, isRetryableProviderAppError, joinSystemMessageText, mapAnthropicResponseToChatCompletionResult, mapAnthropicUsageToTokenUsage, mapChatMessageToAnthropicRequestMessage, mapChatMessageToOpenAiRequestMessage, mapModelToolChoiceToAnthropicToolChoice, mapModelToolChoiceToOpenAiToolChoice, mapModelToolDefinitionToOpenAiTool, mapModelToolDefinitionsToAnthropicTools, mockModel, normalizeAnthropicStopReason, openai, parseAnthropicStreamEvents, parseAnthropicToolInputJson, resolveProviderApiKey, streamAnthropicChatCompletion };