jeopi-ai 16.2.13

package/dist/types/error/finalize.d.ts

@@ -0,0 +1,39 @@
+import type { Api } from "../types";
+import type { AbortSourceTracker } from "../utils/abort";
+import type { CapturedHttpErrorResponse, RawHttpRequestDump } from "../utils/http-inspector";
+/** Context a provider catch block hands to {@link finalize}. */
+export interface FinalizeOptions {
+    /** Wire API, for api-specific text classification (e.g. stale-responses items). */
+    api?: Api;
+    /** Provider id; forwarded to the message formatter for copilot rewrites. */
+    provider?: string;
+    /** Caller signal, for providers that don't run an abort tracker. */
+    signal?: AbortSignal;
+    /** Abort tracker, preferred over `signal`: distinguishes caller vs. local aborts. */
+    abortTracker?: AbortSourceTracker;
+    /** Raw request, dumped into the message for 400-class failures. */
+    rawRequestDump?: RawHttpRequestDump;
+    /** Captured non-2xx response body, used for status fallback and message detail. */
+    capturedErrorResponse?: CapturedHttpErrorResponse;
+}
+/** The full bundle a provider assigns onto its `AssistantMessage` error fields. */
+export interface FinalizeResult {
+    /** Structured flag id from {@link classify}. */
+    id: number;
+    /** HTTP status, from the error or the captured response. */
+    status: number | undefined;
+    /** `"aborted"` when the caller cancelled, otherwise `"error"`. */
+    stopReason: "aborted" | "error";
+    /** User-facing message from {@link formatMessage}, or a local abort reason. */
+    message: string;
+}
+/**
+ * Build the complete error bundle for a provider catch block, replacing the
+ * `stopReason` / `errorStatus` / `errorId` / `errorMessage` boilerplate.
+ *
+ * `stopReason` comes from the abort tracker (caller intent dominates) or, when
+ * no tracker is supplied, the raw `signal.aborted`. A local abort reason (e.g. a
+ * first-event timeout) supersedes the formatted message. Message formatting is
+ * wrapped so a formatter throw can never skip the caller's `stream.end()`.
+ */
+export declare function finalize(error: unknown, opts?: FinalizeOptions): Promise<FinalizeResult>;

package/dist/types/error/flags.d.ts

@@ -0,0 +1,79 @@
+import type { Api, AssistantMessage } from "../types";
+export declare const Flag: {
+    readonly Class: 4096;
+    readonly ThinkingLoop: 65536;
+    readonly Transient: 131072;
+    readonly Timeout: 262144;
+    readonly UsageLimit: 524288;
+    readonly StaleResponsesItem: 1048576;
+    readonly MalformedFunctionCall: 2097152;
+    readonly ProviderFinishError: 4194304;
+    readonly ContextOverflow: 8388608;
+    readonly AuthFailed: 16777216;
+    readonly SilentAbort: 33554432;
+    readonly UserInterrupt: 67108864;
+    readonly Abort: 134217728;
+    /** Anthropic strict-tool grammar too large / schema too complex to compile (400). */
+    readonly Grammar: 268435456;
+    /** Anthropic model/account does not support fast mode / the `speed` parameter. */
+    readonly FastModeUnsupported: 536870912;
+    /** OAuth refresh failed definitively — the stored grant is dead, re-login required. */
+    readonly OAuthExpiry: 1073741824;
+};
+export type Flag = (typeof Flag)[keyof typeof Flag];
+export declare const STREAM_READ_ERROR_PATTERN: RegExp;
+export declare const TRANSIENT_TRANSPORT_PATTERN: RegExp;
+/**
+ * Local llama.cpp / Ollama deterministic tool-call argument JSON parse failure.
+ * The model emitted invalid JSON in a tool call and the server returned HTTP 500
+ * with this exact text — replaying the same prompt yields the same malformed
+ * output, so callers strip {@link Flag.Transient} when this matches.
+ */
+export declare const LLAMA_CPP_TOOL_CALL_PARSE_PATTERN: RegExp;
+/** Whether an OAuth refresh error message means the grant is definitively dead. */
+export declare function isOAuthExpiry(errorMessage: string): boolean;
+export declare function create(...flags: number[]): number;
+export declare function is(id: number | undefined, flag: Flag): boolean;
+export declare function retriable(id: number | undefined, opts?: {
+    replayUnsafe?: boolean;
+}): boolean;
+export declare function status(error: unknown): number | undefined;
+export declare function isStreamReadErrorText(text: string): boolean;
+export declare function classify(error: unknown, api?: Api): number;
+/**
+ * Whether an error (or message string) classifies as an account usage/quota
+ * limit — the persistent, credential-rotation-worthy kind. This is the public
+ * accessor for {@link Flag.UsageLimit}; prefer it over re-running message
+ * regexes at call sites.
+ */
+export declare function isUsageLimit(error: unknown, api?: Api): boolean;
+/**
+ * Anthropic strict-tool grammar too large / schema too complex to compile.
+ * Accessor for {@link Flag.Grammar}.
+ */
+export declare function isGrammarError(error: unknown): boolean;
+/**
+ * Anthropic model/account does not support fast mode / the `speed` parameter.
+ * Accessor for {@link Flag.FastModeUnsupported}.
+ */
+export declare function isFastModeUnsupported(error: unknown): boolean;
+/**
+ * GitHub Copilot 400 `model_not_supported` routing flap — transient. Reads the
+ * structural `code` (and falls back to {@link Flag.Transient} text classification).
+ */
+export declare function isCopilotTransientModelError(error: unknown): boolean;
+export declare function classifyMessage(message: {
+    api?: Api;
+    errorId?: number;
+    errorMessage?: string;
+    errorStatus?: number;
+}): number;
+export declare function attach<E extends object>(error: E, id: number): E;
+export declare function isContextOverflow(message: AssistantMessage, contextWindow?: number): boolean;
+export declare function stringify(id: number | undefined): string;
+/** Transient stream corruption where the response was truncated mid-JSON. */
+export declare function isTransientStreamParseError(error: unknown): boolean;
+/** Any malformed stream-envelope error (prefix-tagged or out-of-order events). */
+export declare function isStreamEnvelopeError(error: unknown): boolean;
+/** Stream-envelope errors safe to retry against the provider (event ordering only). */
+export declare function isRetryableStreamEnvelopeError(error: unknown): boolean;

package/dist/types/error/format.d.ts

@@ -0,0 +1,20 @@
+import { type CapturedHttpErrorResponse, type RawHttpRequestDump } from "../utils/http-inspector";
+/** Inputs that steer {@link formatMessage}'s formatter selection. */
+export interface FormatMessageOptions {
+    /** When present, the raw request is dumped into the message for 400-class failures. */
+    rawRequestDump?: RawHttpRequestDump;
+    /** Captured non-2xx response body, appended to the message when available. */
+    capturedErrorResponse?: CapturedHttpErrorResponse;
+    /** Provider id; gates provider-specific user-facing rewrites. */
+    provider?: string;
+}
+/**
+ * Format a provider error into a user-facing message, unifying the three
+ * formatters: lightweight retry-after extraction, the raw-dump finalizer, and
+ * the copilot rewrite.
+ *
+ * Selection is driven by inputs, not a mode flag: a `rawRequestDump` routes
+ * through {@link finalizeErrorMessage} (retry-after + raw dump + captured body),
+ * otherwise the lightweight {@link formatErrorMessageWithRetryAfter} is used.
+ */
+export declare function formatMessage(error: unknown, opts?: FormatMessageOptions): Promise<string>;

package/dist/types/error/gateway.d.ts

@@ -0,0 +1,20 @@
+/** A gateway-facing classification of an arbitrary upstream/internal error. */
+export interface GatewayErrorClassification {
+    status: number;
+    type: string;
+    message: string;
+}
+/**
+ * Classify an upstream / gateway-internal error into a status code and a
+ * format-neutral type. The order is intentional:
+ *
+ *  1. Honour an explicit numeric `status` property on the thrown error.
+ *  2. Parse a status code embedded in the message string. Provider errors
+ *     virtually always carry one (`Google API error (400): …`, `HTTP 429`,
+ *     `status=503`) and the embedded value is authoritative.
+ *  3. Fall through to **word-boundaried** substring heuristics. The old
+ *     `lower.includes("rate")` test famously matched `GenerateContentRequest`,
+ *     surfacing every Google 400 as a 429 `rate_limit_error`. The patterns here
+ *     all require boundaries so they don't collide with provider field names.
+ */
+export declare function classifyGatewayError(err: unknown): GatewayErrorClassification;

package/dist/types/error/index.d.ts

@@ -0,0 +1,13 @@
+export * from "./abort";
+export * from "./auth";
+export * from "./auth-classify";
+export * from "./aws";
+export * from "./classes";
+export * from "./finalize";
+export * from "./flags";
+export * from "./format";
+export * from "./gateway";
+export * from "./oauth";
+export * from "./provider";
+export * from "./retryable";
+export * from "./validation";

package/dist/types/error/oauth.d.ts

@@ -0,0 +1,43 @@
+/**
+ * What stage of an OAuth / device-code login flow failed. Discriminates the
+ * single {@link OAuthError} class so login flows don't each mint a bespoke
+ * error type.
+ */
+export type OAuthErrorKind = 
+/** Token-exchange / refresh / discovery HTTP response was non-2xx or unparseable. */
+"http"
+/** Response body was missing required fields (token, account id, endpoints, …). */
+ | "validation"
+/** Authorization-code → token exchange failed. */
+ | "token-exchange"
+/** Refresh-token grant failed. */
+ | "token-refresh"
+/** Device-code / authorization polling failed (server error, too many retries). */
+ | "polling"
+/** The flow exceeded its deadline (device-code expiry, polling timeout). */
+ | "timeout"
+/** Device authorization was denied or cancelled by the user/provider. */
+ | "device-auth"
+/** Misconfiguration (bad redirect URI, missing projectId, callback bind, …). */
+ | "configuration"
+/** Cloud project provisioning / onboarding (loadCodeAssist, onboardUser). */
+ | "provisioning"
+/** OIDC / endpoint discovery failed. */
+ | "discovery";
+export interface OAuthErrorOptions {
+    kind?: OAuthErrorKind;
+    provider?: string;
+    status?: number;
+    cause?: unknown;
+}
+/**
+ * A failure inside an interactive OAuth / device-code login flow. The `kind`
+ * pinpoints the stage. Timeout/polling are classified transient; everything
+ * else is a hard auth failure so the credential layer does not silently retry.
+ */
+export declare class OAuthError extends Error {
+    readonly kind: OAuthErrorKind;
+    readonly provider: string | undefined;
+    readonly status: number | undefined;
+    constructor(message: string, options?: OAuthErrorOptions);
+}

package/dist/types/error/provider.d.ts

@@ -0,0 +1,42 @@
+import { ProviderHttpError } from "./classes";
+/** Which part of a provider exchange produced a non-HTTP error. */
+export type ProviderResponseErrorKind = 
+/** Stream closed before a terminal completion/response event. */
+"incomplete-stream"
+/** Terminal event carried an error / unexpected stop reason. */
+ | "output"
+/** Response body was empty/missing when content was required. */
+ | "empty-body"
+/** Malformed wire envelope (unexpected message ordering / shape). */
+ | "envelope"
+/** Content was blocked by a provider safety filter. */
+ | "content-blocked"
+/** Runtime/namespace resolution or other provider-internal failure. */
+ | "runtime";
+export interface ProviderResponseErrorOptions {
+    provider?: string;
+    kind?: ProviderResponseErrorKind;
+    cause?: unknown;
+}
+/**
+ * A non-HTTP provider failure: a truncated stream, an error stop reason, an
+ * empty body, a malformed envelope, or a runtime fault. For non-2xx HTTP
+ * responses use {@link ProviderHttpError} (or a provider subclass) instead.
+ */
+export declare class ProviderResponseError extends Error {
+    readonly provider: string | undefined;
+    readonly kind: ProviderResponseErrorKind;
+    constructor(message: string, options?: ProviderResponseErrorOptions);
+}
+/** Non-2xx response from the Devin API. */
+export declare class DevinApiError extends ProviderHttpError {
+    readonly name = "DevinApiError";
+}
+/** Non-2xx response from the GitLab Duo direct-access API. */
+export declare class GitLabDuoApiError extends ProviderHttpError {
+    readonly name = "GitLabDuoApiError";
+}
+/** Non-2xx response from the GitLab Duo Workflow API. */
+export declare class GitLabDuoWorkflowApiError extends ProviderHttpError {
+    readonly name = "GitLabDuoWorkflowApiError";
+}

package/dist/types/error/rate-limit.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Rate limit reason classification and backoff calculation utilities.
+ * Ported from opencode-antigravity-auth plugin for consistency.
+ */
+export type RateLimitReason = "QUOTA_EXHAUSTED" | "RATE_LIMIT_EXCEEDED" | "MODEL_CAPACITY_EXHAUSTED" | "SERVER_ERROR" | "UNKNOWN";
+/**
+ * Classify a rate-limit error message into a reason category.
+ * Priority order: QUOTA (Antigravity "quota will reset") > MODEL_CAPACITY > QUOTA (account) >
+ * RATE_LIMIT > QUOTA (generic) > SERVER_ERROR > UNKNOWN.
+ *
+ * "resource exhausted" maps to MODEL_CAPACITY (transient, short wait)
+ * "quota exceeded" / "quota will reset" maps to QUOTA_EXHAUSTED (long wait, switch account)
+ */
+export declare function parseRateLimitReason(errorMessage: string): RateLimitReason;
+/**
+ * Calculate backoff delay in ms for a given rate limit reason.
+ * MODEL_CAPACITY gets jitter to prevent thundering herd.
+ */
+export declare function calculateRateLimitBackoffMs(reason: RateLimitReason): number;
+/**
+ * HTTP status codes that, absent richer body classification, represent an
+ * account-local usage cap rather than a bad credential or a transient blip.
+ * Always combine with {@link isUsageLimitOutcome} when a message is available
+ * — a 429 carrying transient rate-limit wording is NOT a usage cap.
+ */
+export declare function isUsageLimitStatus(status: number | undefined): boolean;
+/**
+ * Returns true for failures that should burn one credential and rotate to a
+ * sibling account. Decision tree:
+ *
+ *  1. Body matches {@link isUsageLimitError} (Codex `usage_limit_reached`,
+ *     Anthropic account rate-limit, Google `resource_exhausted`, OpenAI
+ *     `insufficient_quota`, …) → rotate.
+ *  2. Status is not 429 → backoff (caller's domain).
+ *  3. Body is absent or {@link isOpaqueStatusBody opaque} (just the status,
+ *     empty JSON, HTTP framing only) → rotate conservatively: the server
+ *     gave us nothing else to go on.
+ *  4. Body has content → defer to {@link parseRateLimitReason}. Only
+ *     `QUOTA_EXHAUSTED` rotates; `RATE_LIMIT_EXCEEDED` (`Too many requests`,
+ *     per-minute caps), `MODEL_CAPACITY_EXHAUSTED` (`Service overloaded`),
+ *     `SERVER_ERROR`, and `UNKNOWN` (`Please retry in 5s`) stay in the
+ *     provider's own backoff layer so transient 429s don't burn sibling
+ *     credentials.
+ */
+export declare function isUsageLimitOutcome(status: number | undefined, message: string | undefined): boolean;
+/**
+ * A 429 body is opaque when it carries no signal beyond the status itself —
+ * empty, whitespace-only, the status digits with HTTP/JSON framing, or
+ * generic punctuation. Anything else (retry hints, capacity wording, error
+ * descriptions) is informative enough to defer to the classifier.
+ */
+export declare function isOpaqueStatusBody(message: string): boolean;
+/**
+ * Internal text matcher for usage/quota-limit phrasing. NOT part of the public
+ * API — callers classify through {@link import("./flags").isUsageLimit} (the
+ * flag accessor). `flags.ts` consumes this to populate `Flag.UsageLimit`, and
+ * {@link isUsageLimitOutcome} uses it for the account-rotation decision.
+ */
+export declare function matchesUsageLimitText(errorMessage: string): boolean;

package/dist/types/error/retryable.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Whether a numeric HTTP status is in the canonical transient/retryable set:
+ * 408 (Request Timeout), 429 (Too Many Requests), and any 5xx.
+ *
+ * This is a pure predicate over a status code already in hand — distinct from
+ * {@link classify}, which inspects a whole error (including message text) and
+ * may match more. Use this when you only have a `status: number`.
+ */
+export declare function isTransientStatus(status: number | undefined): boolean;
+/** Hook for provider-specific transient detection that the error module must not import directly. */
+export interface ProviderRetryableHooks {
+    /** Provider id of the failing request, used to gate provider-specific checks. */
+    provider?: string;
+    /** Provider-specific transient predicate (e.g. Copilot `model_not_supported`). */
+    isProviderTransient?: (error: Error) => boolean;
+}
+/**
+ * Whether a provider stream error should be retried against the same credential.
+ *
+ * Account-level usage/quota limits are deliberately treated as **non**-retryable
+ * here — they are owned by the credential-rotation layer (auth-gateway /
+ * `streamSimple` a/b/c policy), not this seconds-scale provider backoff.
+ *
+ * Provider-specific transient cases are injected via {@link ProviderRetryableHooks}
+ * so this stays free of provider imports.
+ */
+export declare function isProviderRetryableError(error: unknown, hooks?: ProviderRetryableHooks): boolean;

package/dist/types/error/validation.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Caller-supplied input failed validation before/while building a provider
+ * request: bad request body, malformed tool arguments, unsupported content
+ * type, a schema that cannot be normalized, an unknown tool, etc.
+ *
+ * This is a programmer/config/contract error, not a transient provider fault —
+ * it is never retried.
+ */
+export declare class ValidationError extends Error {
+    constructor(message: string, options?: {
+        cause?: unknown;
+    });
+}
+/** A referenced tool was not found in the active tool set. */
+export declare class ToolNotFoundError extends ValidationError {
+    constructor(toolName: string);
+}
+/**
+ * Provider/auth configuration was missing or malformed (env var pointing at a
+ * missing file, missing projectId, bad bind string, mTLS half-configured, …).
+ */
+export declare class ConfigurationError extends Error {
+    constructor(message: string, options?: {
+        cause?: unknown;
+    });
+}
+/** A request was abandoned because it exceeded a stream/idle/first-event deadline. */
+export declare class StreamTimeoutError extends Error {
+    constructor(message?: string, options?: {
+        cause?: unknown;
+    });
+}

package/dist/types/index.d.ts

@@ -0,0 +1,49 @@
+export { type Type, type } from "arktype";
+export { type ZodType, z } from "zod/v4";
+export * from "./api-registry";
+export type * from "./auth-broker";
+export type { AuthGatewayBootOptions, ModelResolver } from "./auth-gateway/server";
+export * from "./auth-gateway/types";
+export * from "./auth-retry";
+export * from "./auth-storage";
+export * from "./error/rate-limit";
+export * from "./provider-details";
+export * from "./providers/anthropic";
+export * from "./providers/anthropic-client";
+export * from "./providers/azure-openai-responses";
+export type * from "./providers/cursor";
+export * from "./providers/gitlab-duo";
+export * from "./providers/gitlab-duo-workflow";
+export type * from "./providers/google";
+export type * from "./providers/google-gemini-cli";
+export type * from "./providers/google-vertex";
+export * from "./providers/kimi";
+export * from "./providers/mock";
+export * from "./providers/ollama";
+export * from "./providers/openai-codex-responses";
+export * from "./providers/openai-completions";
+export * from "./providers/openai-responses";
+export * from "./providers/synthetic";
+export * from "./registry";
+export * from "./stream";
+export * from "./types";
+export * from "./usage";
+export * from "./usage/claude";
+export * from "./usage/gemini";
+export * from "./usage/github-copilot";
+export * from "./usage/google-antigravity";
+export * from "./usage/kimi";
+export * from "./usage/minimax-code";
+export * from "./usage/ollama";
+export * from "./usage/openai-codex";
+export * from "./usage/openai-codex-reset";
+export * from "./usage/opencode-go";
+export * from "./usage/zai";
+export * from "./utils/anthropic-auth";
+export * from "./utils/event-stream";
+export * from "./utils/openrouter-headers";
+export * from "./utils/retry";
+export * from "./utils/schema";
+export * from "./utils/thinking-loop";
+export * from "./utils/tool-call-loop-guard";
+export * from "./utils/validation";

package/dist/types/provider-details.d.ts

@@ -0,0 +1,24 @@
+import type { Api, Model, Provider, ProviderSessionState } from "./types";
+export interface ProviderDetailField {
+    label: string;
+    value: string;
+}
+export interface ProviderDetails {
+    provider: Provider;
+    api: Api;
+    fields: ProviderDetailField[];
+}
+export interface ProviderDetailsContext {
+    model: Model<Api>;
+    sessionId?: string;
+    authMode?: string;
+    /**
+     * Human-readable description of the active credential, e.g.
+     * `"broker http://omp.internal:8765 · oauth #5 (foo@bar.com)"`.
+     * Rendered as a `Source` field; omitted when undefined.
+     */
+    credentialSource?: string;
+    preferWebsockets?: boolean;
+    providerSessionState?: Map<string, ProviderSessionState>;
+}
+export declare function getProviderDetails(context: ProviderDetailsContext): ProviderDetails;

package/dist/types/providers/__tests__/google-auth.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/providers/__tests__/kimi-code-thinking.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/providers/__tests__/openai-codex-error.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/providers/amazon-bedrock.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Amazon Bedrock Converse Stream provider.
+ *
+ * Talks directly to `bedrock-runtime.{region}.amazonaws.com` over HTTPS with
+ * SigV4 signing and decodes the `application/vnd.amazon.eventstream` response.
+ * No `@aws-sdk/*`, no `@smithy/*`, no `proxy-agent`. Proxies are honored via
+ * Bun's native `HTTPS_PROXY` support.
+ */
+import type { Effort } from "jeopi-catalog/effort";
+import type { StreamFunction, StreamOptions, ThinkingBudgets } from "../types";
+export type BedrockThinkingDisplay = "summarized" | "omitted";
+export interface BedrockOptions extends StreamOptions {
+    region?: string;
+    profile?: string;
+    /** Amazon Bedrock API key sent as `Authorization: Bearer`, ahead of SigV4 credential resolution. */
+    bearerToken?: string;
+    toolChoice?: "auto" | "any" | "none" | {
+        type: "tool";
+        name: string;
+    };
+    reasoning?: Effort;
+    thinkingBudgets?: ThinkingBudgets;
+    interleavedThinking?: boolean;
+    /**
+     * Controls how Claude returns thinking content in Bedrock responses.
+     * - `"summarized"`: thinking blocks include human-readable summaries (default here).
+     * - `"omitted"`: thinking content is suppressed; the encrypted signature still
+     *   travels back for multi-turn continuity.
+     *
+     * Starting with Claude Opus 4.7 and Claude Fable/Mythos 5 the Anthropic API
+     * default is `"omitted"`, which leaves callers waiting on a silent stream during
+     * long reasoning runs (issue #1373). We default to `"summarized"` so adaptive-
+     * thinking models that accept the field keep producing visible thinking deltas.
+     * Older adaptive-thinking models (Opus 4.6, Sonnet 4.6+) reject the field, so
+     * we omit it for them.
+     */
+    thinkingDisplay?: BedrockThinkingDisplay;
+}
+export declare const streamBedrock: StreamFunction<"bedrock-converse-stream">;

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

@@ -0,0 +1,94 @@
+import { AnthropicApiError, AnthropicConnectionError, AnthropicConnectionTimeoutError } from "../error";
+export { AnthropicApiError, AnthropicConnectionError, AnthropicConnectionTimeoutError };
+import type { FetchImpl } from "../types";
+import type { MessageCreateParamsStreaming } from "./anthropic-wire";
+/** Per-request options accepted by {@link AnthropicMessages.create}. */
+export interface AnthropicRequestOptions {
+    signal?: AbortSignal;
+    /** Pre-response timeout in milliseconds. */
+    timeout?: number;
+    /** Per-request retry budget override. */
+    maxRetries?: number;
+    /** Per-request headers merged after client defaults. */
+    headers?: Record<string, string>;
+}
+/**
+ * Extra `RequestInit` fields merged into every fetch call. Bun extends
+ * `RequestInit` with a `tls` option used for the Claude Code TLS profile and
+ * Foundry mTLS. Core request fields (`method`, `headers`, `body`, `signal`)
+ * are owned by the client and cannot be overridden from here — the timeout
+ * controller's signal in particular must always win.
+ */
+export type AnthropicFetchOptions = RequestInit & {
+    tls?: {
+        rejectUnauthorized?: boolean;
+        serverName?: string;
+        ciphers?: string;
+        ca?: string | string[];
+        cert?: string;
+        key?: string;
+    };
+    /** Bun extension: see {@link FetchWithRetryOptions.timeout} — `false` disables Bun's native fetch TTFT timeout (issue #2422). */
+    timeout?: number | false;
+};
+export interface AnthropicClientOptions {
+    /** Sent as `X-Api-Key` unless the header is already present in `defaultHeaders`. */
+    apiKey?: string | null;
+    /** Sent as `Authorization: Bearer <token>` unless the header is already present in `defaultHeaders`. */
+    authToken?: string | null;
+    baseURL?: string | null;
+    maxRetries?: number;
+    /** Pre-response timeout in milliseconds. Defaults to 10 minutes. */
+    timeout?: number;
+    defaultHeaders?: Record<string, string>;
+    fetch?: FetchImpl;
+    fetchOptions?: AnthropicFetchOptions;
+}
+/** Server-suggested delay (`retry-after-ms`, then `retry-after` seconds or HTTP date). */
+export declare function retryDelayFromHeaders(headers: Headers | undefined): number | undefined;
+export declare function calculateAnthropicRetryDelayMs(attempt: number): number;
+/**
+ * Lazy in-flight request handle. The HTTP request starts on the first
+ * `asResponse()` call; subsequent calls return the same promise.
+ *
+ * Shape-compatible with the SDK's `APIPromise.asResponse()` so
+ * `getAnthropicStreamResponse` treats internal and injected clients uniformly.
+ */
+export declare class AnthropicApiRequest {
+    #private;
+    constructor(start: () => Promise<Response>);
+    asResponse(): Promise<Response>;
+}
+/**
+ * `messages` resource. `create` lives on the prototype so tests can intercept
+ * every outgoing request with `vi.spyOn(AnthropicMessages.prototype, "create")`.
+ */
+export declare class AnthropicMessages {
+    #private;
+    constructor(client: AnthropicMessagesClient, path: string);
+    create(params: MessageCreateParamsStreaming, options?: AnthropicRequestOptions): AnthropicApiRequest;
+}
+/**
+ * Structural interface satisfied by both {@link AnthropicMessagesClient} and
+ * SDK-style clients (e.g. `AnthropicVertex`), so callers can inject an
+ * alternative Messages-API client via `AnthropicOptions.client`.
+ */
+export interface AnthropicMessagesClientLike {
+    messages: {
+        create(params: MessageCreateParamsStreaming, options?: AnthropicRequestOptions): unknown;
+    };
+    beta?: {
+        messages: {
+            create(params: MessageCreateParamsStreaming, options?: AnthropicRequestOptions): unknown;
+        };
+    };
+}
+export declare class AnthropicMessagesClient implements AnthropicMessagesClientLike {
+    #private;
+    readonly messages: AnthropicMessages;
+    readonly beta: {
+        readonly messages: AnthropicMessages;
+    };
+    constructor(options: AnthropicClientOptions);
+    request(path: string, params: MessageCreateParamsStreaming, options?: AnthropicRequestOptions): AnthropicApiRequest;
+}