@oh-my-pi/pi-ai 18.2.6 → 18.2.7

package/CHANGELOG.md

@@ -2,6 +2,18 @@
 
 ## [Unreleased]
 
+## [18.2.7] - 2026-09-21
+
+### Breaking Changes
+
+- Anthropic streaming and provider request helpers must now be imported from `@oh-my-pi/pi-ai/providers/anthropic` instead of the package root.
+- Moved the public `NO_AUTH_SENTINEL` export from `providers/openai-shared` to `auth-retry`.
+
+### Fixed
+
+- Anthropic organization-level OAuth permission errors now reliably rotate to sibling credentials and persist blocks across usage reports.
+- Fixed error handling for provider responses that do not include token usage information.
+
 ## [18.2.6] - 2026-09-18
 
 ### Fixed
@@ -78,7 +90,7 @@
 - Fixed openai-responses replay wedging a repaired orphan tool-result note between another call's `function_call` and `function_call_output`, which broke round pairing on strict validators (e.g. DeepSeek) with `400 No tool output found for tool call …`: orphan-output/call repair now runs before the interleaved-message hoist, so any injected note is relocated out of the tool-call batch ([#11473](https://github.com/can1357/oh-my-pi/issues/11473)).
 - A stale Anthropic tier block (`tier:fable`, `tier:mythos`) is now cleared once a live usage report shows headroom on both the tier row and the shared windows, instead of idling a usable account until the reported reset. Healing requires a live report, and a credential held by an unscoped block spends no usage request on a probe that cannot lift it ([#11334](https://github.com/can1357/oh-my-pi/pull/11334) by [@AshishKumar4](https://github.com/AshishKumar4)).
 - A running session now picks up credentials another process committed: adding an account in a second terminal is visible to credential selection and rotation without restarting the session, and a session's pinned account is re-resolved by row id so a row another process deleted cannot hand its slot to a sibling ([#11329](https://github.com/can1357/oh-my-pi/pull/11329) by [@AshishKumar4](https://github.com/AshishKumar4)).
-- Fixed rate-limit/overload failures that arrive *inside* an HTTP 200 body (Azure, LiteLLM-style aggregators, and reverse proxies that already committed to the stream) not advancing `retry.fallbackChains`: a `{"error":{…}}`/`{"code":429}` chunk or a plain-text throttle frame (`429 Too Many Requests`, an nginx page) is now classified as a retryable 429/5xx through the same path an HTTP-status 429 takes, so a busy provider backs off and fails over instead of ending the session. Only bodies the provider actually reported are used: no status is inferred from error wording, and an unreadable body can no longer consume a credential.
+- Fixed rate-limit/overload failures that arrive _inside_ an HTTP 200 body (Azure, LiteLLM-style aggregators, and reverse proxies that already committed to the stream) not advancing `retry.fallbackChains`: a `{"error":{…}}`/`{"code":429}` chunk or a plain-text throttle frame (`429 Too Many Requests`, an nginx page) is now classified as a retryable 429/5xx through the same path an HTTP-status 429 takes, so a busy provider backs off and fails over instead of ending the session. Only bodies the provider actually reported are used: no status is inferred from error wording, and an unreadable body can no longer consume a credential.
 - Fixed tool schema normalization and cycle detection for frozen, sealed, and nonextensible schemas.
 - Reduced memory retained by `complete()` and `completeSimple()` while streaming responses.
 - Antigravity quota summaries now identify Claude/GPT routing copies as one shared upstream pool while preserving model-specific quota selection ([#11268](https://github.com/can1357/oh-my-pi/issues/11268)).

package/THIRD-PARTY-NOTICES.txt

@@ -335,43 +335,6 @@ This license allows the work and adaptations of it to be shared and used
 commercially, as long as it is attributed to Poppy Works. The font is bundled
 here (crates/pi-natives/src/fonts/Silver.ttf) as a CJK/Unicode bitmap fallback.
 
--------------------------------------------------------------------------------
-packages/utils/src/vendor/mermaid-ascii/NOTICE
-
-This directory contains an in-house Mermaid-diagram-to-ASCII renderer adapted
-from beautiful-mermaid (https://github.com/lukilabs/beautiful-mermaid), used
-under the MIT License.
-
-  Copyright (c) 2026 Craft Docs
-
-Only the ASCII rendering pipeline is ported (flowchart/state, sequence, class,
-ER, and xychart diagrams); the SVG renderer and its `elkjs` graph-layout
-dependency, the browser entry point, and the SVG theme/style modules were
-dropped. Terminal display width is reimplemented on `Bun.stringWidth`, and
-inline label formatting (HTML tags, markdown emphasis) is reduced to plain text
-for ASCII output. Layout and edge-routing logic is preserved faithfully so
-ASCII output matches the upstream package.
-
-MIT License
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
-
 -------------------------------------------------------------------------------
 packages/coding-agent/src/markit/NOTICE
 

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

@@ -35,6 +35,8 @@ export interface ApiKeyResolveContext {
 export type ApiKeyResolver = (ctx: ApiKeyResolveContext) => Promise<string | undefined> | string | undefined;
 /** A static bearer string, or a {@link ApiKeyResolver} that mints/rotates one. */
 export type ApiKey = string | ApiKeyResolver;
+/** Keyless-provider credential marker; transports must not send it in authentication headers. */
+export declare const NO_AUTH_SENTINEL = "N/A";
 /** Narrows {@link ApiKey} to its resolver form. */
 export declare function isApiKeyResolver(key: ApiKey | undefined): key is ApiKeyResolver;
 /**

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

@@ -1218,8 +1218,8 @@ export declare class AuthStorage {
      * stale session stickiness. Fall back to the session-sticky credential only
      * when neither explicit target is available. For hard-auth errors, an explicit
      * target that no longer matches storage returns `false` without mutation.
-     * Delayed usage-limit errors may instead recover the durable OAuth row from
-     * the bearer fingerprint recorded when the request resolved.
+     * Delayed usage-limit and account-policy errors may instead recover the durable
+     * OAuth row from the bearer fingerprint recorded when the request resolved.
      *
      * - usage-limit / account-rate-limit error → {@link AuthStorage.markUsageLimitReached}
      *   (temporary block via its own backoff — default plus server usage-report

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

@@ -39,7 +39,10 @@ export declare const __anthropicApiErrorForTesting: {
 export declare class AnthropicApiError extends ProviderHttpError {
     readonly headers: Headers;
     readonly requestId: string | null;
-    constructor(status: number, message: string, headers: Headers);
+    constructor(status: number, message: string, headers: Headers, options?: {
+        code?: string;
+        cause?: unknown;
+    });
     static fromResponse(response: Response, signal?: AbortSignal): Promise<AnthropicApiError>;
 }
 /** Network-level failure (DNS, TLS, socket reset) after retries were exhausted. */

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

@@ -1,4 +1,4 @@
-import type { Api, AssistantMessage } from "../types.js";
+import type { Api, AssistantMessage, Usage } from "../types.js";
 export declare const Flag: {
     readonly Class: 4096;
     readonly ThinkingLoop: 65536;
@@ -44,6 +44,9 @@ export declare function isResponsesRequestBodyReadTimeout(message: {
     requestBodyReadTimeoutFullReplay?: boolean;
 }): boolean;
 export declare const TRANSIENT_TRANSPORT_PATTERN: RegExp;
+export declare const ANTHROPIC_ACCOUNT_POLICY_PATTERN: RegExp;
+/** Whether an error message represents an Anthropic account-scoped permission/policy denial. */
+export declare function isAnthropicAccountPolicyText(text: string, provider?: string, statusArg?: number): boolean;
 /**
  * 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
@@ -121,16 +124,21 @@ export declare function classifyMessage(message: {
     errorStatus?: number;
 }): number;
 export declare function attach<E extends object>(error: E, id: number): E;
+/** Overflow-classification evidence, including errors received before token usage is available. */
+export interface ContextOverflowMessage extends Pick<AssistantMessage, "errorId" | "stopReason" | "errorMessage"> {
+    readonly usage?: Pick<Usage, "input" | "cacheRead" | "cacheWrite">;
+}
 /** Provider-reported usage proves context-window excess — authoritative, compaction-owned (#9235). */
-export declare function isUsageBackedContextOverflow(message: AssistantMessage, contextWindow?: number): boolean;
-export declare function isContextOverflow(message: AssistantMessage, contextWindow?: number): boolean;
+export declare function isUsageBackedContextOverflow(message: ContextOverflowMessage, contextWindow?: number): boolean;
+/** Classify overflow from error flags, available token usage, or provider error text. */
+export declare function isContextOverflow(message: ContextOverflowMessage, contextWindow?: number): boolean;
 /** HTTP 413 byte/media rejection (#9235); may co-occur with {@link isContextOverflow} for bare `413 (no body)`.
  *  Callers with local headroom should skip compaction when this returns true. */
 export declare function isPayloadRejection(message: AssistantMessage): boolean;
 /** Dual-flagged 413 (PayloadRejected + ContextOverflow) with no provider-reported token excess (#9235).
  *  The co-flag means a different provider's larger byte/media budget may accept the request.
  *  Usage-backed overflows are authoritative window excesses and never ambiguous. */
-export declare function isTextAmbiguousContextOverflow(errorId: number, message: AssistantMessage | undefined, contextWindow?: number): boolean;
+export declare function isTextAmbiguousContextOverflow(errorId: number, message: ContextOverflowMessage | undefined, contextWindow?: number): boolean;
 export declare function stringify(id: number | undefined): string;
 /**
  * Transient stream corruption where the response was truncated mid-JSON.

package/dist/types/index.d.ts

@@ -10,22 +10,24 @@ export * from "./judgment/index.js";
 export * from "./oneshot-retry.js";
 export * from "./provider-details.js";
 export * from "./provider-session-state.js";
-export * from "./providers/anthropic.js";
-export * from "./providers/anthropic-client.js";
-export * from "./providers/azure-openai-responses.js";
+export type * from "./providers/anthropic.js";
+export * from "./providers/anthropic-identity.js";
+export * from "./providers/anthropic-state.js";
+export type * from "./providers/anthropic-client.js";
+export type * 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/gitlab-duo.js";
+export type * 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 type * from "./providers/kimi.js";
+export type * from "./providers/mock.js";
+export type * from "./providers/ollama.js";
+export type * from "./providers/openai-codex-responses.js";
+export type * from "./providers/openai-completions.js";
+export type * from "./providers/openai-responses.js";
+export type * from "./providers/synthetic.js";
 export * from "./registry/index.js";
 export * from "./stream.js";
 export * from "./types.js";

package/dist/types/judgment/types.d.ts

@@ -99,5 +99,8 @@ export declare class JudgmentParseError extends Error {
     readonly output: string;
     constructor(questionId: string, output: string, detail: string);
 }
-/** Zero-cost usage for a request whose backend reports only token counts. */
-export declare function tokenUsage(input: number, output: number): Usage;
+/**
+ * Usage from a backend that reports token counts and, optionally, one billed
+ * USD amount. Judgment pricing is input-only, so the amount lands on `input`.
+ */
+export declare function tokenUsage(input: number, output: number, cost?: number): Usage;

package/dist/types/judgment/typesafe.d.ts

@@ -1,28 +1,28 @@
-/**
- * TypeSafe System One client: the native {@link Judge} backend.
- *
- * Forwards a {@link JudgmentRequest} verbatim to `POST /v1/systemone` and maps
- * the typed answers back. Credentials flow through {@link withAuth}, so a
- * stored key rotates on 401/403 exactly like chat providers; transient
- * 429/5xx responses retry with bounded, `retry-after`-aware backoff.
- *
- * Environment (mirrors the official SDK): `TYPESAFE_API_KEY` is resolved by
- * the auth registry (`rules/auth/typesafe.kdl`), `TYPESAFE_BASE_URL`
- * overrides the API root, `TYPESAFE_DEFAULT_MODEL` the model.
- */
-import type { FetchImpl } from "@oh-my-pi/pi-catalog/types";
+import type { Api, FetchImpl } from "@oh-my-pi/pi-catalog/types";
 import { type ApiKey } from "../auth-retry.js";
 import * as AIError from "../error/index.js";
 import { type Judge, type JudgeOptions, type JudgmentRequest, type JudgmentResult, type Questions } from "./types.js";
 export declare const TYPESAFE_PROVIDER = "typesafe";
-export declare const TYPESAFE_DEFAULT_BASE_URL = "https://api.typesafe.ai";
 export declare const TYPESAFE_DEFAULT_MODEL = "jev-latest";
+/** Judgment `POST` path under a model's base URL, per System One–compatible API. */
+export declare const JUDGMENT_ROUTES: {
+    readonly typesafe: "/v1/systemone";
+    readonly "openrouter-decisions": "/decisions";
+};
+/** APIs {@link TypeSafeJudge} can serve. */
+export type JudgmentApi = keyof typeof JUDGMENT_ROUTES;
+/** Whether a catalog API answers System One judgments natively. */
+export declare function isJudgmentApi(api: Api): api is JudgmentApi;
 /** `TYPESAFE_BASE_URL` when set, else the public API root; trailing slashes stripped. */
 export declare function typesafeBaseUrl(): string;
 /** `TYPESAFE_DEFAULT_MODEL` when set, else {@link TYPESAFE_DEFAULT_MODEL}. */
 export declare function typesafeModel(): string;
 export interface TypeSafeJudgeOptions {
     apiKey: ApiKey;
+    /** Wire route; defaults to TypeSafe's own API. */
+    api?: JudgmentApi;
+    /** Catalog provider reported on results; defaults to {@link TYPESAFE_PROVIDER}. */
+    provider?: string;
     /** Defaults to {@link typesafeBaseUrl}. */
     baseUrl?: string;
     /** Defaults to {@link typesafeModel}. */
@@ -35,19 +35,13 @@ export interface TypeSafeJudgeOptions {
 export declare class TypeSafeApiError extends AIError.ProviderHttpError {
     readonly name = "TypeSafeApiError";
 }
-/** Wire shape of `GET /v1/models`. */
-export interface TypeSafeModelCard {
-    name: string;
-    description: string;
-    release_date: string;
-}
 export declare class TypeSafeJudge implements Judge {
     #private;
     readonly label: string;
+    readonly api: JudgmentApi;
+    readonly provider: string;
     readonly model: string;
     readonly baseUrl: string;
     constructor(options: TypeSafeJudgeOptions);
     judge<Q extends Questions>(request: JudgmentRequest<Q>, options?: JudgeOptions): Promise<JudgmentResult<Q>>;
-    /** Models available to the account (`GET /v1/models`); also the login validation probe. */
-    listModels(signal?: AbortSignal): Promise<TypeSafeModelCard[]>;
 }

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

@@ -0,0 +1,10 @@
+import type { Model } from "../types.js";
+import type { AnthropicMessagesClientLike } from "./anthropic-client.js";
+/** Whether the model's effective first-party route is the official Anthropic API. */
+export declare function resolvesToOfficialAnthropicEndpoint(model: Model<"anthropic-messages">): boolean;
+/** Whether the model and effective endpoint support Anthropic native compaction. */
+export declare function supportsAnthropicCompaction(model: Model<"anthropic-messages">, effectiveBaseUrl?: string): boolean;
+/** Read a caller-owned client's endpoint for request and compaction routing. */
+export declare function injectedClientBaseUrl(client: AnthropicMessagesClientLike): string | undefined;
+/** Whether a caller-owned Anthropic client targets a compaction-capable endpoint. */
+export declare function supportsAnthropicCompactionOnClient(model: Model<"anthropic-messages">, client: AnthropicMessagesClientLike): boolean;

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

@@ -0,0 +1,18 @@
+/** Whether a metadata id uses Claude Code's legacy cloaking shape. */
+export declare function isClaudeCloakingUserId(userId: string): boolean;
+/** Extract a stable session id from a supported Anthropic metadata user id. */
+export declare function extractClaudeMetadataSessionId(userId: unknown): string | undefined;
+/** Generate a legacy Claude Code cloaking metadata id. */
+export declare function generateClaudeCloakingUserId(): string;
+/** Derive the stable Claude device id for an installation and optional account. */
+export declare function deriveClaudeDeviceId(installId: string, accountId?: string): string;
+/** Read a non-empty string from provider metadata. */
+export declare function readAnthropicMetadataString(metadata: Record<string, unknown> | undefined, key: string): string | undefined;
+/** Resolve the account id aliases accepted in Anthropic request metadata. */
+export declare function readAnthropicMetadataAccountId(metadata: Record<string, unknown> | undefined): string | undefined;
+/** Resolve the provider-facing metadata user id for API-key or OAuth requests. */
+export declare function resolveAnthropicMetadataUserId(userId: unknown, isOAuthToken: boolean, sessionId?: string, accountId?: string): string | undefined;
+/** Apply Claude Code's wire-only tool prefix. */
+export declare const applyClaudeToolPrefix: (name: string) => string;
+/** Remove one Claude Code wire-only tool prefix. */
+export declare const stripClaudeToolPrefix: (name: string) => string;

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

@@ -0,0 +1,13 @@
+import type { Api, Model, ProviderSessionState } from "../types.js";
+/** Root key for Anthropic's per-session provider state. */
+export declare const ANTHROPIC_PROVIDER_SESSION_STATE_KEY = "anthropic-messages";
+/** Normalize an Anthropic base URL to its origin path without `/v1`. */
+export declare function normalizeAnthropicBaseUrl(baseUrl?: string): string | undefined;
+/** Resolve the endpoint for a first-party Anthropic model without loading its provider implementation. */
+export declare function resolveDirectAnthropicBaseUrl(model: Model<Api>): string;
+/** Build the endpoint-and-model-scoped Anthropic session-state key. */
+export declare function anthropicProviderSessionStateKey(baseUrl: string, modelId: string): string;
+/** Re-arm fast mode across materialized Anthropic session-state entries. */
+export declare function clearAnthropicFastModeFallback(providerSessionState: Map<string, ProviderSessionState> | undefined): void;
+/** Inspect the direct model's fast-mode fallback without materializing state. */
+export declare function isAnthropicFastModeFallbackDisabled(providerSessionState: Map<string, ProviderSessionState> | undefined, model: Model<Api>): boolean;

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

@@ -1,6 +1,11 @@
-import type { Api, FetchImpl, Message, Model, ProviderSessionState, ServiceTier, SimpleStreamOptions, StreamFunction, StreamOptions, Usage } from "../types.js";
+import type { FetchImpl, Message, Model, ServiceTier, SimpleStreamOptions, StreamFunction, StreamOptions, Usage } from "../types.js";
 import { type AnthropicFetchOptions, type AnthropicMessagesClientLike } from "./anthropic-client.js";
 import { type FallbackParam, type MessageParam, type TextBlockParam } from "./anthropic-wire.js";
+import { resolvesToOfficialAnthropicEndpoint, supportsAnthropicCompaction, supportsAnthropicCompactionOnClient } from "./anthropic-compaction.js";
+import { applyClaudeToolPrefix, deriveClaudeDeviceId, generateClaudeCloakingUserId, isClaudeCloakingUserId, resolveAnthropicMetadataUserId, stripClaudeToolPrefix } from "./anthropic-identity.js";
+import { clearAnthropicFastModeFallback, isAnthropicFastModeFallbackDisabled, normalizeAnthropicBaseUrl } from "./anthropic-state.js";
+export { applyClaudeToolPrefix, clearAnthropicFastModeFallback, deriveClaudeDeviceId, generateClaudeCloakingUserId, isAnthropicFastModeFallbackDisabled, isClaudeCloakingUserId, normalizeAnthropicBaseUrl, resolveAnthropicMetadataUserId, stripClaudeToolPrefix, };
+export { resolvesToOfficialAnthropicEndpoint, supportsAnthropicCompaction, supportsAnthropicCompactionOnClient };
 export type AnthropicHeaderOptions = {
     apiKey: string;
     baseUrl?: string;
@@ -14,24 +19,9 @@ export type AnthropicHeaderOptions = {
     /** Allow explicit fingerprint headers to replace OAuth defaults on non-official endpoints. */
     allowAnthropicHeaderOverrides?: boolean;
 };
-export declare function normalizeAnthropicBaseUrl(baseUrl?: string): string | undefined;
 export declare function buildBetaHeader(baseBetas: readonly string[], extraBetas: readonly string[]): string;
 export declare function buildAnthropicHeaders(options: AnthropicHeaderOptions): Record<string, string>;
 type AnthropicCacheControl = NonNullable<TextBlockParam["cache_control"]>;
-/**
- * Clears the in-session "server rejected fast mode" sticky flag. Call when the
- * caller is explicitly re-arming `serviceTier: "priority"` (e.g. user toggled
- * `/fast on` after a previous turn auto-disabled it) so the next request
- * actually carries `speed: "fast"` again. No-op when the map or state entry
- * hasn't been materialized yet.
- */
-export declare function clearAnthropicFastModeFallback(providerSessionState: Map<string, ProviderSessionState> | undefined): void;
-/**
- * Whether the direct Anthropic model's endpoint-scoped fast-mode fallback is
- * currently active. Reading the map directly is intentional: inspection must
- * not materialize a state entry for a model that has never streamed.
- */
-export declare function isAnthropicFastModeFallbackDisabled(providerSessionState: Map<string, ProviderSessionState> | undefined, model: Model<Api>): boolean;
 export * from "./claude-code-fingerprint.js";
 /** Maps Node's platform identifier to the Stainless wire value. */
 export declare function mapStainlessOs(platform: string): "MacOS" | "Windows" | "Linux" | "FreeBSD" | `Other::${string}`;
@@ -54,23 +44,6 @@ export declare const claudeCodeHeaders: {
  * pass through untouched, so installing it on every OAuth flow is safe.
  */
 export declare function wrapFetchForCch(base: FetchImpl): FetchImpl;
-export declare function isClaudeCloakingUserId(userId: string): boolean;
-export declare function generateClaudeCloakingUserId(): string;
-export declare function deriveClaudeDeviceId(installId: string, accountId?: string): string;
-/**
- * Resolve the `metadata.user_id` field for an Anthropic Messages request.
- *
- * For API-key tokens, an explicit caller-supplied `userId` is forwarded
- * verbatim and `undefined` yields no metadata. For OAuth tokens the value
- * must match the Claude Code attribution shape (`isClaudeCloakingUserId` or
- * the `{session_id, account_uuid?, device_id?}` JSON envelope) — anything
- * else is dropped and a fresh Claude-Code-style JSON id is generated from
- * `sessionId`/`accountId` so attribution stays consistent across the main
- * streaming path and provider-specific request builders (e.g. web search).
- */
-export declare function resolveAnthropicMetadataUserId(userId: unknown, isOAuthToken: boolean, sessionId?: string, accountId?: string): string | undefined;
-export declare const applyClaudeToolPrefix: (name: string) => string;
-export declare const stripClaudeToolPrefix: (name: string) => string;
 export type AnthropicOutputEffort = "low" | "medium" | "high" | "xhigh" | "max";
 export type AnthropicEffort = AnthropicOutputEffort | "adaptive";
 export type AnthropicThinkingDisplay = "summarized" | "omitted";
@@ -212,32 +185,6 @@ export type AnthropicUsageLike = {
  * zero-valued objects clear prior extras from earlier stream usage snapshots.
  */
 export declare function applyAnthropicUsageExtras(usage: Usage, source: AnthropicUsageLike): void;
-/**
- * Whether this model's requests reach the official Anthropic API, resolved the
- * way the transport resolves it — including the Foundry and
- * `ANTHROPIC_BASE_URL` reroutes that leave `compat.officialEndpoint` stale.
- */
-export declare function resolvesToOfficialAnthropicEndpoint(model: Model<"anthropic-messages">): boolean;
-/**
- * Whether server-side compaction (`compact-2026-01-12`) may be spoken for
- * this model to the endpoint a request actually reaches: a model line the
- * beta supports (`compat.supportsServerCompaction`, rule-owned in the
- * catalog), on the official API for the first-party provider or on any
- * endpoint that opted in through `remoteCompaction.enabled`, and never on one
- * whose deployment contract excludes context management. The same predicate
- * gates emitting the edit, attaching the beta, and replaying a persisted
- * block, so a route or model change can never leave a session sending a block
- * its endpoint rejects.
- */
-export declare function supportsAnthropicCompaction(model: Model<"anthropic-messages">, effectiveBaseUrl?: string): boolean;
-/**
- * {@link supportsAnthropicCompaction} for a request on a caller-owned client:
- * the endpoint is whatever the client targets (an `AnthropicVertex` client
- * carries an Anthropic model to Vertex), never the model's own routing. SDK
- * clients expose it as `baseURL`; a client that exposes no endpoint only
- * compacts through an explicit `remoteCompaction.enabled` opt-in.
- */
-export declare function supportsAnthropicCompactionOnClient(model: Model<"anthropic-messages">, client: AnthropicMessagesClientLike): boolean;
 /** Detects the preserved-thinking error caused by rewriting a signed block's conversation prefix. */
 export declare function isThinkingPrefixBindingError(message: string): boolean;
 export declare function isInvalidThinkingSignatureError(message: string): boolean;

package/dist/types/providers/gitlab-duo.d.ts

@@ -3,5 +3,4 @@ import type { Api, Context, Model, SimpleStreamOptions } from "../types.js";
 import { AssistantMessageEventStream } from "../utils/event-stream.js";
 export { getGitLabDuoModels };
 export declare function clearGitLabDuoDirectAccessCache(): void;
-export declare function isGitLabDuoModel(model: Model<Api>): boolean;
 export declare function streamGitLabDuo(model: Model<Api>, context: Context, options?: SimpleStreamOptions): AssistantMessageEventStream;

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

@@ -8,7 +8,7 @@
  * Each discovered model selects its server-declared protocol; legacy models
  * without protocol metadata retain the Anthropic-compatible default.
  */
-import type { Api, Context, Model } from "../types.js";
+import type { Context, Model } from "../types.js";
 import type { AssistantMessageEventStream } from "../utils/event-stream.js";
 import { type OpenAIAnthropicApiFormat, type OpenAIAnthropicShimOptions } from "./openai-anthropic-shim.js";
 export type KimiApiFormat = OpenAIAnthropicApiFormat;
@@ -21,7 +21,3 @@ export interface KimiOptions extends OpenAIAnthropicShimOptions {
  * Returns synchronously like other providers - async header fetching happens internally.
  */
 export declare function streamKimi(model: Model<"openai-completions">, context: Context, options?: KimiOptions): AssistantMessageEventStream;
-/**
- * Check if a model is a Kimi Code model.
- */
-export declare function isKimiModel(model: Model<Api>): boolean;

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

@@ -0,0 +1,6 @@
+/** Host integration boundary for just-in-time `x-oai-attestation` values. */
+export type CodexAttestationProvider = () => Promise<string | undefined>;
+/** Install the process-wide just-in-time Codex attestation provider. */
+export declare function setCodexAttestationProvider(provider: CodexAttestationProvider | undefined): void;
+/** Resolve an attestation only for ChatGPT-OAuth credentials. */
+export declare function getCodexAttestationHeader(accountId: string | undefined): Promise<string | undefined>;

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

@@ -0,0 +1,6 @@
+import type { CodexCompactionContext, CodexCompactionRequestContext } from "../types.js";
+/** Add the selected wire implementation to one logical compaction context. */
+export declare function createOpenAICodexCompactionRequestContext(options: {
+    context: CodexCompactionContext | undefined;
+    implementation: "responses" | "responses_compaction_v2" | "responses_compact";
+}): CodexCompactionRequestContext | undefined;

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

@@ -1,5 +1,8 @@
 import type { CodexCompactionContext, CodexCompactionRequestContext, Context, Model, ProviderSessionState, ServiceTier, StreamFunction, StreamOptions, Tool, ToolChoice } from "../types.js";
 import { type CodexLiteShapedBody, type CodexReasoningContext, type InputItem, type RequestBody } from "./openai-codex/request-transformer.js";
+export { createOpenAICodexCompactionRequestContext } from "./openai-codex-compaction.js";
+export { setCodexAttestationProvider } from "./openai-codex-attestation.js";
+export type { CodexAttestationProvider } from "./openai-codex-attestation.js";
 import type { ResponseInput } from "./openai-responses-wire.js";
 export interface OpenAICodexResponsesOptions extends StreamOptions {
     reasoning?: "none" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max";
@@ -73,33 +76,6 @@ export interface OpenAICodexCompactionResetOptions {
     sessionId?: string;
     compaction: CodexCompactionContext;
 }
-/** Add the selected wire implementation to one logical compaction context. */
-export declare function createOpenAICodexCompactionRequestContext(options: {
-    context: CodexCompactionContext | undefined;
-    implementation: "responses" | "responses_compaction_v2" | "responses_compact";
-}): CodexCompactionRequestContext | undefined;
-/**
- * Host integration boundary for just-in-time `x-oai-attestation` header
- * values (codex-rs `AttestationProvider`). Resolves to the full header value
- * — an `{"v":1,"s":0,"t":"v1.…"}` envelope — or `undefined` when no
- * attestation should be sent.
- */
-export type CodexAttestationProvider = () => Promise<string | undefined>;
-/**
- * Install the process-wide attestation hook consulted for upstream Codex
- * requests (codex-rs stores its provider on `ModelClient` construction). The
- * hook is only consulted for ChatGPT-OAuth credentials and runs just-in-time
- * per request; WebSocket handshakes resolve once per connection because the
- * header is connection-scoped there.
- */
-export declare function setCodexAttestationProvider(provider: CodexAttestationProvider | undefined): void;
-/**
- * Resolve the `x-oai-attestation` header value for one upstream request.
- * Gated on ChatGPT-OAuth credentials (a Codex JWT carries `chatgpt_account_id`;
- * codex-rs gates on `auth.is_chatgpt_auth()`). A throwing hook degrades to no
- * header rather than failing the request.
- */
-export declare function getCodexAttestationHeader(accountId: string | undefined): Promise<string | undefined>;
 type CodexTransport = "sse" | "websocket";
 /** Shape of the Codex request sent on the latest provider turn. */
 export interface OpenAICodexTurnRequestDiagnostics {

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

@@ -0,0 +1,7 @@
+import type { Model } from "../types.js";
+/** Read the optional process-wide Codex WebSocket override. */
+export declare function getOpenAICodexWebSocketEnvValue(): boolean | undefined;
+/** Resolve the public WebSocket preference using env, caller, then model precedence. */
+export declare function isOpenAICodexWebSocketPreferred(model: Model<"openai-codex-responses">, options?: {
+    preferWebsockets?: boolean;
+}): boolean;

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

@@ -8,15 +8,6 @@ import type { CapturedHttpErrorResponse } from "../utils/http-inspector.js";
 import type { ChatCompletionCreateParamsStreaming } from "./openai-chat-wire.js";
 import { type InputItem } from "./openai-codex/request-transformer.js";
 import type { ResponseComputerToolCall, ResponseContentPartAddedEvent, ResponseCreateParamsStreaming, ResponseInput, ResponseInputContent, ResponseInputItem, ResponseOutputItem, ResponseOutputMessage, ResponseReasoningItem, ResponseStatus, ResponseStreamEvent } from "./openai-responses-wire.js";
-/**
- * Keyless-provider sentinel. Custom providers configured with `auth: none`
- * (models.yml) have no credential, so the coding-agent resolves their API key
- * to this literal instead of a real secret. Providers must treat it as "no
- * credential" and suppress any credential-bearing header (e.g. `Authorization:
- * Bearer …`) rather than forwarding the sentinel on the wire. See #6188; the
- * google-vertex and amazon-bedrock transports apply the same guard inline.
- */
-export declare const NO_AUTH_SENTINEL = "N/A";
 export interface OpenAIModelIdentity {
     provider: string;
     id: string;

package/dist/types/providers/register-builtins.d.ts

@@ -1,37 +1,35 @@
 /**
- * Lazy provider module loading.
- *
- * Each provider module is loaded only when its stream function is first called.
- * This avoids eagerly importing heavy SDK dependencies (e.g., openai) at
- * startup. The loaded module promise is cached so subsequent calls
- * reuse the same import.
- *
- * NOTE: stream.ts currently imports providers directly, so this file is not yet
- * wired into the main streaming path. It provides the infrastructure for lazy
- * loading that can be integrated when stream.ts is refactored.
+ * Built-in provider stream dispatch with shared error, cancellation, and timeout handling.
  */
-import type { AssistantMessageEventStream, Context, Model, OptionsForApi } from "../types.js";
+import type { Context, Model, OptionsForApi } from "../types.js";
 import { AssistantMessageEventStream as EventStreamImpl } from "../utils/event-stream.js";
-import type { BedrockOptions } from "./amazon-bedrock.js";
-import type { CursorOptions } from "./cursor.js";
-interface CursorProviderModule {
-    streamCursor: (model: Model<"cursor-agent">, context: Context, options: CursorOptions) => AssistantMessageEventStream;
-}
-interface BedrockProviderModule {
-    streamBedrock: (model: Model<"bedrock-converse-stream">, context: Context, options: BedrockOptions) => AssistantMessageEventStream;
-}
-export declare function setBedrockProviderModule(module: BedrockProviderModule): void;
-export declare function setCursorProviderModule(module: CursorProviderModule): void;
+import * as BedrockProvider from "./amazon-bedrock.js";
+import * as CursorProvider from "./cursor.js";
+/** Install a host-supplied Bedrock transport in place of the built-in provider. */
+export declare function setBedrockProviderModule(module: Pick<typeof BedrockProvider, "streamBedrock">): void;
+/** Install a host-supplied Cursor transport in place of the built-in provider. */
+export declare function setCursorProviderModule(module: Pick<typeof CursorProvider, "streamCursor">): void;
+/** Stream Anthropic responses with provider-owned timeout handling. */
 export declare const streamAnthropic: (model: Model<"anthropic-messages">, context: Context, options: OptionsForApi<"anthropic-messages">) => EventStreamImpl;
+/** Stream Azure Responses with provider-owned timeout handling. */
 export declare const streamAzureOpenAIResponses: (model: Model<"azure-openai-responses">, context: Context, options: OptionsForApi<"azure-openai-responses">) => EventStreamImpl;
+/** Stream Google's direct API through the shared watchdog. */
 export declare const streamGoogle: (model: Model<"google-generative-ai">, context: Context, options: OptionsForApi<"google-generative-ai">) => EventStreamImpl;
+/** Stream Cloud Code Assist while retaining its first-event watchdog. */
 export declare const streamGoogleGeminiCli: (model: Model<"google-gemini-cli">, context: Context, options: OptionsForApi<"google-gemini-cli">) => EventStreamImpl;
+/** Stream the Vertex API through the shared watchdog. */
 export declare const streamGoogleVertex: (model: Model<"google-vertex">, context: Context, options: OptionsForApi<"google-vertex">) => EventStreamImpl;
+/** Stream Codex with provider-owned timeout handling. */
 export declare const streamOpenAICodexResponses: (model: Model<"openai-codex-responses">, context: Context, options: OptionsForApi<"openai-codex-responses">) => EventStreamImpl;
+/** Stream Chat Completions with provider-owned timeout handling. */
 export declare const streamOpenAICompletions: (model: Model<"openai-completions">, context: Context, options: OptionsForApi<"openai-completions">) => EventStreamImpl;
+/** Stream Responses with provider-owned timeout handling. */
 export declare const streamOpenAIResponses: (model: Model<"openai-responses">, context: Context, options: OptionsForApi<"openai-responses">) => EventStreamImpl;
+/** Stream through the host Cursor transport when installed, otherwise the built-in transport. */
 export declare const streamCursor: (model: Model<"cursor-agent">, context: Context, options: OptionsForApi<"cursor-agent">) => EventStreamImpl;
+/** Stream Devin through the shared watchdog. */
 export declare const streamDevin: (model: Model<"devin-agent">, context: Context, options: OptionsForApi<"devin-agent">) => EventStreamImpl;
+/** Stream Ollama with OpenAI-compatible idle timeout precedence. */
 export declare const streamOllama: (model: Model<"ollama-chat">, context: Context, options: OptionsForApi<"ollama-chat">) => EventStreamImpl;
+/** Stream through the host Bedrock transport when installed, otherwise the built-in transport. */
 export declare const streamBedrock: (model: Model<"bedrock-converse-stream">, context: Context, options: OptionsForApi<"bedrock-converse-stream">) => EventStreamImpl;
-export {};

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

@@ -7,7 +7,7 @@
  *
  * @see https://dev.synthetic.new/docs/api/overview
  */
-import type { Api, Context, Model } from "../types.js";
+import type { Context, Model } from "../types.js";
 import type { AssistantMessageEventStream } from "../utils/event-stream.js";
 import { type OpenAIAnthropicApiFormat, type OpenAIAnthropicShimOptions } from "./openai-anthropic-shim.js";
 export type SyntheticApiFormat = OpenAIAnthropicApiFormat;
@@ -20,7 +20,3 @@ export interface SyntheticOptions extends OpenAIAnthropicShimOptions {
  * Returns synchronously like other providers - async processing happens internally.
  */
 export declare function streamSynthetic(model: Model<"openai-completions">, context: Context, options?: SyntheticOptions): AssistantMessageEventStream;
-/**
- * Check if a model is a Synthetic model.
- */
-export declare function isSyntheticModel(model: Model<Api>): boolean;