jeopi-ai 16.2.13

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

@@ -0,0 +1,318 @@
+/**
+ * Anthropic Messages API wire types.
+ *
+ * Hand-maintained against https://docs.anthropic.com/en/api/messages so pi-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 pi-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;
+};
+/**
+ * Server-side fallback beta boundary marker (server-side-fallback-2026-06-01).
+ * Emitted by the API mid-stream when a classifier block on the requested
+ * model is retried on a fallback model. Only the official Anthropic
+ * endpoint accepts this block on replay — cross-provider hops MUST strip it.
+ */
+export type FallbackBlockParam = {
+    type: "fallback";
+    from: {
+        model: string;
+    };
+    to: {
+        model: string;
+    };
+};
+export type ContentBlockParam = TextBlockParam | ImageBlockParam | ToolUseBlockParam | ToolResultBlockParam | ThinkingBlockParam | RedactedThinkingBlockParam | FallbackBlockParam;
+/**
+ * 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;
+};
+/**
+ * Per-attempt override entry in `MessageCreateParams.fallbacks`
+ * (server-side-fallback-2026-06-01 beta). Every field except `model`
+ * mirrors a top-level control the beta allows re-specifying per attempt.
+ */
+export type FallbackParam = {
+    model: string;
+    max_tokens?: number;
+    thinking?: ThinkingConfigParam;
+    output_config?: OutputConfig;
+    speed?: "fast";
+};
+/** 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;
+    /**
+     * Server-side fallback beta chain — up to three fallback models the API
+     * retries when a classifier blocks the primary. Required companion beta
+     * header: `server-side-fallback-2026-06-01`.
+     */
+    fallbacks?: FallbackParam[];
+};
+export type MessageCreateParamsStreaming = MessageCreateParams & {
+    stream: true;
+};
+export type StopReason = "end_turn" | "max_tokens" | "stop_sequence" | "tool_use" | "pause_turn" | "refusal" | "sensitive" | "model_context_window_exceeded";
+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;
+};
+/**
+ * Per-attempt token accounting inside a multi-run turn
+ * (server-side-fallback-2026-06-01). Populated whenever a fallback chain
+ * ran, including sticky-served turns with no `fallback` content block.
+ * A `fallback_message` entry is the definitive "served by fallback" signal.
+ */
+export type UsageIteration = {
+    type?: "message" | "fallback_message" | string;
+    model?: string | null;
+    input_tokens?: number | null;
+    output_tokens?: number | null;
+    cache_read_input_tokens?: number | null;
+    cache_creation_input_tokens?: 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;
+    iterations?: UsageIteration[] | 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;
+} | {
+    type: "fallback";
+    from: {
+        model: string;
+    };
+    to: {
+        model: string;
+    };
+};
+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,248 @@
+import type { FetchImpl, Message, Model, ProviderSessionState, ServiceTier, SimpleStreamOptions, StreamFunction, StreamOptions, Usage } from "../types";
+import { type AnthropicFetchOptions, type AnthropicMessagesClientLike } from "./anthropic-client";
+import type { FallbackParam, 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 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 const claudeCodeVersion = "2.1.165";
+export declare const claudeAgentSdkVersion = "0.3.165";
+export declare const claudeClientVersion = "1.11187.4";
+export declare const claudeToolPrefix: string;
+export declare const claudeCodeSystemInstruction = "You are a Claude agent, built on Anthropic's Claude Agent SDK.";
+export declare const CLAUDE_CODE_MAX_OUTPUT_TOKENS = 64000;
+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;
+    "anthropic-client-platform": string;
+    "anthropic-client-version": string;
+};
+/**
+ * Wraps a fetch implementation to patch the Claude Code billing-header `cch`
+ * attestation into outgoing request bodies. Bodies without the placeholder
+ * pass through untouched, so installing it on every OAuth flow is safe.
+ */
+export declare function wrapFetchForCch(base: FetchImpl): FetchImpl;
+export declare function isClaudeCloakingUserId(userId: string): boolean;
+export declare function generateClaudeCloakingUserId(): string;
+export declare function deriveClaudeDeviceId(installId: string, accountId?: string): string;
+/**
+ * Resolve the `metadata.user_id` field for an Anthropic Messages request.
+ *
+ * For API-key tokens, an explicit caller-supplied `userId` is forwarded
+ * verbatim and `undefined` yields no metadata. For OAuth tokens the value
+ * must match the Claude Code attribution shape (`isClaudeCloakingUserId` or
+ * the `{session_id, account_uuid?, device_id?}` JSON envelope) — anything
+ * else is dropped and a fresh Claude-Code-style JSON id is generated from
+ * `sessionId`/`accountId` so attribution stays consistent across the main
+ * streaming path and provider-specific request builders (e.g. web search).
+ */
+export declare function resolveAnthropicMetadataUserId(userId: unknown, isOAuthToken: boolean, sessionId?: string, accountId?: string): string | undefined;
+export declare const applyClaudeToolPrefix: (name: string) => string;
+export declare const stripClaudeToolPrefix: (name: string) => string;
+export type AnthropicOutputEffort = "low" | "medium" | "high" | "xhigh" | "max";
+export type AnthropicEffort = AnthropicOutputEffort | "adaptive";
+export type AnthropicThinkingDisplay = "summarized" | "omitted";
+export interface AnthropicOptions extends StreamOptions {
+    /**
+     * Enable extended thinking.
+     * For adaptive-capable models (Opus 4.6+, Sonnet 4.6+, Fable/Mythos 5):
+     * 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 adaptive-capable models.
+     */
+    thinkingBudgetTokens?: number;
+    /**
+     * Upstream wire model id override for collapsed effort-tier variants.
+     * Serialized as `requestModelId ?? model.requestModelId ?? model.id`.
+     */
+    requestModelId?: string;
+    /**
+     * Effort level for adaptive thinking.
+     * Controls how much Claude allocates, or uses "adaptive" for MiniMax's
+     * binary adaptive-thinking tag:
+     * - "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
+     * - "adaptive": Sends `thinking.type: "adaptive"` without `output_config.effort`
+     * 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;
+    /**
+     * Server-side fallback beta chain (`server-side-fallback-2026-06-01`).
+     * When set, `fallbacks` is forwarded on the request body and the beta
+     * header is auto-attached; the response parser then honors mid-stream
+     * `fallback` content blocks and `usage.iterations` for served-model
+     * promotion and per-attempt pricing. Opt-in ONLY — leaving this
+     * undefined preserves the pre-fallback behavior on every code path.
+     */
+    fallbacks?: FallbackParam[];
+}
+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;
+    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;
+/**
+ * Whether an Anthropic (or Copilot-over-Anthropic) stream error should be
+ * retried. The classification lives in {@link AIError.isProviderRetryableError};
+ * this wrapper injects the Copilot-specific `model_not_supported` transient
+ * check, which the error module must not import directly.
+ */
+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. Omitted/null fields are no-ops; explicit
+ * zero-valued objects clear prior extras from earlier stream usage snapshots.
+ */
+export declare function applyAnthropicUsageExtras(usage: Usage, source: AnthropicUsageLike): void;
+/**
+ * Public entry: wrap the single-attempt streamer with bounded empty-completion
+ * retries (a benign terminal stop carrying no content/usage would otherwise
+ * stall the agent loop). The inner attempt keeps its own provider-failure retry
+ * loop; this layer only re-issues a fresh request on an empty success. Shared
+ * with the OpenAI-completions provider via `withEmptyCompletionRetry`.
+ */
+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+ and Fable/Mythos 5).
+ */
+export type AnthropicMessageParam = MessageParam;
+/**
+ * Serialize omp {@link Message}s to Anthropic wire messages.
+ *
+ * `opts.serverSideFallbackEnabled` — when the CURRENT request itself
+ * opts into the server-side-fallback beta chain. Only then may a persisted
+ * `fallback` content block from a prior turn be replayed on the wire;
+ * otherwise the block is dropped to avoid a 400 on non-fallback requests
+ * that don't send the beta.
+ */
+export declare function convertAnthropicMessages(messages: Message[], model: Model<"anthropic-messages">, isOAuthToken: boolean, opts?: {
+    serverSideFallbackEnabled?: boolean;
+}): AnthropicMessageParam[];
+export declare function normalizeAnthropicToolSchema(schema: unknown): unknown;
+export {};

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

@@ -0,0 +1,53 @@
+/**
+ * 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 { FetchImpl } from "../types";
+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;
+    fetch?: FetchImpl;
+}
+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;
+/**
+ * Drop the cache entry for one profile/region. Called by the Bedrock provider on
+ * 401/403 responses so stale credentials are re-resolved instead of served until restart.
+ */
+export declare function invalidateAwsCredentialCache(opts?: {
+    profile?: string;
+    region?: string;
+}): void;

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

@@ -0,0 +1,39 @@
+/**
+ * `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;
+}
+/** CRC32 (IEEE / zlib polynomial 0xEDB88320), matches `@aws-crypto/crc32`. */
+export declare function crc32(bytes: Uint8Array): 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>;