@oh-my-pi/pi-ai 16.2.1 → 16.2.2

package/CHANGELOG.md

@@ -2,6 +2,33 @@
 
 ## [Unreleased]
 
+### Changed
+
+- Default reasoning context to `all_turns` for all Codex requests
+
+## [16.2.2] - 2026-06-27
+
+### Added
+
+- Added a comprehensive, public-facing error module exported via the "./error" path, featuring structured error classification, provider-specific HTTP error classes (e.g., Anthropic, OpenAI, Gemini), OAuth/Auth-specific errors, rate-limit utilities, and retryability predicates.
+
+### Changed
+
+- Updated OpenAI Codex defaults to increase default text verbosity to medium, enable detailed reasoning summaries by default, and include all turns in the reasoning context by default.
+- Updated the OpenAI Codex WebSocket transport to resolve its configuration (via PI_CODEX_WEBSOCKET_* environment variables) once at startup rather than re-parsing on every request.
+- Enhanced cross-model reasoning recovery and preservation to render demoted reasoning in the target model's canonical inline thinking dialect (such as Gemini's thinking fence or standard think tags) to prevent leaking inert context or control tokens into history.
+- Broadened the leaked-thinking stream healer to recover reasoning emitted in any dialect's canonical idiom (including Gemini, Gemma, Harmony, and scratchpads) and route them to thinking events instead of raw markup.
+- Implemented automatic retry logic for detected thinking-loop stalls to improve response reliability.
+- Hardened stateful delta chaining to ignore transient streaming bookkeeping symbols during structural equality checks, preventing unnecessary full-transcript replays.
+
+### Fixed
+
+- Fixed preservation of OpenAI Responses assistant message phase values across auth-gateway parsing, streaming, and history replay, ensuring GPT-5.4/GPT-5.5 intermediate updates and final answers retain their original phase labels.
+
+### Removed
+
+- Removed Pi dialect support and related serialization/parsing logic.
+
 ## [16.2.0] - 2026-06-27
 
 ### Breaking Changes

package/dist/types/auth-gateway/server.d.ts

@@ -33,23 +33,4 @@ export interface AuthGatewayBootOptions extends AuthGatewayServerOptions {
     /** Optional supplier for `/v1/models` listing. Returns the full model array. */
     listModels?: () => Iterable<Model<Api>>;
 }
-/**
- * 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): {
-    status: number;
-    type: string;
-    message: string;
-};
 export declare function startAuthGateway(opts: AuthGatewayBootOptions): AuthGatewayServerHandle;

package/dist/types/auth-retry.d.ts

@@ -1,4 +1,5 @@
 import type { OAuthAccess } from "./auth-storage";
+import { isAuthRetryableError } from "./error/auth-classify";
 /**
  * Context passed to an {@link ApiKeyResolver} on each resolution attempt.
  *
@@ -46,16 +47,7 @@ export declare function resolveApiKeyOnce(key: ApiKey | undefined, signal?: Abor
  * `resolver`.
  */
 export declare function seedApiKeyResolver(seed: string | undefined, resolver: ApiKeyResolver): ApiKeyResolver;
-/**
- * Classifies whether an error should trigger a credential refresh/rotation
- * retry: a hard `401`, body-classified usage limit (Codex
- * `usage_limit_reached`, Anthropic account rate-limit, Google
- * `resource_exhausted`, OpenAI `insufficient_quota`, …), or a bare `429`
- * whose payload did not preserve a richer quota code. Transient 429s
- * (`Too many requests`, per-minute caps) classify as `RATE_LIMIT_EXCEEDED`
- * via {@link parseRateLimitReason} and stay in the upstream-backoff lane.
- */
-export declare function isAuthRetryableError(error: unknown): boolean;
+export { isAuthRetryableError };
 /**
  * The ordered `lastChance` values for the retry steps after the initial
  * attempt fails: `false` → step (b) refresh-same, `true` → step (c) switch.

package/dist/types/auth-storage.d.ts

@@ -391,7 +391,7 @@ export type AuthStorageOptions = {
      */
     fetchUsageReports?: (signal?: AbortSignal) => Promise<UsageReport[] | null>;
 };
-export declare function isDefinitiveOAuthFailure(errorMsg: string): boolean;
+export { isDefinitiveOAuthFailure } from "./error/auth-classify";
 /**
  * Outcome of {@link AuthStorage.markUsageLimitReached}.
  *
@@ -1023,4 +1023,3 @@ export declare class SqliteAuthCredentialStore implements AuthCredentialStore {
     deleteProvider(provider: string): void;
     close(): void;
 }
-export {};

package/dist/types/dialect/demotion.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Wrap a prior-turn reasoning string for demotion into native conversation
+ * history — the cross-provider / cross-model case where the target cannot replay
+ * it as a structured thinking block (verified end-to-end against Gemini 3: a
+ * replayed unsigned `thought` part is schema-accepted but silently discarded —
+ * neither recalled nor influencing generation).
+ *
+ * The reasoning is rendered in the TARGET model's canonical inline thinking
+ * delimiters so it reads as reasoning in that model's own idiom instead of bare
+ * prose the model might continue. Harmony and Gemma are the exception: their
+ * `renderThinking` emits chat-template control tokens (`<|channel|>analysis`,
+ * `<|channel>thought`) that must not appear inside a structured native message,
+ * so they fall back to a plain `<think>` block. Every other dialect's thinking
+ * form is inline-safe XML tags or a markdown fence.
+ *
+ * The result ends with a trailing newline so the block stays separated from the
+ * turn's reply text when the wire encoder concatenates parts.
+ *
+ * Distinct from {@link DialectDefinition.renderThinking}, which targets the
+ * owned-dialect *text transport* where those control tokens are legal.
+ */
+export declare function renderDemotedThinking(modelId: string, text: string): string;

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

@@ -1,9 +1,11 @@
 export * from "./catalog";
 export * from "./coercion";
+export * from "./demotion";
 export * from "./examples";
 export * from "./factory";
 export * from "./history";
 export * from "./inventory";
 export * from "./owned-stream";
 export { renderDelimitedThinking } from "./rendering";
+export * from "./thinking";
 export * from "./types";

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

@@ -0,0 +1,14 @@
+/**
+ * A request was cancelled — by the caller's `AbortSignal` or a provider-local
+ * watchdog. Carries the {@link Flag.Abort} classification structurally so retry
+ * logic does not have to regex the message text.
+ *
+ * The default message is kept byte-identical to the historical
+ * `"Request was aborted"` string so any remaining text-based matchers keep
+ * working through the migration.
+ */
+export declare class AbortError extends Error {
+    constructor(message?: string, options?: {
+        cause?: unknown;
+    });
+}

package/dist/types/error/auth-classify.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Whether an OAuth refresh failure is definitive (the credential must be
+ * disabled) versus transient. Thin alias over the {@link Flag.OAuthExpiry}
+ * text classifier {@link isOAuthExpiry}; retained as the public
+ * `@oh-my-pi/pi-ai` entrypoint name used by the coding agent and auth-broker.
+ */
+export declare function isDefinitiveOAuthFailure(errorMsg: string): boolean;
+/**
+ * Whether an upstream failure should rotate to a sibling credential: a hard
+ * `401`, a body-classified usage limit (Codex `usage_limit_reached`, Anthropic
+ * account rate-limit, Google `resource_exhausted`, OpenAI `insufficient_quota`,
+ * …), or a bare `429` whose payload did not preserve a richer quota code.
+ * Transient 429s (`Too many requests`, per-minute caps) stay in the
+ * upstream-backoff lane.
+ */
+export declare function isAuthRetryableError(error: unknown): boolean;

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

@@ -0,0 +1,27 @@
+/**
+ * No API key / credential was available to dispatch a request.
+ *
+ * The default message preserves the historical `"No API key for provider: X"`
+ * wording, which {@link Flag.AuthFailed}'s regex (`no api key`) keys off — but
+ * the flag is also attached structurally so classification never depends on the
+ * exact phrasing.
+ */
+export declare class MissingApiKeyError extends Error {
+    readonly provider: string | undefined;
+    constructor(provider?: string, message?: string);
+}
+/** A user-facing login flow required an `onPrompt` callback that was not supplied. */
+export declare class OnPromptRequiredError extends Error {
+    constructor(providerLabel: string);
+}
+/** An interactive login asked for an API key but the user supplied an empty value. */
+export declare class ApiKeyRequiredError extends Error {
+    constructor(message?: string);
+}
+/**
+ * A user cancelled an interactive login / device flow. Classified as an abort
+ * so it is never surfaced as a retryable transient failure.
+ */
+export declare class LoginCancelledError extends Error {
+    constructor(message?: string);
+}

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

@@ -0,0 +1,23 @@
+/** Which AWS credential-resolution path failed. */
+export type AwsCredentialsErrorKind = 
+/** No usable credential source resolved (chain exhausted). */
+"resolution"
+/** SSO cache token missing (`aws sso login` not run). */
+ | "sso-token-missing"
+/** SSO cache token present but expired. */
+ | "sso-token-expired"
+/** SSO `GetRoleCredentials` call failed or returned no role. */
+ | "sso-role"
+/** External `credential_process` failed, timed out, or emitted bad output. */
+ | "credential-process";
+/** A failure resolving AWS credentials for the Bedrock provider. */
+export declare class AwsCredentialsError extends Error {
+    readonly kind: AwsCredentialsErrorKind;
+    constructor(message: string, kind: AwsCredentialsErrorKind, options?: {
+        cause?: unknown;
+    });
+}
+/** A malformed AWS event-stream frame (bad length, CRC mismatch, unknown header type). */
+export declare class EventStreamFrameError extends Error {
+    constructor(detail: string);
+}

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

@@ -0,0 +1,102 @@
+import type { CapturedHttpErrorResponse } from "../utils/http-inspector";
+/** Prefix on errors raised when an Anthropic SSE stream envelope is malformed. */
+export declare const STREAM_ENVELOPE_ERROR_PREFIX = "Anthropic stream envelope error:";
+/** Structured HTTP errors thrown by provider clients. */
+export interface ProviderHttpErrorOptions {
+    /** Response headers; enables `retry-after`/rate-limit extraction downstream. */
+    headers?: Headers;
+    /** Machine-readable error code from the response body (`error.code` / `error.type`). */
+    code?: string;
+    cause?: unknown;
+}
+/** Non-2xx HTTP response from a provider. */
+export declare class ProviderHttpError extends Error {
+    readonly status: number;
+    readonly headers: Headers | undefined;
+    readonly code: string | undefined;
+    constructor(message: string, status: number, options?: ProviderHttpErrorOptions);
+}
+/** Non-2xx response from an OpenAI-wire endpoint, with the decoded body attached. */
+export declare class OpenAIHttpError extends ProviderHttpError {
+    readonly captured: CapturedHttpErrorResponse;
+    constructor(message: string, captured: CapturedHttpErrorResponse, code?: string, cause?: unknown);
+    /**
+     * Pull a human-readable message and machine code out of an OpenAI-style error
+     * envelope (`{ error: { message, code, type } }`), tolerating the flat shapes
+     * compat hosts return (`{ error: "..." }`, `{ message: "..." }`) and falling
+     * back to the raw body text.
+     */
+    static parseEnvelope(bodyJson: unknown, bodyText: string | undefined): {
+        detail: string | undefined;
+        code: string | undefined;
+    };
+}
+/** Non-2xx response from the Anthropic API. */
+export declare class AnthropicApiError extends ProviderHttpError {
+    readonly headers: Headers;
+    readonly requestId: string | null;
+    constructor(status: number, message: string, headers: Headers);
+    static fromResponse(response: Response): Promise<AnthropicApiError>;
+}
+/** Network-level failure (DNS, TLS, socket reset) after retries were exhausted. */
+export declare class AnthropicConnectionError extends Error {
+    constructor(cause: unknown);
+}
+/** No response headers arrived within the configured request timeout. */
+export declare class AnthropicConnectionTimeoutError extends Error {
+    constructor();
+}
+/**
+ * A malformed Anthropic SSE stream envelope — events arriving out of order
+ * (before `message_start`) or otherwise violating the message-event grammar.
+ * The message is prefixed with {@link STREAM_ENVELOPE_ERROR_PREFIX} so the
+ * shared envelope predicates classify it.
+ */
+export declare class AnthropicStreamEnvelopeError extends Error {
+    constructor(detail: string);
+}
+/** Non-2xx response (or in-stream exception event) from the Bedrock runtime API. */
+export declare class BedrockApiError extends ProviderHttpError {
+    readonly name = "BedrockApiError";
+}
+/** Non-2xx response (or in-stream error chunk) from the Cloud Code Assist API. */
+export declare class GeminiCliApiError extends ProviderHttpError {
+    readonly name = "GeminiCliApiError";
+}
+/** Non-2xx response (or in-stream error chunk) from the Google Generative Language / Vertex API. */
+export declare class GoogleApiError extends ProviderHttpError {
+    readonly name = "GoogleApiError";
+}
+/** Non-2xx response from the Ollama `/api/chat` endpoint. */
+export declare class OllamaApiError extends ProviderHttpError {
+    readonly name = "OllamaApiError";
+}
+/** Auth gateway HTTP failure. */
+export declare class AuthGatewayError extends ProviderHttpError {
+    constructor(message: string, status: number, headers?: Headers, code?: string);
+}
+export declare class CodexWebSocketTransportError extends Error {
+    constructor(detail: string);
+}
+export declare class CodexWhitespaceToolCallLoopError extends Error {
+    constructor(message: string);
+}
+export declare class CodexProviderStreamError extends Error {
+    readonly retryable: boolean;
+    constructor(message: string, options?: {
+        retryable?: boolean;
+        cause?: unknown;
+    });
+}
+export declare class AuthBrokerError extends Error {
+    readonly status: number | undefined;
+    readonly body: string | undefined;
+    constructor(message: string, opts?: {
+        status?: number;
+        body?: string;
+        cause?: unknown;
+    });
+}
+export declare class AuthBrokerStreamUnsupportedError extends AuthBrokerError {
+    constructor(message?: string);
+}

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,70 @@
+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 TRANSIENT_TRANSPORT_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 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; `"github-copilot"` triggers the copilot message rewrite. */
+    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/{rate-limit-utils.d.ts → error/rate-limit.d.ts}

@@ -43,4 +43,17 @@ export declare function isUsageLimitStatus(status: number | undefined): boolean;
  *     credentials.
  */
 export declare function isUsageLimitOutcome(status: number | undefined, message: string | undefined): boolean;
-export declare function isUsageLimitError(errorMessage: string): 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;
+    });
+}