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

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

@@ -6,7 +6,7 @@ export type { AuthGatewayBootOptions, ModelResolver } from "./auth-gateway/serve
 export * from "./auth-gateway/types";
 export * from "./auth-retry";
 export * from "./auth-storage";
-export * from "./errors";
+export * from "./error/rate-limit";
 export * from "./provider-details";
 export * from "./providers/anthropic";
 export * from "./providers/anthropic-client";
@@ -24,7 +24,6 @@ export * from "./providers/openai-codex-responses";
 export * from "./providers/openai-completions";
 export * from "./providers/openai-responses";
 export * from "./providers/synthetic";
-export * from "./rate-limit-utils";
 export * from "./registry";
 export * from "./stream";
 export * from "./types";
@@ -43,7 +42,6 @@ export * from "./usage/zai";
 export * from "./utils/anthropic-auth";
 export * from "./utils/event-stream";
 export * from "./utils/openrouter-headers";
-export * from "./utils/overflow";
 export * from "./utils/retry";
 export * from "./utils/schema";
 export * from "./utils/thinking-loop";

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

@@ -7,12 +7,7 @@
  * Bun's native `HTTPS_PROXY` support.
  */
 import type { Effort } from "@oh-my-pi/pi-catalog/effort";
-import { ProviderHttpError } from "../errors";
 import type { StreamFunction, StreamOptions, ThinkingBudgets } from "../types";
-/** Non-2xx response (or in-stream exception event) from the Bedrock runtime API. */
-export declare class BedrockApiError extends ProviderHttpError {
-    readonly name = "BedrockApiError";
-}
 export type BedrockThinkingDisplay = "summarized" | "omitted";
 export interface BedrockOptions extends StreamOptions {
     region?: string;

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

@@ -1,4 +1,5 @@
-import { ProviderHttpError } from "../errors";
+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}. */
@@ -43,21 +44,6 @@ export interface AnthropicClientOptions {
     fetch?: FetchImpl;
     fetchOptions?: AnthropicFetchOptions;
 }
-/** 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();
-}
 /** 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;

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

@@ -24,7 +24,6 @@ type AnthropicCacheControl = NonNullable<TextBlockParam["cache_control"]>;
  * hasn't been materialized yet.
  */
 export declare function clearAnthropicFastModeFallback(providerSessionState: Map<string, ProviderSessionState> | undefined): void;
-export declare function isAnthropicFastModeUnsupportedError(error: unknown): boolean;
 export declare const claudeCodeVersion = "2.1.165";
 export declare const claudeAgentSdkVersion = "0.3.165";
 export declare const claudeClientVersion = "1.11187.4";
@@ -173,6 +172,12 @@ export type AnthropicClientOptionsResult = {
  * 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?: {

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

@@ -21,7 +21,8 @@ export interface EventStreamMessage {
     headers: Record<string, string>;
     payload: Uint8Array;
 }
-export declare function crc32(bytes: Uint8Array, seed?: number): number;
+/** 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

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

@@ -1,5 +1,6 @@
 import { type JsonValue } from "@bufbuild/protobuf";
 import type { AssistantMessage, CursorExecHandlerResult, CursorExecHandlers, CursorToolResultHandler, Message, StreamFunction, StreamOptions, TextContent, ThinkingContent, ToolCall, ToolResultMessage } from "../types";
+import { kStreamingBlockIndex, kStreamingBlockKind, kStreamingPartialJson } from "../utils/block-symbols";
 import { AssistantMessageEventStream } from "../utils/event-stream";
 export declare const CURSOR_API_URL = "https://api2.cursor.sh";
 export declare const CURSOR_CLIENT_VERSION = "cli-2026.01.09-231024f";
@@ -11,24 +12,24 @@ export interface CursorOptions extends StreamOptions {
 }
 export declare const streamCursor: StreamFunction<"cursor-agent">;
 export type ToolCallState = ToolCall & {
-    index: number;
-    partialJson?: string;
-    kind: "mcp" | "todo";
+    [kStreamingBlockIndex]: number;
+    [kStreamingPartialJson]?: string;
+    [kStreamingBlockKind]: "mcp" | "todo";
 };
 export interface BlockState {
     currentTextBlock: (TextContent & {
-        index: number;
+        [kStreamingBlockIndex]: number;
     }) | null;
     currentThinkingBlock: (ThinkingContent & {
-        index: number;
+        [kStreamingBlockIndex]: number;
     }) | null;
     currentToolCall: ToolCallState | null;
     firstTokenTime: number | undefined;
     setTextBlock: (b: (TextContent & {
-        index: number;
+        [kStreamingBlockIndex]: number;
     }) | null) => void;
     setThinkingBlock: (b: (ThinkingContent & {
-        index: number;
+        [kStreamingBlockIndex]: number;
     }) | null) => void;
     setToolCall: (t: ToolCallState | null) => void;
     setFirstTokenTime: () => void;

package/dist/types/providers/google-gemini-cli.d.ts

@@ -1,4 +1,3 @@
-import { ProviderHttpError } from "../errors";
 import type { Context, Model, ProviderSessionState, StreamFunction, StreamOptions } from "../types";
 import type { Content, FunctionCallingConfigMode, ThinkingConfig } from "./google-shared";
 import { type GoogleThinkingLevel } from "./google-shared";
@@ -7,10 +6,6 @@ import { type GoogleThinkingLevel } from "./google-shared";
  * `import { GoogleThinkingLevel } from "./google-gemini-cli"` callers keep working.
  */
 export type { GoogleThinkingLevel };
-/** Non-2xx response (or in-stream error chunk) from the Cloud Code Assist API. */
-export declare class GeminiCliApiError extends ProviderHttpError {
-    readonly name = "GeminiCliApiError";
-}
 export interface GoogleGeminiCliOptions extends StreamOptions {
     /**
      * Tool selection mode. String forms map directly to Gemini

package/dist/types/providers/google-shared.d.ts

@@ -1,17 +1,12 @@
 /**
  * Shared utilities for Google Generative AI and Google Cloud Code Assist providers.
  */
-import { ProviderHttpError } from "../errors";
 import type { AssistantMessage, Context, FetchImpl, Model, StopReason, StreamOptions, TextContent, ThinkingContent, Tool, ToolCall } from "../types";
 import { AssistantMessageEventStream } from "../utils/event-stream";
 import { normalizeSchemaForGoogle } from "../utils/schema";
 import type { Content, FinishReason, FunctionCallingConfigMode, GenerateContentParameters, GenerateContentResponse, Part } from "./google-types";
 export type { Content, FunctionCallingConfigMode, GenerateContentParameters, GenerateContentResponse, ThinkingConfig, } from "./google-types";
 export { normalizeSchemaForGoogle };
-/** Non-2xx response (or in-stream error chunk) from the Google Generative Language / Vertex API. */
-export declare class GoogleApiError extends ProviderHttpError {
-    readonly name = "GoogleApiError";
-}
 type GoogleApiType = "google-generative-ai" | "google-gemini-cli" | "google-vertex";
 /**
  * Thinking level for Gemini 3 models. Mirrors Google's `ThinkingLevel` enum values.

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

@@ -1,9 +1,4 @@
-import { ProviderHttpError } from "../errors";
 import type { StreamFunction, StreamOptions, ToolChoice } from "../types";
-/** Non-2xx response from the Ollama `/api/chat` endpoint. */
-export declare class OllamaApiError extends ProviderHttpError {
-    readonly name = "OllamaApiError";
-}
 export interface OllamaChatOptions extends StreamOptions {
     reasoning?: "minimal" | "low" | "medium" | "high" | "xhigh";
     disableReasoning?: boolean;

package/dist/types/providers/openai-codex/request-transformer.d.ts

@@ -9,11 +9,11 @@ export interface ReasoningConfig {
 export interface CodexRequestOptions {
     reasoningEffort?: ReasoningConfig["effort"];
     reasoningSummary?: ReasoningConfig["summary"] | null;
-    /** Explicit `reasoning.context` override. Defaults to `all_turns` under {@link CodexRequestOptions.responsesLite}, otherwise omitted (server default is `current_turn`). */
+    /** Explicit `reasoning.context` override; defaults to `all_turns` for every Codex request when unset. */
     reasoningContext?: CodexReasoningContext;
     textVerbosity?: "low" | "medium" | "high";
     include?: string[];
-    /** Responses Lite transport contract: strips image detail and defaults `reasoning.context` to `all_turns`, mirroring codex-rs. */
+    /** Responses Lite transport contract: strips image detail and disables parallel tool calling, mirroring codex-rs. */
     responsesLite?: boolean;
 }
 export interface InputItem {

package/dist/types/providers/openai-codex/response-handler.d.ts

@@ -1,4 +1,4 @@
-import { ProviderHttpError } from "../../errors";
+import { ProviderHttpError } from "../../error";
 export type CodexRateLimit = {
     used_percent?: number;
     window_minutes?: number;

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

@@ -4,7 +4,7 @@ import type { ResponseInput } from "./openai-responses-wire";
 export interface OpenAICodexResponsesOptions extends StreamOptions {
     reasoning?: "none" | "minimal" | "low" | "medium" | "high" | "xhigh";
     reasoningSummary?: "auto" | "concise" | "detailed" | null;
-    /** `reasoning.context` replay scope. Defaults to `all_turns` under {@link OpenAICodexResponsesOptions.responsesLite}, otherwise omitted (server default is `current_turn`). */
+    /** `reasoning.context` replay scope; defaults to `all_turns` for every Codex request when unset. */
     reasoningContext?: CodexReasoningContext;
     textVerbosity?: "low" | "medium" | "high";
     include?: string[];
@@ -17,7 +17,7 @@ export interface OpenAICodexResponsesOptions extends StreamOptions {
      * `x-openai-internal-codex-responses-lite: true` on HTTP requests and on the
      * WebSocket upgrade (the marker is connection-scoped there, so lite and
      * non-lite turns never share a pooled socket), strips image detail from
-     * input, and defaults `reasoning.context` to `all_turns` — mirroring codex-rs.
+     * input, and disables parallel tool calling — mirroring codex-rs.
      */
     responsesLite?: boolean;
     /**

package/dist/types/providers/openai-responses-server-schema.d.ts

@@ -81,6 +81,7 @@ export declare const inputItemSchema: import("arktype/internal/variants/object.t
     })[] | undefined;
 } | {
     type?: "message" | undefined;
+    id?: string | undefined;
     role: "assistant";
     content?: string | ({
         type: "text";
@@ -92,6 +93,8 @@ export declare const inputItemSchema: import("arktype/internal/variants/object.t
         type: "refusal";
         refusal: string;
     })[] | undefined;
+    status?: "completed" | "in_progress" | "incomplete" | undefined;
+    phase?: "commentary" | "final_answer" | null | undefined;
 } | {
     type: "reasoning";
     id?: string | undefined;
@@ -221,6 +224,7 @@ export declare const openaiResponsesRequestSchema: import("arktype/internal/vari
         })[] | undefined;
     } | {
         type?: "message" | undefined;
+        id?: string | undefined;
         role: "assistant";
         content?: string | ({
             type: "text";
@@ -232,6 +236,8 @@ export declare const openaiResponsesRequestSchema: import("arktype/internal/vari
             type: "refusal";
             refusal: string;
         })[] | undefined;
+        status?: "completed" | "in_progress" | "incomplete" | undefined;
+        phase?: "commentary" | "final_answer" | null | undefined;
     } | {
         type: "reasoning";
         id?: string | undefined;

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

@@ -5627,7 +5627,7 @@ export interface ResponseCreateParamsBase {
      * - [Conversation state](https://platform.openai.com/docs/guides/conversation-state)
      * - [Function calling](https://platform.openai.com/docs/guides/function-calling)
      */
-    input?: string | ResponseInput;
+    input?: ResponseInput;
     /**
      * A system (or developer) message inserted into the model's context.
      *

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

@@ -7,6 +7,7 @@ export interface OpenAIResponsesOptions extends StreamOptions {
     reasoning?: "minimal" | "low" | "medium" | "high" | "xhigh";
     reasoningSummary?: "auto" | "detailed" | "concise" | null;
     serviceTier?: ServiceTier;
+    textVerbosity?: "low" | "medium" | "high";
     toolChoice?: ToolChoice;
     openrouterVariant?: string;
     maxTokensExplicit?: boolean;
@@ -117,9 +118,9 @@ export declare function buildParams(model: Model<"openai-responses">, context: C
  * runtime path only consumes that metadata.
  * @internal Exported for tests.
  */
-export declare function supportsFreeformApplyPatch(model: Model<"openai-responses">): boolean;
+export declare function supportsFreeformApplyPatch(model: Model<"openai-responses" | "azure-openai-responses" | "openai-codex-responses">): boolean;
 /** @internal Exported for tests. */
 export declare function mapOpenAIResponsesToolChoiceForTools(choice: ToolChoice | undefined, tools: Tool[], model: Model<"openai-responses">): OpenAIResponsesToolChoice;
 /** @internal Exported for tests. */
-export declare function convertTools(tools: Tool[], strictMode: boolean, model: Model<"openai-responses">, onQuarantine?: (toolName: string, schemaPath: string) => void): OpenAITool[];
+export declare function convertTools(tools: Tool[], strictMode: boolean, model: Model<"openai-responses" | "azure-openai-responses" | "openai-codex-responses">, onQuarantine?: (toolName: string, schemaPath: string) => void): OpenAITool[];
 export {};

package/dist/types/providers/openai-shared.d.ts

@@ -1,9 +1,11 @@
 import type { OpenAICompat, OpenAIReasoningDisableMode, OpenAIStreamMarkupHealingPattern, OpenRouterRouting, ResolvedOpenAICompat, ResolvedOpenAIResponsesCompat, ResolvedOpenAISharedCompat, VercelGatewayRouting } from "@oh-my-pi/pi-catalog/types";
 import { type Api, type AssistantMessage, type CacheRetention, type Context, type ImageContent, type Message, type MessageAttribution, type Model, type Provider, type ResolvedServiceTier, type ServiceTier, type StopReason, type StreamOptions, type TextContent, type TextSignatureV1, type ThinkingContent, type Tool, type ToolCall, type ToolResultMessage } from "../types";
+import { kStreamingLastParseLen, kStreamingPartialJson } from "../utils/block-symbols";
 import type { AssistantMessageEventStream } from "../utils/event-stream";
 import type { CapturedHttpErrorResponse } from "../utils/http-inspector";
 import type { ChatCompletionCreateParamsStreaming } from "./openai-chat-wire";
-import type { ResponseContentPartAddedEvent, ResponseCreateParamsStreaming, ResponseInput, ResponseInputContent, ResponseOutputItem, ResponseOutputMessage, ResponseReasoningItem, ResponseStatus, ResponseStreamEvent } from "./openai-responses-wire";
+import type { InputItem } from "./openai-codex/request-transformer";
+import type { ResponseContentPartAddedEvent, ResponseCreateParamsStreaming, ResponseInput, ResponseInputContent, ResponseInputItem, ResponseOutputItem, ResponseOutputMessage, ResponseReasoningItem, ResponseStatus, ResponseStreamEvent } from "./openai-responses-wire";
 export interface OpenAIModelIdentity {
     provider: string;
     id: string;
@@ -373,8 +375,8 @@ export declare function appendResponsesToolResultMessages<TApi extends Api>(mess
  * each decoder's existing behavior byte-for-byte.
  */
 type ResponsesToolCallBlock = ToolCall & {
-    partialJson: string;
-    lastParseLen?: number;
+    [kStreamingPartialJson]: string;
+    [kStreamingLastParseLen]?: number;
 };
 export declare function appendReasoningSummaryPart(item: ResponseReasoningItem, part: ResponseReasoningItem["summary"][number]): void;
 export declare function appendReasoningSummaryTextDelta(item: ResponseReasoningItem, block: ThinkingContent, delta: string, stream: AssistantMessageEventStream, output: AssistantMessage, contentIndex: number): void;
@@ -494,9 +496,9 @@ export declare function populateResponsesUsageFromResponse(output: AssistantMess
  * `client_metadata` (e.g. rotating turn ids) is excluded from the option
  * comparison; codex-rs excludes it from the same check.
  */
-export declare function buildResponsesDeltaInput<TItem>(previous: {
-    input?: unknown;
+export declare function buildResponsesDeltaInput<TItem extends ResponseInputItem | InputItem>(previous: {
+    input?: TItem[];
 } | undefined, previousResponseItems: readonly TItem[] | undefined, current: {
-    input?: unknown;
+    input?: TItem[];
 }): TItem[] | null;
 export {};

package/dist/types/providers/pi-native-client.d.ts

@@ -1,13 +1,4 @@
-import { ProviderHttpError } from "../errors";
 import type { Api, AssistantMessageEventStream as AssistantMessageEventStreamType, Context, Model, SimpleStreamOptions } from "../types";
-/**
- * Non-2xx response from the auth-gateway `/v1/pi/stream` endpoint. `code`
- * carries the gateway's error-type token (`authentication_error`,
- * `rate_limit_error`, `upstream_error`, ...).
- */
-export declare class AuthGatewayError extends ProviderHttpError {
-    constructor(message: string, status: number, headers?: Headers, code?: string);
-}
 /**
  * Stream a turn through an `omp auth-gateway` over the pi-native protocol.
  *

package/dist/types/registry/oauth/xai-oauth.d.ts

@@ -1,12 +1,3 @@
-/**
- * xAI Grok (SuperGrok Subscription) OAuth flow.
- *
- * Loopback PKCE flow on `127.0.0.1:56121/callback`. One token unlocks Grok-4.x
- * chat, Grok Imagine image generation, and Grok Voice TTS via subsequent
- * commits. Endpoint discovery is hardened against MITM via
- * {@link validateXAIEndpoint}: any non-HTTPS or non-`x.ai`/`*.x.ai` host is
- * rejected on every call site, not just the first.
- */
 import type { FetchImpl } from "../../types";
 import { OAuthCallbackFlow } from "./callback-server";
 import type { OAuthController, OAuthCredentials } from "./types";

package/dist/types/types.d.ts

@@ -20,6 +20,7 @@ import type { OllamaChatOptions } from "./providers/ollama";
 import type { OpenAICodexResponsesOptions } from "./providers/openai-codex-responses";
 import type { OpenAICompletionsOptions } from "./providers/openai-completions";
 import type { OpenAIResponsesOptions } from "./providers/openai-responses";
+import type { kStreamingPartialJson } from "./utils/block-symbols";
 import type { AssistantMessageEventStream } from "./utils/event-stream";
 export type { StopDetails } from "./providers/anthropic-wire";
 export type { AssistantMessageEventStream } from "./utils/event-stream";
@@ -303,6 +304,8 @@ export interface SimpleStreamOptions extends Omit<StreamOptions, "apiKey"> {
      * Useful when the UI hides thinking blocks anyway and the summary is wasted bandwidth.
      */
     hideThinkingSummary?: boolean;
+    /** OpenAI Responses/Codex `text.verbosity` response detail level. */
+    textVerbosity?: "low" | "medium" | "high";
     /** Custom token budgets for thinking levels (token-based providers only) */
     thinkingBudgets?: ThinkingBudgets;
     /** Cursor exec handlers for local tool execution */
@@ -369,6 +372,7 @@ export interface ToolCall {
     id: string;
     name: string;
     arguments: Record<string, unknown>;
+    [kStreamingPartialJson]?: string;
     thoughtSignature?: string;
     intent?: string;
     /**
@@ -442,6 +446,8 @@ export interface AssistantMessage {
     errorMessage?: string;
     /** HTTP status surfaced by the provider when the request failed. Populated by every provider's catch block alongside `errorMessage` so consumers (auth retry, telemetry, UI) can branch without regex-scraping the message. */
     errorStatus?: number;
+    /** Structured machine-readable error classifier; see `utils/error-id.ts` for bit layout and helpers. */
+    errorId?: number;
     /**
      * Stable identifiers for request features the provider silently dropped
      * during this turn (e.g. `"priority"`). Set when a server-side rejection

package/dist/types/usage/openai-codex-base-url.d.ts

@@ -1 +1,18 @@
+/**
+ * Resolve the base URL for ChatGPT account-API requests (`wham/usage`,
+ * `wham/rate-limit-reset-credits`).
+ *
+ * These endpoints live on the canonical ChatGPT origin and authenticate with
+ * the Codex OAuth bearer minted for that origin. They are NOT part of the
+ * `/responses` API surface that streaming proxies (Headroom, 9router, etc.)
+ * forward, so a `providers.openai-codex.baseUrl` override pointed at such a
+ * proxy MUST NOT be used here — doing so 404s and silently breaks
+ * `/usage show` (issue #3679).
+ *
+ * Accepted overrides are the canonical `chatgpt.com` / `chat.openai.com`
+ * origins. Any extra path (e.g. a streaming override like
+ * `/backend-api/codex/responses`) is normalized to `${origin}/backend-api`,
+ * since the account endpoints always live directly under `/backend-api`. Any
+ * other host falls back to {@link CODEX_BASE_URL}.
+ */
 export declare function normalizeCodexBaseUrl(baseUrl?: string): string;

package/dist/types/utils/block-symbols.d.ts

@@ -0,0 +1,20 @@
+/** Stores streamed tool-call argument JSON for live renderers and parser recovery. */
+export declare const kStreamingPartialJson: unique symbol;
+/** Carries streamed tool-call argument JSON without exposing a string-keyed property. */
+export type StreamingPartialJsonCarrier = object & {
+    [kStreamingPartialJson]?: string;
+};
+/** Reads streamed tool-call argument JSON from a block or event snapshot. */
+export declare function getStreamingPartialJson(block: StreamingPartialJsonCarrier | null | undefined): string | undefined;
+/** Writes streamed tool-call argument JSON to a block or clears it with `undefined`. */
+export declare function setStreamingPartialJson(block: StreamingPartialJsonCarrier, value: string | undefined): void;
+/** Clears streamed tool-call argument JSON without deleting or changing object shape. */
+export declare function clearStreamingPartialJson(block: StreamingPartialJsonCarrier): void;
+/** Stores a provider-local stream block index without exposing a string-keyed property. */
+export declare const kStreamingBlockIndex: unique symbol;
+/** Stores the last parsed argument prefix length for throttled streaming JSON parsing. */
+export declare const kStreamingLastParseLen: unique symbol;
+/** Marks streamed tool-call arguments that already received an authoritative done payload. */
+export declare const kStreamingArgumentsDone: unique symbol;
+/** Classifies Cursor's in-flight tool-call kind without leaking provider-private state. */
+export declare const kStreamingBlockKind: unique symbol;

package/dist/types/utils/openai-http.d.ts

@@ -15,14 +15,10 @@
  *   chain-state detectors, which regex over `error.message`.
  */
 import { type SseEventObserver } from "@oh-my-pi/pi-utils";
-import { ProviderHttpError } from "../errors";
+import * as AIError from "../error";
+import { OpenAIHttpError } from "../error";
+export { OpenAIHttpError };
 import type { FetchImpl } from "../types";
-import type { CapturedHttpErrorResponse } from "./http-inspector";
-/** 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 | undefined);
-}
 export interface OpenAIStreamRequestInit {
     url: string;
     headers: Record<string, string>;
@@ -55,4 +51,4 @@ export interface OpenAIStreamHandle<TEvent> {
  */
 export declare function postOpenAIStream<TEvent>(init: OpenAIStreamRequestInit): Promise<OpenAIStreamHandle<TEvent>>;
 /** Decode a non-2xx response into an {@link OpenAIHttpError} without consuming it twice. */
-export declare function captureOpenAIHttpError(response: Response): Promise<OpenAIHttpError>;
+export declare function captureOpenAIHttpError(response: Response): Promise<AIError.OpenAIHttpError>;

package/dist/types/utils/retry.d.ts

@@ -1,17 +1,5 @@
-/**
- * GitHub Copilot intermittently rejects preview models (gpt-5.3-codex,
- * gpt-5.4, gpt-5.4-mini, ...) with HTTP 400 `model_not_supported`, even
- * though the model is listed as enabled on the user's account via `/models`.
- *
- * Root cause: Copilot's request-routing backend is rolled out per OAuth
- * client. Our OAuth client id is shared with opencode; VS Code uses its own
- * client and sees full availability, so the same account may succeed in VS
- * Code and flap between 200/400 here. See opencode#13313 and copilot-cli#2597.
- *
- * Retrying the identical request 2-3 times almost always lands on a backend
- * that has the model, so we wrap the initial request with a short retry loop.
- */
-export declare function isCopilotTransientModelError(error: unknown): boolean;
+import { isCopilotTransientModelError } from "../error/flags";
+export { isCopilotTransientModelError };
 /**
  * Wrap an initial Copilot request so transient `model_not_supported` 400s are
  * retried a small number of times. No-op for non-Copilot providers.

package/dist/types/utils/stream-markup-healing.d.ts

@@ -29,6 +29,12 @@ export type StreamMarkupHealingEvent = {
  * State machine that consumes streamed visible text and emits cleaned text,
  * thinking deltas, and reconstructed tool calls.
  *
+ * A {@link ThinkingInbandScanner} always heals leaked reasoning idioms
+ * (`<think>`, `<thinking>`, ` ```thinking `, Gemma/Harmony channels, …) out of
+ * the visible channel. For Kimi / DeepSeek-DSML the provider tool-call grammar
+ * runs first and its cleaned text is piped through that thinking healer, so a
+ * model can leak tool-call markup and reasoning in the same stream.
+ *
  * Feed only one stream channel (usually `delta.content` / `message.content`).
  * Mixing reasoning and visible text into the same instance can corrupt held-back
  * partial tag buffers.
@@ -71,8 +77,11 @@ export declare class StreamMarkupHealing {
 export declare function modelMayLeakKimiToolCalls(provider: string, modelId: string): boolean;
 /** Cheap model/provider gate for DeepSeek DSML envelope leaks. */
 export declare function modelMayLeakDsmlToolCalls(provider: string, modelId: string): boolean;
-/** Cheap model/provider gate for MiniMax plain thinking tag leaks. */
-export declare function modelMayLeakThinkingTags(provider: string, modelId: string): boolean;
-export declare function getStreamMarkupHealingPattern(provider: string, modelId: string, options?: {
-    readonly parseThinkingTags?: boolean;
-}): StreamMarkupHealingPattern | undefined;
+/**
+ * Pick the leaked-markup healer for an OpenAI-compatible / Ollama visible-text
+ * stream. Kimi chat-template tokens and DeepSeek DSML envelopes need their
+ * dedicated tool-call grammars; every other model uses `"thinking"`. All three
+ * patterns run the generic {@link ThinkingInbandScanner}, so leaked reasoning
+ * idioms (e.g. a Gemini ` ```thinking ` fence on OpenRouter) are always healed.
+ */
+export declare function getStreamMarkupHealingPattern(provider: string, modelId: string): StreamMarkupHealingPattern;

package/dist/types/utils/thinking-loop.d.ts

@@ -84,7 +84,9 @@ export declare function guardThinkingLoopStream(inner: AssistantMessageEventStre
  * Apply the loop guard around a provider dispatch. For non-guarded models
  * (or when disabled) this is a transparent pass-through. For guarded models it injects a
  * guard abort signal into the provider call so a detected loop tears down the
- * upstream, then wraps the returned stream.
+ * upstream, then wraps the returned stream. The guard only raises the retryable
+ * stall; bounding the re-samples and the final cook pass lives in the
+ * result-awaiting caller.
  */
 export declare function withGeminiThinkingLoopGuard<O extends {
     signal?: AbortSignal;

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-ai",
-	"version": "16.2.1",
+	"version": "16.2.3",
 	"description": "Unified LLM API with automatic model discovery and provider configuration",
 	"homepage": "https://omp.sh",
 	"author": "Can Boluk",
@@ -38,9 +38,9 @@
 	},
 	"dependencies": {
 		"@bufbuild/protobuf": "^2.12.0",
-		"@oh-my-pi/pi-catalog": "16.2.1",
-		"@oh-my-pi/pi-utils": "16.2.1",
-		"@oh-my-pi/pi-wire": "16.2.1",
+		"@oh-my-pi/pi-catalog": "16.2.3",
+		"@oh-my-pi/pi-utils": "16.2.3",
+		"@oh-my-pi/pi-wire": "16.2.3",
 		"arktype": "^2.2.0",
 		"zod": "^4"
 	},
@@ -62,6 +62,10 @@
 			"types": "./dist/types/index.d.ts",
 			"import": "./src/index.ts"
 		},
+		"./error": {
+			"types": "./dist/types/error/index.d.ts",
+			"import": "./src/error/index.ts"
+		},
 		"./*": {
 			"types": "./dist/types/*.d.ts",
 			"import": "./src/*.ts"

package/src/api-registry.ts

@@ -4,6 +4,8 @@
  * Allows extensions to register streaming functions for custom API types
  * (e.g., "vertex-claude-api") that are not built into stream.ts.
  */
+
+import * as AIError from "./error";
 import type {
 	Api,
 	AssistantMessageEventStream,
@@ -60,7 +62,7 @@ const customApiRegistry = new Map<string, RegisteredCustomApi>();
 
 function assertCustomApiName(api: string): void {
 	if (BUILTIN_APIS.has(api as KnownApi)) {
-		throw new Error(`Cannot register custom API "${api}": built-in API names are reserved.`);
+		throw new AIError.ConfigurationError(`Cannot register custom API "${api}": built-in API names are reserved.`);
 	}
 }