@linxiraos/pi-ai 1.0.0

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

@@ -0,0 +1,39 @@
+import type { Api } from "../types.js";
+import type { AbortSourceTracker } from "../utils/abort.js";
+import type { CapturedHttpErrorResponse, RawHttpRequestDump } from "../utils/http-inspector.js";
+/** 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,94 @@
+import type { Api, AssistantMessage } from "../types.js";
+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 ContentBlocked: 32768;
+    readonly ContextOverflow: 8388608;
+    readonly AuthFailed: 16777216;
+    readonly SilentAbort: 33554432;
+    readonly UserInterrupt: 67108864;
+    readonly Abort: 134217728;
+    /** Strict-tool rejection (400): grammar too large, schema too complex, or structured outputs unsupported by the model/endpoint. */
+    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;
+/** Persisted-text form of {@link isStreamEnvelopeError}: recognizes the
+ *  prefix-tagged envelope diagnostic on an aborted turn's `errorMessage` /
+ *  `stopDetails.explanation` so loop-level salvage can classify it after the
+ *  original `Error` instance is gone. */
+export declare function isStreamEnvelopeErrorText(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;
+/**
+ * Strict-tool rejection: grammar too large, schema too complex, or structured
+ * outputs unsupported by the model/endpoint.
+ * 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` response for a model advertised by
+ * `/models` — transient fleet skew, not a malformed request. Reads the
+ * structural `code` through the SDK/body envelopes, then falls back to the
+ * stringified body both SDK families put in `message`.
+ */
+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.
+ *
+ * Strings (persisted `stopDetails.explanation`/`errorMessage` diagnostics) are matched with the
+ * stricter {@link STREAM_PARSE_DIAGNOSTIC_PATTERN} — bare "truncated"/"end of file" text is too
+ * low-signal to trust once detached from a live transport `Error`, which keeps the broad pattern.
+ */
+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.js";
+/** 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,14 @@
+export * from "./abort.js";
+export * from "./auth.js";
+export * from "./auth-classify.js";
+export * from "./aws.js";
+export * from "./classes.js";
+export * from "./finalize.js";
+export * from "./flags.js";
+export * from "./format.js";
+export * from "./gateway.js";
+export * from "./oauth.js";
+export * from "./provider.js";
+export * from "./rate-limit.js";
+export * from "./retryable.js";
+export * from "./validation.js";

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.js";
+/** 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,80 @@
+/**
+ * Rate limit reason classification and backoff calculation utilities.
+ * Ported from opencode-antigravity-auth plugin for consistency.
+ */
+export type RateLimitReason = "QUOTA_EXHAUSTED" | "RATE_LIMIT_EXCEEDED" | "CONCURRENT_LIMIT" | "MODEL_CAPACITY_EXHAUSTED" | "SERVER_ERROR" | "UNKNOWN";
+/**
+ * Classify a rate-limit error message into a reason category.
+ * Priority order: explicit details in a resource-exhausted error > QUOTA
+ * (Antigravity "quota will reset") > CONCURRENT_LIMIT > MODEL_CAPACITY >
+ * QUOTA (account) > RATE_LIMIT > QUOTA (generic) > SERVER_ERROR > bare resource-exhausted > UNKNOWN.
+ *
+ * Bare "resource exhausted" / "resource_exhausted" maps to MODEL_CAPACITY (transient, short wait).
+ * Explicit details such as "quota exceeded" retain their normal classification.
+ */
+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.
+ * HTTP 402 Payment Required is categorically an account-billing cap (xAI
+ * Grok Build "usage balance exhausted", DeepSeek "Insufficient Balance",
+ * OpenRouter credit exhaustion) — never a transient blip or bad credential.
+ * 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 a usage-limit status (429/402) → 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}. `QUOTA_EXHAUSTED`
+ *     rotates; for the categorical 402 billing cap a `CONCURRENT_LIMIT` body
+ *     also rotates (the cap is concurrent-worded but the status is still an
+ *     exhausted billing cap). `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 usage-limit status 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.js").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;
+/**
+ * Account-scoped cap phrasing delivered on a 403 (or a statusless Connect
+ * trailer): "Reached overall message rate limit", "Your limit will reset in …".
+ * Kept separate from {@link matchesUsageLimitText} because the bare wording is
+ * ambiguous without the 403 / statusless-account context; consumed by both
+ * {@link isUsageLimitOutcome} (rotation decision) and `flags.ts` (Flag.UsageLimit).
+ */
+export declare function isAccountScopedCapText(message: string): boolean;
+/**
+ * A concurrency cap on a non-billing status is shed-and-backoff, not
+ * credential-rotatable. This mirrors the exclusion in {@link isUsageLimitOutcome}
+ * for the 403 auth-retry entry points. A 402 remains a categorical billing cap.
+ */
+export declare function isConcurrencyCapExclusion(status: number | undefined, message: string | undefined): 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-availability 400s). */
+    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,51 @@
+export { type Type, type } from "@linxiraos/pi-omptype";
+export * from "./api-registry.js";
+export type * from "./auth-broker/index.js";
+export type { AuthGatewayBootOptions, ModelResolver } from "./auth-gateway/server.js";
+export * from "./auth-gateway/types.js";
+export * from "./auth-retry.js";
+export * from "./auth-storage.js";
+export * from "./error/rate-limit.js";
+export * from "./provider-details.js";
+export * from "./providers/anthropic.js";
+export * from "./providers/anthropic-client.js";
+export * from "./providers/azure-openai-responses.js";
+export type * from "./providers/cursor.js";
+export * from "./providers/gitlab-duo.js";
+export * from "./providers/gitlab-duo-workflow.js";
+export type * from "./providers/google.js";
+export type * from "./providers/google-gemini-cli.js";
+export type * from "./providers/google-vertex.js";
+export * from "./providers/kimi.js";
+export * from "./providers/mock.js";
+export * from "./providers/ollama.js";
+export * from "./providers/openai-codex-responses.js";
+export * from "./providers/openai-completions.js";
+export * from "./providers/openai-responses.js";
+export * from "./providers/synthetic.js";
+export * from "./registry/index.js";
+export * from "./stream.js";
+export * from "./types.js";
+export * from "./usage.js";
+export * from "./usage/claude.js";
+export * from "./usage/cursor.js";
+export * from "./usage/gemini.js";
+export * from "./usage/github-copilot.js";
+export * from "./usage/google-antigravity.js";
+export * from "./usage/kimi.js";
+export * from "./usage/minimax-code.js";
+export * from "./usage/ollama.js";
+export * from "./usage/openai-codex.js";
+export * from "./usage/openai-codex-reset.js";
+export * from "./usage/opencode-go.js";
+export * from "./usage/synthetic.js";
+export * from "./usage/xai-oauth.js";
+export * from "./usage/zai.js";
+export * from "./utils/anthropic-auth.js";
+export * from "./utils/event-stream.js";
+export * from "./utils/openrouter-headers.js";
+export * from "./utils/retry.js";
+export * from "./utils/schema/index.js";
+export * from "./utils/thinking-loop.js";
+export * from "./utils/tool-call-loop-guard.js";
+export * from "./utils/validation.js";

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

@@ -0,0 +1,24 @@
+import type { Api, Model, Provider, ProviderSessionState } from "./types.js";
+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/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 "@linxiraos/pi-catalog/effort";
+import type { StreamFunction, StreamOptions, ThinkingBudgets } from "../types.js";
+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,106 @@
+import { AnthropicApiError, AnthropicConnectionError, AnthropicConnectionTimeoutError } from "../error/index.js";
+export { AnthropicApiError, AnthropicConnectionError, AnthropicConnectionTimeoutError };
+import type { FetchImpl } from "../types.js";
+import type { MessageCreateParamsStreaming } from "./anthropic-wire.js";
+/** 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;
+    /**
+     * Maximum delay in milliseconds to wait for a server-directed retry. If the
+     * server's `retry-after` hint exceeds this value, the retry is declined and
+     * the original error is surfaced. Non-positive values disable the cap. Defaults to 60000.
+     */
+    maxRetryDelayMs?: 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;
+    /**
+     * Maximum delay in milliseconds to wait for a server-directed retry. If the
+     * server's `retry-after` hint exceeds this value, the retry is declined and
+     * the original error is surfaced. Non-positive values disable the cap. Defaults to 60000.
+     */
+    maxRetryDelayMs?: 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: Pick<Headers, "get"> | 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;
+}