@aryee337/aery-ai 0.1.148 → 0.2.10

package/dist/types/providers/anthropic-wire.d.ts

@@ -0,0 +1,262 @@
+/**
+ * Anthropic Messages API wire types.
+ *
+ * Hand-maintained against https://docs.anthropic.com/en/api/messages so aery-ai
+ * does not depend on `@anthropic-ai/sdk` for type information. Only the shapes
+ * this package actually reads or writes are modeled; fields we never touch are
+ * intentionally omitted. Names mirror the SDK so call sites read the same.
+ *
+ * Unlike the SDK, beta fields aery-ai uses (`speed`, `context_management`,
+ * `output_config.effort`/`task_budget`, `thinking.display`, cache-control
+ * `scope`, tool `strict`/`eager_input_streaming`, mid-conversation `system`
+ * role) are first-class here instead of being patched in via casts.
+ */
+import type { TokenTaskBudget } from "../types";
+/** Ephemeral prefix-cache breakpoint marker. */
+export type CacheControlEphemeral = {
+    type: "ephemeral";
+    ttl?: "1h" | "5m";
+    /** Claude Code prompt-caching-scope beta: shares the breakpoint across sessions. */
+    scope?: "global";
+};
+export type Base64ImageSource = {
+    type: "base64";
+    media_type: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
+    data: string;
+};
+export type URLImageSource = {
+    type: "url";
+    url: string;
+};
+export type FileImageSource = {
+    type: "file";
+    file_id: string;
+};
+export type ImageSource = Base64ImageSource | URLImageSource | FileImageSource;
+export type TextBlockParam = {
+    type: "text";
+    text: string;
+    cache_control?: CacheControlEphemeral | null;
+};
+export type ImageBlockParam = {
+    type: "image";
+    source: ImageSource;
+    cache_control?: CacheControlEphemeral | null;
+};
+export type ToolUseBlockParam = {
+    type: "tool_use";
+    id: string;
+    name: string;
+    input: unknown;
+    cache_control?: CacheControlEphemeral | null;
+};
+export type ToolResultBlockParam = {
+    type: "tool_result";
+    tool_use_id: string;
+    content?: string | Array<TextBlockParam | ImageBlockParam>;
+    is_error?: boolean;
+    cache_control?: CacheControlEphemeral | null;
+};
+export type ThinkingBlockParam = {
+    type: "thinking";
+    thinking: string;
+    signature: string;
+};
+export type RedactedThinkingBlockParam = {
+    type: "redacted_thinking";
+    data: string;
+};
+export type ContentBlockParam = TextBlockParam | ImageBlockParam | ToolUseBlockParam | ToolResultBlockParam | ThinkingBlockParam | RedactedThinkingBlockParam;
+/**
+ * A single conversation turn.
+ *
+ * `system` is the Opus 4.8+ mid-conversation system role
+ * (`mid-conversation-system-2026-04-07` beta); the public API otherwise only
+ * accepts `user` / `assistant`.
+ */
+export type MessageParam = {
+    role: "user" | "assistant" | "system";
+    content: string | ContentBlockParam[];
+};
+export type ToolInputSchema = {
+    type: "object";
+    properties?: unknown | null;
+    required?: string[] | null;
+    [k: string]: unknown;
+};
+export type Tool = {
+    name: string;
+    description?: string;
+    input_schema: ToolInputSchema;
+    cache_control?: CacheControlEphemeral | null;
+    /** Structured-outputs beta: enforce the schema as a strict grammar. */
+    strict?: boolean;
+    /** Fine-grained tool streaming beta: stream tool input as it is generated. */
+    eager_input_streaming?: boolean;
+};
+export type ToolChoiceAuto = {
+    type: "auto";
+    disable_parallel_tool_use?: boolean;
+};
+export type ToolChoiceAny = {
+    type: "any";
+    disable_parallel_tool_use?: boolean;
+};
+export type ToolChoiceTool = {
+    type: "tool";
+    name: string;
+    disable_parallel_tool_use?: boolean;
+};
+export type ToolChoiceNone = {
+    type: "none";
+};
+export type ToolChoice = ToolChoiceAuto | ToolChoiceAny | ToolChoiceTool | ToolChoiceNone;
+export type Metadata = {
+    user_id?: string | null;
+};
+export type ThinkingConfigEnabled = {
+    type: "enabled";
+    budget_tokens: number;
+    /** Opus 4.7+ reasoning display mode. */
+    display?: "summarized" | "omitted";
+};
+export type ThinkingConfigDisabled = {
+    type: "disabled";
+};
+export type ThinkingConfigAdaptive = {
+    type: "adaptive";
+    /** Opus 4.7+ reasoning display mode. */
+    display?: "summarized" | "omitted";
+};
+export type ThinkingConfigParam = ThinkingConfigEnabled | ThinkingConfigDisabled | ThinkingConfigAdaptive;
+export type OutputConfig = {
+    /** Adaptive-thinking effort level (effort beta). */
+    effort?: "low" | "medium" | "high" | "xhigh" | "max" | null;
+    /** Task-budgets beta. */
+    task_budget?: TokenTaskBudget | null;
+};
+/** Claude Code context-management beta payload. */
+export type ContextManagement = {
+    edits: Array<{
+        type: "clear_thinking_20251015";
+        keep: "all";
+    }>;
+};
+export type MessageCreateParams = {
+    model: string;
+    messages: MessageParam[];
+    max_tokens: number;
+    system?: string | TextBlockParam[];
+    temperature?: number;
+    top_p?: number;
+    top_k?: number;
+    stop_sequences?: string[];
+    stream?: boolean;
+    tools?: Tool[];
+    tool_choice?: ToolChoice;
+    metadata?: Metadata;
+    thinking?: ThinkingConfigParam;
+    output_config?: OutputConfig;
+    /** Fast-mode beta: realization of priority service tier. */
+    speed?: "fast";
+    /** Claude Code context-management beta. */
+    context_management?: ContextManagement;
+};
+export type MessageCreateParamsStreaming = MessageCreateParams & {
+    stream: true;
+};
+export type StopReason = "end_turn" | "max_tokens" | "stop_sequence" | "tool_use" | "pause_turn" | "refusal" | "sensitive";
+export type CacheCreation = {
+    ephemeral_5m_input_tokens?: number | null;
+    ephemeral_1h_input_tokens?: number | null;
+};
+export type ServerToolUsage = {
+    web_search_requests?: number | null;
+    web_fetch_requests?: number | null;
+};
+export type Usage = {
+    input_tokens?: number | null;
+    output_tokens?: number | null;
+    cache_read_input_tokens?: number | null;
+    cache_creation_input_tokens?: number | null;
+    cache_creation?: CacheCreation | null;
+    server_tool_use?: ServerToolUsage | null;
+};
+/** The `message` envelope carried by `message_start`. */
+export type ResponseMessage = {
+    id: string;
+    type?: "message";
+    role?: "assistant";
+    model?: string;
+    content?: unknown[];
+    stop_reason?: StopReason | null;
+    stop_sequence?: string | null;
+    usage: Usage;
+};
+/** `content_block` payload carried by `content_block_start`. */
+export type ResponseContentBlock = {
+    type: "text";
+    text: string;
+} | {
+    type: "thinking";
+    thinking: string;
+    signature?: string;
+} | {
+    type: "redacted_thinking";
+    data: string;
+} | {
+    type: "tool_use";
+    id: string;
+    name: string;
+    input?: Record<string, unknown> | null;
+};
+export type ContentBlockDelta = {
+    type: "text_delta";
+    text: string;
+} | {
+    type: "input_json_delta";
+    partial_json: string;
+} | {
+    type: "thinking_delta";
+    thinking: string;
+} | {
+    type: "signature_delta";
+    signature: string;
+};
+export type StopDetails = {
+    type: string;
+    category?: string | null;
+    explanation?: string | null;
+};
+export type MessageDelta = {
+    stop_reason?: StopReason | null;
+    stop_sequence?: string | null;
+    stop_details?: StopDetails | null;
+};
+export type RawMessageStartEvent = {
+    type: "message_start";
+    message: ResponseMessage;
+};
+export type RawContentBlockStartEvent = {
+    type: "content_block_start";
+    index: number;
+    content_block: ResponseContentBlock;
+};
+export type RawContentBlockDeltaEvent = {
+    type: "content_block_delta";
+    index: number;
+    delta: ContentBlockDelta;
+};
+export type RawContentBlockStopEvent = {
+    type: "content_block_stop";
+    index: number;
+};
+export type RawMessageDeltaEvent = {
+    type: "message_delta";
+    delta: MessageDelta;
+    usage: Usage;
+};
+export type RawMessageStopEvent = {
+    type: "message_stop";
+};
+export type RawMessageStreamEvent = RawMessageStartEvent | RawContentBlockStartEvent | RawContentBlockDeltaEvent | RawContentBlockStopEvent | RawMessageDeltaEvent | RawMessageStopEvent;

package/dist/types/providers/anthropic.d.ts

@@ -0,0 +1,206 @@
+import type { FetchImpl, Message, Model, ProviderSessionState, ServiceTier, SimpleStreamOptions, StreamFunction, StreamOptions, Usage } from "../types";
+import { type AnthropicFetchOptions, type AnthropicMessagesClientLike } from "./anthropic-client";
+import type { MessageParam, TextBlockParam } from "./anthropic-wire";
+export type AnthropicHeaderOptions = {
+    apiKey: string;
+    baseUrl?: string;
+    isOAuth?: boolean;
+    extraBetas?: string[];
+    stream?: boolean;
+    modelHeaders?: Record<string, string>;
+    isCloudflareAiGateway?: boolean;
+    claudeCodeSessionId?: string;
+    claudeCodeBetas?: readonly string[];
+};
+export declare function normalizeAnthropicBaseUrl(baseUrl?: string): string | undefined;
+export declare function buildBetaHeader(baseBetas: readonly string[], extraBetas: readonly string[]): string;
+export declare function isAnthropicApiBaseUrl(baseUrl?: string): boolean;
+export declare function buildAnthropicHeaders(options: AnthropicHeaderOptions): Record<string, string>;
+type AnthropicCacheControl = NonNullable<TextBlockParam["cache_control"]>;
+/**
+ * Clears the in-session "server rejected fast mode" sticky flag. Call when the
+ * caller is explicitly re-arming `serviceTier: "priority"` (e.g. user toggled
+ * `/fast on` after a previous turn auto-disabled it) so the next request
+ * actually carries `speed: "fast"` again. No-op when the map or state entry
+ * hasn't been materialized yet.
+ */
+export declare function clearAnthropicFastModeFallback(providerSessionState: Map<string, ProviderSessionState> | undefined): void;
+export declare function isAnthropicFastModeUnsupportedError(error: unknown): boolean;
+export declare const claudeCodeVersion = "2.1.160";
+export declare const claudeToolPrefix: string;
+export declare const claudeCodeSystemInstruction = "You are Claude Code, Anthropic's official CLI for Claude.";
+export declare function mapStainlessOs(platform: string): "MacOS" | "Windows" | "Linux" | "FreeBSD" | `Other::${string}`;
+export declare function mapStainlessArch(arch: string): "x64" | "arm64" | "x86" | `other::${string}`;
+export declare const claudeCodeHeaders: {
+    "X-Stainless-Retry-Count": string;
+    "X-Stainless-Runtime-Version": string;
+    "X-Stainless-Package-Version": string;
+    "X-Stainless-Runtime": string;
+    "X-Stainless-Lang": string;
+    "X-Stainless-Arch": "arm64" | "x64" | "x86" | `other::${string}`;
+    "X-Stainless-OS": "FreeBSD" | "Linux" | "MacOS" | "Windows" | `Other::${string}`;
+    "X-Stainless-Timeout": string;
+};
+export declare function isClaudeCloakingUserId(userId: string): boolean;
+export declare function generateClaudeCloakingUserId(): string;
+export declare const applyClaudeToolPrefix: (name: string, prefixOverride?: string) => string;
+export declare const stripClaudeToolPrefix: (name: string, prefixOverride?: string) => string;
+export type AnthropicEffort = "low" | "medium" | "high" | "xhigh" | "max";
+export type AnthropicThinkingDisplay = "summarized" | "omitted";
+export interface AnthropicOptions extends StreamOptions {
+    /**
+     * Enable extended thinking.
+     * For Opus 4.6+: uses adaptive thinking (Claude decides when/how much to think).
+     * For older models: uses budget-based thinking with thinkingBudgetTokens.
+     */
+    thinkingEnabled?: boolean;
+    /**
+     * Token budget for extended thinking (older models only).
+     * Ignored for Opus 4.6+ which uses adaptive thinking.
+     */
+    thinkingBudgetTokens?: number;
+    /**
+     * Effort level for adaptive thinking (Opus 4.6+ only).
+     * Controls how much thinking Claude allocates:
+     * - "max": Always thinks with no constraints
+     * - "high": Always thinks, deep reasoning (default)
+     * - "medium": Moderate thinking, may skip for simple queries
+     * - "low": Minimal thinking, skips for simple tasks
+     * Ignored for older models.
+     */
+    effort?: AnthropicEffort;
+    /**
+     * Optional reasoning level fallback for direct Anthropic provider usage.
+     * Converted to adaptive effort when effort is not explicitly provided.
+     */
+    reasoning?: SimpleStreamOptions["reasoning"];
+    /**
+     * Controls how Anthropic returns thinking content when the selected thinking
+     * transport supports a display option. Defaults to "summarized" where the
+     * API accepts it.
+     */
+    thinkingDisplay?: AnthropicThinkingDisplay;
+    interleavedThinking?: boolean;
+    toolChoice?: "auto" | "any" | "none" | {
+        type: "tool";
+        name: string;
+    };
+    betas?: string[] | string;
+    /**
+     * Realization of `serviceTier: "priority"` on Anthropic models. When
+     * `"priority"`, sets `speed: "fast"` on the request and appends the
+     * `fast-mode-2026-02-01` beta header. Anthropic rejects unsupported models
+     * with `invalid_request_error`, which triggers an in-provider one-shot
+     * fallback (see `fastModeDisabled` provider state).
+     *
+     * Other `ServiceTier` values are currently ignored on this provider.
+     */
+    serviceTier?: ServiceTier;
+    /** Force OAuth bearer auth mode for proxy tokens that don't match Anthropic token prefixes. */
+    isOAuth?: boolean;
+    /**
+     * Pre-built Anthropic Messages client. When provided, skips internal client
+     * construction entirely. Accepts any structurally compatible client,
+     * including SDK clients such as `AnthropicVertex`.
+     */
+    client?: AnthropicMessagesClientLike;
+}
+export type AnthropicClientOptionsArgs = {
+    model: Model<"anthropic-messages">;
+    apiKey: string;
+    extraBetas?: string[];
+    stream?: boolean;
+    interleavedThinking?: boolean;
+    headers?: Record<string, string>;
+    dynamicHeaders?: Record<string, string>;
+    isOAuth?: boolean;
+    hasTools?: boolean;
+    thinkingEnabled?: boolean;
+    thinkingDisplay?: AnthropicThinkingDisplay;
+    onSseEvent?: AnthropicOptions["onSseEvent"];
+    fetch?: FetchImpl;
+    claudeCodeSessionId?: string;
+};
+export type AnthropicClientOptionsResult = {
+    isOAuthToken: boolean;
+    apiKey: string | null;
+    authToken?: string | null;
+    baseURL?: string;
+    maxRetries: number;
+    defaultHeaders: Record<string, string>;
+    fetch?: FetchImpl;
+    fetchOptions?: AnthropicFetchOptions;
+};
+/**
+ * Returns env-supplied custom headers (`ANTHROPIC_CUSTOM_HEADERS`) when they
+ * should be forwarded to the upstream endpoint.
+ *
+ * Foundry mode forwards them unconditionally. Outside Foundry, they're applied
+ * only when the configured base URL is a non-Anthropic host — i.e. an
+ * enterprise/corporate gateway that may require its own proprietary auth
+ * header. Stock `api.anthropic.com` would reject unknown headers, so they're
+ * omitted there.
+ */
+export declare function resolveAnthropicCustomHeadersForBaseUrl(baseUrl: string | undefined): Record<string, string> | undefined;
+export declare function isProviderRetryableError(error: unknown, provider?: string): boolean;
+export type AnthropicUsageLike = {
+    cache_creation?: {
+        ephemeral_5m_input_tokens?: number | null;
+        ephemeral_1h_input_tokens?: number | null;
+    } | null;
+    server_tool_use?: {
+        web_search_requests?: number | null;
+        web_fetch_requests?: number | null;
+    } | null;
+};
+/**
+ * Capture Anthropic's optional cache-creation TTL breakdown and server-tool-use
+ * counters into the harness Usage shape. Only sets fields that were reported, so
+ * a `message_delta` that omits `cache_creation` does not clobber the breakdown
+ * established at `message_start`.
+ */
+export declare function applyAnthropicUsageExtras(usage: Usage, source: AnthropicUsageLike): void;
+export declare const streamAnthropic: StreamFunction<"anthropic-messages">;
+export type AnthropicSystemBlock = {
+    type: "text";
+    text: string;
+    cache_control?: AnthropicCacheControl;
+};
+type SystemBlockOptions = {
+    includeClaudeCodeInstruction?: boolean;
+    extraInstructions?: string[];
+    /** Text of the first user message — used as fingerprint seed for the billing header. */
+    firstUserMessageText?: string;
+    cacheControl?: AnthropicCacheControl;
+};
+export declare function buildAnthropicSystemBlocks(systemPrompt: readonly string[] | undefined, options?: SystemBlockOptions): AnthropicSystemBlock[] | undefined;
+export declare function normalizeExtraBetas(betas?: string[] | string): string[];
+export declare function buildAnthropicClientOptions(args: AnthropicClientOptionsArgs): AnthropicClientOptionsResult;
+/**
+ * A single Anthropic conversation turn, including the mid-conversation
+ * `system` role (Opus 4.8+).
+ */
+export type AnthropicMessageParam = MessageParam;
+export declare function convertAnthropicMessages(messages: Message[], model: Model<"anthropic-messages">, isOAuthToken: boolean): AnthropicMessageParam[];
+/**
+ * Normalize a JSON Schema node for Anthropic tool `input_schema`.
+ *
+ * Applies the full whitelist semantics from the Anthropic Python SDK's
+ * `lib/_parse/_transform.py::transform_schema`:
+ *
+ * 1. Universal keys (`$ref`, `$defs`, `type`, `anyOf`/`oneOf`/`allOf`, `enum`, `const`,
+ *    `description`, `title`, `default`, `nullable`) are preserved on every node.
+ * 2. Per-type keys are kept additively (object → `properties`/`required`/`additionalProperties`,
+ *    array → `items`/`prefixItems` plus `minItems` only when 0 or 1, string → `format`
+ *    only when in the supported value set).
+ * 3. Everything else is demoted into the node's `description` as `\n\n{key: value, ...}`
+ *    so the model still sees the constraint as a natural-language hint.
+ *
+ * Object nodes default to `additionalProperties: false`, but explicit open-map
+ * declarations (`additionalProperties: true` or a schema literal — Zod's
+ * `z.record(z.string(), z.unknown())` produces `{}`) are preserved. The strict-mode
+ * pass downstream demotes those shapes to non-strict instead of fabricating a closed
+ * object, so callers like the resolve tool keep working open-map semantics.
+ */
+export declare function normalizeAnthropicToolSchema(schema: unknown): unknown;
+export {};

package/dist/types/providers/aws-credentials.d.ts

@@ -0,0 +1,43 @@
+/**
+ * AWS credential resolution for the Bedrock provider.
+ *
+ * Chain (first hit wins):
+ *  1. Static credentials from the environment
+ *     (`AWS_ACCESS_KEY_ID` + `AWS_SECRET_ACCESS_KEY` [+ `AWS_SESSION_TOKEN`]).
+ *  2. Profile in `~/.aws/credentials` (and `~/.aws/config` for SSO):
+ *      - static `aws_access_key_id` / `aws_secret_access_key` / `aws_session_token`
+ *      - SSO profile referencing a cached token in `~/.aws/sso/cache/*.json`,
+ *        which we exchange for short-lived role credentials via
+ *        `https://portal.sso.{region}.amazonaws.com/federation/credentials`.
+ *      - `credential_process` — an external command emitting the AWS SDK
+ *        `Version: 1` JSON envelope on stdout. Used by `aws-vault`, `granted`,
+ *        in-house brokers, etc.
+ *  3. EC2 IMDSv2 (only when `AWS_EC2_METADATA_DISABLED` is unset / falsey and
+ *     `169.254.169.254` is reachable within a 1 s timeout).
+ *
+ * Resolved credentials are cached process-wide per profile and refreshed
+ * 60 s before `Expiration` to absorb clock skew.
+ */
+import type { AwsCredentials } from "./aws-sigv4";
+export interface ResolvedCredentials extends AwsCredentials {
+    /** Absolute expiration timestamp in ms. `undefined` for non-expiring static creds. */
+    expiresAt?: number;
+}
+export interface CredentialResolveOptions {
+    /** Named profile from `~/.aws/credentials` / `~/.aws/config`. */
+    profile?: string;
+    /** Falls back to env (`AWS_REGION` / `AWS_DEFAULT_REGION`) and finally `us-east-1`. */
+    region?: string;
+    signal?: AbortSignal;
+}
+export declare function resolveAwsCredentials(opts?: CredentialResolveOptions): Promise<ResolvedCredentials>;
+/** POSIX-shell-style tokenizer used by the AWS CLI for `credential_process`.
+ *
+ * Outside quotes a backslash escapes the next character. Inside single quotes
+ * everything is literal (no escapes, cannot contain `'`). Inside double quotes
+ * a backslash only escapes `$`, `` ` ``, `"`, and `\` — every other backslash
+ * is preserved verbatim, which is what makes Windows paths like
+ * `"C:\Program Files\tool\auth.exe"` survive tokenization. */
+export declare function tokenizeCredentialProcessCommand(cmd: string): string[];
+/** Test/diagnostic helper — drops cached credentials. */
+export declare function clearAwsCredentialCache(): void;

package/dist/types/providers/aws-eventstream.d.ts

@@ -0,0 +1,38 @@
+/**
+ * `application/vnd.amazon.eventstream` decoder.
+ *
+ * Wire format (all integers big-endian):
+ *
+ *   [total length     u32]
+ *   [headers length   u32]
+ *   [prelude CRC32    u32]   <- CRC over the first 8 bytes
+ *   [headers          headers_length]
+ *   [payload          total_length - headers_length - 16]
+ *   [message CRC32    u32]   <- CRC over the entire message minus the trailing 4 bytes
+ *
+ * Headers: a sequence of `[name_len u8][name utf8][value_type u8][value …]`.
+ * We only need the typed values Bedrock emits (boolean true/false, byte, short,
+ * integer, long, byte-array, string, timestamp, uuid). All are surfaced as
+ * strings for ease of consumption — Bedrock only sets string-valued headers in
+ * practice (`:event-type`, `:message-type`, `:content-type`, `:exception-type`).
+ */
+export interface EventStreamMessage {
+    /** Lower-cased copy is *not* applied — Bedrock uses casing like `:event-type` verbatim. */
+    headers: Record<string, string>;
+    payload: Uint8Array;
+}
+export declare function crc32(bytes: Uint8Array, seed?: number): number;
+/**
+ * Decode a single, fully buffered eventstream message. Throws if the framing is
+ * malformed or either CRC mismatches. Used by both `decodeEventStream` (the
+ * streaming entry point) and the unit tests, which exercise it with hand-built
+ * frames.
+ */
+export declare function decodeMessage(frame: Uint8Array): EventStreamMessage;
+/**
+ * Async generator that consumes a `ReadableStream<Uint8Array>` (e.g. a fetch
+ * response body) and yields fully-framed messages. Handles arbitrary chunk
+ * boundaries: messages may span multiple chunks, and a single chunk may carry
+ * many messages.
+ */
+export declare function decodeEventStream(source: ReadableStream<Uint8Array>): AsyncGenerator<EventStreamMessage>;

package/dist/types/providers/aws-sigv4.d.ts

@@ -0,0 +1,55 @@
+/**
+ * AWS Signature V4 signing for HTTP requests. WebCrypto-only — no node:crypto.
+ *
+ * Matches `@smithy/signature-v4` for our usage: header-based signing with a
+ * full SHA-256 payload hash (Bedrock requires `applyChecksum: true`).
+ *
+ * Returns the set of headers to attach to the request:
+ *  - `host`
+ *  - `x-amz-date`
+ *  - `x-amz-content-sha256`
+ *  - `x-amz-security-token` (only when credentials carry a sessionToken)
+ *  - `authorization`
+ */
+export interface AwsCredentials {
+    accessKeyId: string;
+    secretAccessKey: string;
+    sessionToken?: string;
+}
+export interface SignParams {
+    method: string;
+    /** Hostname only — used to build the `host` header and the canonical request. */
+    host: string;
+    /** URI path component, e.g. `/model/anthropic.claude/converse-stream`. */
+    path: string;
+    /** Optional pre-built query string (without leading `?`). */
+    query?: string;
+    /** Extra headers to sign in addition to `host`/`x-amz-*`. Names are case-insensitive. */
+    headers?: Record<string, string>;
+    body: Uint8Array;
+    region: string;
+    service: string;
+    credentials: AwsCredentials;
+    /** Override clock for deterministic tests. */
+    date?: Date;
+}
+export declare function toHex(bytes: Uint8Array): string;
+export declare function sha256(data: Uint8Array | string): Promise<Uint8Array>;
+export declare function sha256Hex(data: Uint8Array | string): Promise<string>;
+/**
+ * Derive a signing key: HMAC chain `kSecret → kDate → kRegion → kService → kSigning`.
+ */
+export declare function getSigningKey(secretAccessKey: string, shortDate: string, region: string, service: string): Promise<Uint8Array>;
+/** `YYYYMMDDTHHMMSSZ` + 8-char `YYYYMMDD`. */
+export declare function formatAmzDate(d: Date): {
+    longDate: string;
+    shortDate: string;
+};
+export interface SignedHeaders {
+    host: string;
+    "x-amz-date": string;
+    "x-amz-content-sha256": string;
+    authorization: string;
+    "x-amz-security-token"?: string;
+}
+export declare function signRequest(params: SignParams): Promise<SignedHeaders>;

package/dist/types/providers/azure-openai-responses.d.ts

@@ -0,0 +1,15 @@
+import type { ServiceTier, StreamFunction, StreamOptions, ToolChoice } from "../types";
+export interface AzureOpenAIResponsesOptions extends StreamOptions {
+    reasoning?: "minimal" | "low" | "medium" | "high" | "xhigh";
+    reasoningSummary?: "auto" | "detailed" | "concise" | null;
+    azureApiVersion?: string;
+    azureResourceName?: string;
+    azureBaseUrl?: string;
+    azureDeploymentName?: string;
+    toolChoice?: ToolChoice;
+    serviceTier?: ServiceTier;
+}
+/**
+ * Generate function for Azure OpenAI Responses API
+ */
+export declare const streamAzureOpenAIResponses: StreamFunction<"azure-openai-responses">;