@assemble-dev/providers 0.1.0 → 0.3.0

package/dist/index.d.cts

@@ -1,8 +1,11 @@
 import { z } from 'zod';
-import { JsonValue } from '@assemble-dev/shared-types/json';
+import { JsonValue, JsonObject } 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';
+import { RunMetadata } from '@assemble-dev/shared-types/run-metadata';
+import { TraceEvent } from '@assemble-dev/shared-types/trace-events';
+import { ValidationSchema } from '@assemble-dev/shared-types/validation';
 
 declare const ChatMessageRoleSchema: z.ZodEnum<{
     system: "system";
@@ -30,6 +33,13 @@ declare const ModelToolCallSchema: z.ZodObject<{
     input: z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>;
 }, z.core.$strip>;
 type ModelToolCall = z.infer<typeof ModelToolCallSchema>;
+declare const ChatMessageCacheControlSchema: z.ZodObject<{
+    ttl: z.ZodOptional<z.ZodEnum<{
+        "5m": "5m";
+        "1h": "1h";
+    }>>;
+}, z.core.$strip>;
+type ChatMessageCacheControl = z.infer<typeof ChatMessageCacheControlSchema>;
 declare const ChatMessageSchema: z.ZodObject<{
     role: z.ZodEnum<{
         system: "system";
@@ -56,6 +66,12 @@ declare const ChatMessageSchema: z.ZodObject<{
         toolName: z.ZodString;
         input: z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>;
     }, z.core.$strip>>>;
+    cacheControl: z.ZodOptional<z.ZodObject<{
+        ttl: z.ZodOptional<z.ZodEnum<{
+            "5m": "5m";
+            "1h": "1h";
+        }>>;
+    }, z.core.$strip>>;
 }, z.core.$strip>;
 type ChatMessage = z.infer<typeof ChatMessageSchema>;
 type ModelToolDefinition = {
@@ -80,6 +96,7 @@ type ChatCompletionRequest = {
     tools?: ModelToolDefinition[];
     toolChoice?: ModelToolChoice;
     abortSignal?: AbortSignal;
+    extraBody?: Record<string, JsonValue>;
 };
 type ChatCompletionResult = {
     content: string;
@@ -87,10 +104,14 @@ type ChatCompletionResult = {
     latencyMs: number;
     toolCalls?: ModelToolCall[];
     stopReason?: ChatStopReason;
+    thinkingText?: string;
 };
 type ChatStreamEvent = {
     type: "text_delta";
     text: string;
+} | {
+    type: "thinking_delta";
+    text: string;
 } | {
     type: "tool_call_started";
     id: string;
@@ -146,19 +167,17 @@ type OpenAiAdapterOptions = {
     maxOutputTokens?: number;
     retry?: ProviderRetryOptions;
     fallbackModel?: string;
+    extraBody?: Record<string, JsonValue>;
 };
 declare function openai(options: OpenAiAdapterOptions): ModelAdapter;
 
-type AnthropicPromptCachingMode = "auto" | "off";
 type AnthropicThinkingOptions = {
     budgetTokens: number;
 };
-type AnthropicCacheControl = {
-    type: "ephemeral";
-};
 type AnthropicRequestContentBlock = {
     type: "text";
     text: string;
+    cache_control?: AnthropicCacheControl;
 } | {
     type: "image";
     source: {
@@ -166,6 +185,7 @@ type AnthropicRequestContentBlock = {
         media_type: string;
         data: string;
     };
+    cache_control?: AnthropicCacheControl;
 } | {
     type: "document";
     source: {
@@ -173,15 +193,18 @@ type AnthropicRequestContentBlock = {
         media_type: string;
         data: string;
     };
+    cache_control?: AnthropicCacheControl;
 } | {
     type: "tool_use";
     id: string;
     name: string;
     input: JsonValue;
+    cache_control?: AnthropicCacheControl;
 } | {
     type: "tool_result";
     tool_use_id: string;
     content: string;
+    cache_control?: AnthropicCacheControl;
 };
 type AnthropicRequestMessage = {
     role: "user" | "assistant";
@@ -208,6 +231,12 @@ type AnthropicToolChoice = {
     type: "tool";
     name: string;
 };
+type AnthropicOutputConfig = {
+    format: {
+        type: "json_schema";
+        schema: JsonObject;
+    };
+};
 type AnthropicRequestBody = {
     model: string;
     max_tokens: number;
@@ -220,6 +249,7 @@ type AnthropicRequestBody = {
     };
     tools?: AnthropicToolDefinition[];
     tool_choice?: AnthropicToolChoice;
+    output_config?: AnthropicOutputConfig;
     stream?: true;
 };
 type AnthropicRequestInput = {
@@ -228,20 +258,37 @@ type AnthropicRequestInput = {
     maxOutputTokens?: number;
     tools?: ModelToolDefinition[];
     toolChoice?: ModelToolChoice;
+    structuredOutputJsonSchema?: JsonObject;
     abortSignal?: AbortSignal;
+    extraBody?: Record<string, JsonValue>;
 };
 type AnthropicRequestSettings = {
     model: string;
     defaultMaxOutputTokens: number;
-    promptCaching?: AnthropicPromptCachingMode;
+    promptCaching?: AnthropicPromptCachingOptions;
     thinking?: AnthropicThinkingOptions;
 };
 declare function buildAnthropicRequestBody(settings: AnthropicRequestSettings, input: AnthropicRequestInput): AnthropicRequestBody;
-declare function mapModelToolDefinitionsToAnthropicTools(tools: ModelToolDefinition[], promptCaching: AnthropicPromptCachingMode | undefined): AnthropicToolDefinition[];
+declare function mapModelToolDefinitionsToAnthropicTools(tools: ModelToolDefinition[], promptCaching: AnthropicPromptCachingOptions | undefined): AnthropicToolDefinition[];
 declare function mapModelToolChoiceToAnthropicToolChoice(toolChoice: ModelToolChoice): AnthropicToolChoice;
 declare function joinSystemMessageText(messages: ChatMessage[]): string;
 declare function mapChatMessageToAnthropicRequestMessage(message: ChatMessage): AnthropicRequestMessage;
 
+type AnthropicPromptCachingMode = "auto" | "off";
+type AnthropicCacheTtl = "5m" | "1h";
+type AnthropicPromptCachingSettings = {
+    mode: "auto" | "messages" | "off";
+    ttl?: AnthropicCacheTtl;
+};
+type AnthropicPromptCachingOptions = AnthropicPromptCachingMode | AnthropicPromptCachingSettings;
+type AnthropicCacheControl = {
+    type: "ephemeral";
+    ttl?: AnthropicCacheTtl;
+};
+declare function resolveAnthropicPromptCachingSettings(promptCaching: AnthropicPromptCachingOptions | undefined): AnthropicPromptCachingSettings;
+declare function buildAnthropicCacheControl(ttl: AnthropicCacheTtl | undefined): AnthropicCacheControl;
+declare function applyCacheControlToLastContentBlock(requestMessage: AnthropicRequestMessage, cacheControl: AnthropicCacheControl): void;
+
 declare const defaultAnthropicBaseUrl = "https://api.anthropic.com";
 declare const defaultAnthropicMaxOutputTokens = 1024;
 
@@ -253,13 +300,17 @@ type AnthropicAdapterOptions = {
     fetchImplementation?: typeof fetch;
     temperature?: number;
     maxOutputTokens?: number;
-    promptCaching?: AnthropicPromptCachingMode;
+    promptCaching?: AnthropicPromptCachingOptions;
     thinking?: AnthropicThinkingOptions;
     retry?: ProviderRetryOptions;
     fallbackModel?: string;
+    extraBody?: Record<string, JsonValue>;
 };
 declare function anthropic(options: AnthropicAdapterOptions): ModelAdapter;
 
+type ProviderExtraBody = Record<string, JsonValue>;
+declare function mergeProviderRequestExtraBody<TRequestBody extends object>(requestBody: TRequestBody, adapterExtraBody: ProviderExtraBody | undefined, requestExtraBody: ProviderExtraBody | undefined): TRequestBody & ProviderExtraBody;
+
 declare const defaultGeminiBaseUrl = "https://generativelanguage.googleapis.com";
 type GeminiAdapterOptions = {
     model: string;
@@ -271,6 +322,7 @@ type GeminiAdapterOptions = {
     maxOutputTokens?: number;
     retry?: ProviderRetryOptions;
     fallbackModel?: string;
+    extraBody?: Record<string, JsonValue>;
 };
 declare function gemini(options: GeminiAdapterOptions): ModelAdapter;
 
@@ -304,6 +356,16 @@ declare function isAbortError(error: Error): boolean;
 declare function buildProviderCanceledError(providerLabel: string): AppError;
 declare function executeAbortableProviderFetch(providerLabel: string, performFetch: () => Promise<Response>): Promise<Response>;
 
+declare const openAiStructuredOutputSchemaName = "structured_output";
+declare function convertZodSchemaToJsonSchema<T>(schema: z.ZodType<T>): JsonObject;
+declare function buildAnthropicStructuredOutputJsonSchema<T>(schema: z.ZodType<T>): JsonObject;
+declare function sanitizeJsonSchemaForAnthropicStructuredOutput(jsonSchema: JsonObject): JsonObject;
+declare function buildOpenAiStructuredOutputJsonSchema<T>(schema: z.ZodType<T>): JsonObject;
+declare function sanitizeJsonSchemaForOpenAiStructuredOutput(jsonSchema: JsonObject): JsonObject;
+
+declare function buildGeminiResponseSchema<T>(schema: z.ZodType<T>): JsonObject;
+declare function sanitizeJsonSchemaForGeminiResponseSchema(jsonSchema: JsonObject): JsonObject;
+
 declare const AnthropicUsageSchema: z.ZodObject<{
     input_tokens: z.ZodNumber;
     output_tokens: z.ZodNumber;
@@ -339,6 +401,7 @@ declare const AnthropicMessagesResponseSchema: z.ZodObject<{
 type AnthropicMessagesResponse = z.infer<typeof AnthropicMessagesResponseSchema>;
 declare function mapAnthropicResponseToChatCompletionResult(response: AnthropicMessagesResponse, latencyMs: number): ChatCompletionResult;
 declare function extractAnthropicToolCalls(response: AnthropicMessagesResponse): ModelToolCall[];
+declare function extractAnthropicThinkingText(response: AnthropicMessagesResponse): string;
 declare function extractAnthropicTextContent(response: AnthropicMessagesResponse, allowEmptyText: boolean): string;
 declare function normalizeAnthropicStopReason(providerStopReason: string): ChatStopReason;
 declare function mapAnthropicUsageToTokenUsage(usage: AnthropicUsage): TokenUsage;
@@ -371,6 +434,12 @@ declare const AnthropicStreamEventSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     content_block: z.ZodDiscriminatedUnion<[z.ZodObject<{
         type: z.ZodLiteral<"text">;
         text: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"thinking">;
+        thinking: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"redacted_thinking">;
+        data: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>, z.ZodObject<{
         type: z.ZodLiteral<"tool_use">;
         id: z.ZodString;
@@ -382,6 +451,12 @@ declare const AnthropicStreamEventSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     delta: z.ZodDiscriminatedUnion<[z.ZodObject<{
         type: z.ZodLiteral<"text_delta">;
         text: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"thinking_delta">;
+        thinking: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"signature_delta">;
+        signature: z.ZodString;
     }, z.core.$strip>, z.ZodObject<{
         type: z.ZodLiteral<"input_json_delta">;
         partial_json: z.ZodString;
@@ -449,14 +524,22 @@ type OpenAiToolChoice = "auto" | "required" | "none" | {
         name: string;
     };
 };
+type OpenAiResponseFormat = {
+    type: "json_object";
+} | {
+    type: "json_schema";
+    json_schema: {
+        name: string;
+        strict: true;
+        schema: JsonObject;
+    };
+};
 type OpenAiRequestBody = {
     model: string;
     messages: OpenAiRequestMessage[];
     temperature?: number;
     max_tokens?: number;
-    response_format?: {
-        type: "json_object";
-    };
+    response_format?: OpenAiResponseFormat;
     tools?: OpenAiToolDefinition[];
     tool_choice?: OpenAiToolChoice;
 };
@@ -464,16 +547,53 @@ type OpenAiCallInput = {
     messages: ChatMessage[];
     temperature?: number;
     maxOutputTokens?: number;
-    requireJsonObjectResponse: boolean;
+    structuredOutputJsonSchema?: JsonObject;
+    requireJsonObjectResponse?: boolean;
     tools?: ModelToolDefinition[];
     toolChoice?: ModelToolChoice;
     abortSignal?: AbortSignal;
+    extraBody?: Record<string, JsonValue>;
 };
 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;
 
+type AnthropicBatchPromptCachingMode = "auto" | "off";
+type AnthropicBatchMessageRequest = {
+    customId: string;
+    model: string;
+    messages: ChatMessage[];
+    maxOutputTokens?: number;
+    temperature?: number;
+    promptCaching?: AnthropicBatchPromptCachingMode;
+    requireJsonResponse?: boolean;
+    structuredOutputJsonSchema?: JsonObject;
+};
+type AnthropicBatchApiRequestMessage = {
+    role: "user" | "assistant";
+    content: string;
+};
+type AnthropicBatchSystemContentBlock = {
+    type: "text";
+    text: string;
+    cache_control?: {
+        type: "ephemeral";
+    };
+};
+type AnthropicBatchApiRequestParams = {
+    model: string;
+    max_tokens: number;
+    messages: AnthropicBatchApiRequestMessage[];
+    system?: string | AnthropicBatchSystemContentBlock[];
+    temperature?: number;
+    output_config?: AnthropicOutputConfig;
+};
+type AnthropicBatchApiRequest = {
+    custom_id: string;
+    params: AnthropicBatchApiRequestParams;
+};
+
 declare const AnthropicMessageBatchResponseSchema: z.ZodObject<{
     id: z.ZodString;
     processing_status: z.ZodEnum<{
@@ -531,6 +651,13 @@ type AnthropicBatchResult = {
     outcome: AnthropicBatchResultOutcome;
 };
 
+declare const anthropicBatchTraceWorkflowName = "anthropic-message-batch";
+type AnthropicBatchTraceEventHandler = (traceEvent: TraceEvent) => void;
+type AnthropicBatchSubmittedRequestSummary = {
+    customId: string;
+    model: string;
+};
+
 declare const defaultAnthropicBatchPollIntervalMs = 5000;
 declare const defaultAnthropicBatchTimeoutMs = 3600000;
 type AnthropicBatchClientOptions = {
@@ -538,13 +665,8 @@ type AnthropicBatchClientOptions = {
     apiKeyName?: string;
     baseURL?: string;
     fetchImplementation?: typeof fetch;
-};
-type AnthropicBatchMessageRequest = {
-    customId: string;
-    model: string;
-    messages: ChatMessage[];
-    maxOutputTokens?: number;
-    temperature?: number;
+    onTraceEvent?: AnthropicBatchTraceEventHandler;
+    metadata?: RunMetadata;
 };
 type AnthropicBatchWaitOptions = {
     pollIntervalMs?: number;
@@ -559,4 +681,114 @@ type AnthropicBatchClient = {
 };
 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 };
+declare const anthropicBatchJsonOnlySystemInstruction = "Respond with a single JSON object that satisfies the caller's requested structure. Output only valid JSON with no surrounding text.";
+declare function parseAnthropicBatchStructuredContent<T>(content: string, schema: ValidationSchema<T>): T;
+
+declare const defaultAzureOpenAiApiVersion = "2024-10-21";
+type AzureOpenAiAdapterOptions = {
+    deployment: string;
+    resourceName?: string;
+    baseURL?: string;
+    apiVersion?: string;
+    apiKey?: string;
+    apiKeyName?: string;
+    fetchImplementation?: typeof fetch;
+    temperature?: number;
+    maxOutputTokens?: number;
+    retry?: ProviderRetryOptions;
+    extraBody?: Record<string, JsonValue>;
+};
+type AzureOpenAiChatRequestBody = Omit<OpenAiRequestBody, "model">;
+declare function azureOpenai(options: AzureOpenAiAdapterOptions): ModelAdapter;
+declare function buildAzureOpenAiChatCompletionsUrl(options: AzureOpenAiAdapterOptions): string;
+declare function buildAzureOpenAiChatRequestBody(input: OpenAiCallInput): AzureOpenAiChatRequestBody;
+
+declare const AzureOpenAiUsageSchema: z.ZodObject<{
+    prompt_tokens: z.ZodNumber;
+    completion_tokens: z.ZodNumber;
+    total_tokens: z.ZodNumber;
+}, z.core.$strip>;
+type AzureOpenAiUsage = z.infer<typeof AzureOpenAiUsageSchema>;
+declare const AzureOpenAiChatCompletionResponseSchema: z.ZodObject<{
+    choices: z.ZodArray<z.ZodObject<{
+        message: z.ZodObject<{
+            content: z.ZodNullable<z.ZodString>;
+            tool_calls: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                function: z.ZodObject<{
+                    name: z.ZodString;
+                    arguments: z.ZodString;
+                }, z.core.$strip>;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>;
+        finish_reason: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strip>>;
+    usage: z.ZodObject<{
+        prompt_tokens: z.ZodNumber;
+        completion_tokens: z.ZodNumber;
+        total_tokens: z.ZodNumber;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+type AzureOpenAiChatCompletionResponse = z.infer<typeof AzureOpenAiChatCompletionResponseSchema>;
+declare function mapAzureOpenAiResponseToChatCompletionResult(response: AzureOpenAiChatCompletionResponse, latencyMs: number): ChatCompletionResult;
+declare function parseAzureOpenAiToolArgumentsJson(argumentsJsonText: string): JsonValue;
+declare function normalizeAzureOpenAiFinishReason(finishReason: string): ChatStopReason;
+declare function mapAzureOpenAiUsageToTokenUsage(usage: AzureOpenAiUsage): TokenUsage;
+
+type AzureOpenAiStreamRequestBody = Omit<OpenAiRequestBody, "model"> & {
+    stream: true;
+    stream_options: {
+        include_usage: boolean;
+    };
+};
+type AzureOpenAiStreamRequestInput = {
+    url: string;
+    headers: Record<string, string>;
+    body: AzureOpenAiStreamRequestBody;
+    fetchImplementation: typeof fetch;
+    retry?: ProviderRetryOptions;
+    abortSignal?: AbortSignal;
+};
+declare function streamAzureOpenAiChatCompletion(input: AzureOpenAiStreamRequestInput): AsyncGenerator<ChatStreamEvent, void, void>;
+declare function parseAzureOpenAiStreamEvents(body: ReadableStream<Uint8Array>, startedAt: number, abortSignal: AbortSignal | undefined): AsyncGenerator<ChatStreamEvent, void, void>;
+
+declare const awsSigV4Algorithm = "AWS4-HMAC-SHA256";
+type AwsCredentials = {
+    accessKeyId: string;
+    secretAccessKey: string;
+    sessionToken?: string;
+};
+type AwsSigV4SigningInput = {
+    method: string;
+    url: URL;
+    headers: Record<string, string>;
+    bodyText: string;
+    region: string;
+    service: string;
+    credentials: AwsCredentials;
+    signingDate?: Date;
+};
+declare function signAwsRequestWithSigV4(input: AwsSigV4SigningInput): Promise<Record<string, string>>;
+
+declare const bedrockAnthropicVersion = "bedrock-2023-05-31";
+declare const defaultBedrockMaxOutputTokens = 1024;
+type BedrockCredentials = AwsCredentials;
+type BedrockAdapterOptions = {
+    region: string;
+    modelId: string;
+    credentials?: BedrockCredentials;
+    fetchImplementation?: typeof fetch;
+    temperature?: number;
+    maxOutputTokens?: number;
+    retry?: ProviderRetryOptions;
+    extraBody?: Record<string, JsonValue>;
+};
+type BedrockInvokeModelRequestBody = Omit<AnthropicRequestBody, "model" | "stream"> & {
+    anthropic_version: string;
+};
+declare function bedrock(options: BedrockAdapterOptions): ModelAdapter;
+declare function buildBedrockInvokeModelUrl(region: string, modelId: string): string;
+declare function resolveBedrockCredentials(options: BedrockAdapterOptions): BedrockCredentials;
+declare function buildBedrockInvokeModelRequestBody(input: AnthropicRequestInput): BedrockInvokeModelRequestBody;
+
+export { type AnthropicAdapterOptions, type AnthropicBatchApiRequest, type AnthropicBatchApiRequestMessage, type AnthropicBatchApiRequestParams, type AnthropicBatchCanceledOutcome, type AnthropicBatchClient, type AnthropicBatchClientOptions, type AnthropicBatchErroredOutcome, type AnthropicBatchExpiredOutcome, type AnthropicBatchMessageRequest, type AnthropicBatchPromptCachingMode, type AnthropicBatchResult, type AnthropicBatchResultOutcome, type AnthropicBatchSubmittedRequestSummary, type AnthropicBatchSucceededOutcome, type AnthropicBatchSystemContentBlock, type AnthropicBatchTraceEventHandler, type AnthropicBatchWaitOptions, type AnthropicCacheControl, type AnthropicCacheTtl, type AnthropicMessageBatch, type AnthropicMessageBatchProcessingStatus, type AnthropicMessageBatchRequestCounts, type AnthropicMessagesResponse, AnthropicMessagesResponseSchema, type AnthropicOutputConfig, type AnthropicPromptCachingMode, type AnthropicPromptCachingOptions, type AnthropicPromptCachingSettings, 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 AwsCredentials, type AwsSigV4SigningInput, type AzureOpenAiAdapterOptions, type AzureOpenAiChatCompletionResponse, AzureOpenAiChatCompletionResponseSchema, type AzureOpenAiChatRequestBody, type AzureOpenAiStreamRequestBody, type AzureOpenAiStreamRequestInput, type AzureOpenAiUsage, type BedrockAdapterOptions, type BedrockCredentials, type BedrockInvokeModelRequestBody, type ChatCompletionRequest, type ChatCompletionResult, type ChatMessage, type ChatMessageCacheControl, ChatMessageCacheControlSchema, 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 OpenAiResponseFormat, type OpenAiToolChoice, type OpenAiToolDefinition, type ProviderExtraBody, type ProviderRetryOptions, type ResolveProviderApiKeyInput, type StructuredOutputRequest, type StructuredOutputResult, anthropic, anthropicBatchJsonOnlySystemInstruction, anthropicBatchTraceWorkflowName, applyCacheControlToLastContentBlock, awsSigV4Algorithm, azureOpenai, bedrock, bedrockAnthropicVersion, buildAnthropicCacheControl, buildAnthropicRequestBody, buildAnthropicStructuredOutputJsonSchema, buildAzureOpenAiChatCompletionsUrl, buildAzureOpenAiChatRequestBody, buildBedrockInvokeModelRequestBody, buildBedrockInvokeModelUrl, buildGeminiResponseSchema, buildOpenAiRequestBody, buildOpenAiStructuredOutputJsonSchema, buildProviderCanceledError, calculateProviderRetryDelayMs, convertZodSchemaToJsonSchema, createAnthropicBatchClient, defaultAnthropicBaseUrl, defaultAnthropicBatchPollIntervalMs, defaultAnthropicBatchTimeoutMs, defaultAnthropicMaxOutputTokens, defaultAzureOpenAiApiVersion, defaultBedrockMaxOutputTokens, defaultGeminiBaseUrl, defaultOpenAiBaseUrl, defaultProviderRetryInitialDelayMs, defaultProviderRetryMaxAttempts, defaultProviderRetryMaxDelayMs, estimateModelCallCostUsd, executeAbortableProviderFetch, executeProviderCallWithModelFallback, executeProviderCallWithRetry, extractAnthropicTextContent, extractAnthropicThinkingText, extractAnthropicToolCalls, extractMessageText, gemini, isAbortError, isRetryableProviderAppError, joinSystemMessageText, mapAnthropicResponseToChatCompletionResult, mapAnthropicUsageToTokenUsage, mapAzureOpenAiResponseToChatCompletionResult, mapAzureOpenAiUsageToTokenUsage, mapChatMessageToAnthropicRequestMessage, mapChatMessageToOpenAiRequestMessage, mapModelToolChoiceToAnthropicToolChoice, mapModelToolChoiceToOpenAiToolChoice, mapModelToolDefinitionToOpenAiTool, mapModelToolDefinitionsToAnthropicTools, mergeProviderRequestExtraBody, mockModel, normalizeAnthropicStopReason, normalizeAzureOpenAiFinishReason, openAiStructuredOutputSchemaName, openai, parseAnthropicBatchStructuredContent, parseAnthropicStreamEvents, parseAnthropicToolInputJson, parseAzureOpenAiStreamEvents, parseAzureOpenAiToolArgumentsJson, resolveAnthropicPromptCachingSettings, resolveBedrockCredentials, resolveProviderApiKey, sanitizeJsonSchemaForAnthropicStructuredOutput, sanitizeJsonSchemaForGeminiResponseSchema, sanitizeJsonSchemaForOpenAiStructuredOutput, signAwsRequestWithSigV4, streamAnthropicChatCompletion, streamAzureOpenAiChatCompletion };