@oh-my-pi/pi-ai 18.6.1 → 18.7.0

package/CHANGELOG.md

@@ -2,6 +2,43 @@
 
 ## [Unreleased]
 
+## [18.7.0] - 2026-10-06
+
+### Added
+
+- Added `getOAuthCredentialProvider()` to resolve login aliases, such as `openai-codex-device`, to the provider where their credentials are stored.
+
+### Fixed
+
+- Fixed Ultrafast service-tier billing and usage accounting: GPT-6 Astra now applies its published premium rates—6× on the OpenAI API and 8× included usage on Codex—and is counted toward the premium-request limit.
+- Fixed Vertex AI authentication on Windows when credentials are created with `gcloud auth application-default login`.
+- Fixed selecting Cursor accounts by email through `auth.accountPolicies` and `/session pin`; newly refreshed and existing accounts now retain the account email.
+
+## [18.6.3] - 2026-10-06
+
+### Added
+
+- Added per-model `compat.statefulResponses` to enable or disable stored Responses chaining (`previous_response_id` with `store: true`) for one endpoint without the official-only request fields that `compat.officialEndpoint` implies ([#13686](https://github.com/can1357/oh-my-pi/pull/13686) by [@alphastorm](https://github.com/alphastorm)).
+- Added Snowflake Cortex with browser OAuth, token refresh, PAT environment authentication, and streaming Claude/OpenAI models with local tool execution ([#14507](https://github.com/can1357/oh-my-pi/pull/14507) by [@jorgoose](https://github.com/jorgoose)).
+- `AuthStorage.health.check()` accepts `excludeProviders` to skip credentials of providers the caller does not serve ([#14234](https://github.com/can1357/oh-my-pi/pull/14234) by [@will-bogusz](https://github.com/will-bogusz))
+
+### Changed
+
+- Reduced CPU spent on thinking-loop detection while streaming long reasoning ([#14284](https://github.com/can1357/oh-my-pi/pull/14284) by [@abilliontokens](https://github.com/abilliontokens)).
+- Added `recordAffinity: false` to credential resolution options, selecting as the session would without pinning the choice to that session ([#14512](https://github.com/can1357/oh-my-pi/pull/14512) by [@will-bogusz](https://github.com/will-bogusz))
+
+### Fixed
+
+- Codex native-lane steering rejections (`unsupported_native_inflight_message`) now classify as retryable from their error text alone, matching the provider's own classification, and `AIError.isCodexSteerRejection()` identifies them so the agent retry can stay on the same model ([#14242](https://github.com/can1357/oh-my-pi/pull/14242) by [@alphastorm](https://github.com/alphastorm))
+- Fixed replayed Responses and Codex history, including persisted Codex user/developer and assistant items, sending `detail: "original"` images to endpoints whose `supportsImageDetailOriginal` is off ([#13687](https://github.com/can1357/oh-my-pi/pull/13687) by [@alphastorm](https://github.com/alphastorm)).
+- Fixed thinking in turns kept after Anthropic native compaction being rejected or dropped on the next request ([#14251](https://github.com/can1357/oh-my-pi/pull/14251) by [@will-bogusz](https://github.com/will-bogusz))
+- Fixed Claude usage being re-polled every 10 seconds while Anthropic rate-limits the account; a failed refresh now waits a minute before trying again ([#14515](https://github.com/can1357/oh-my-pi/pull/14515) by [@will-bogusz](https://github.com/will-bogusz))
+- Fixed Devin requests skipping the `onPayload` hook, so payload capture now sees each Devin chat request and a returned replacement is what gets sent ([#14506](https://github.com/can1357/oh-my-pi/pull/14506) by [@will-bogusz](https://github.com/will-bogusz))
+- An OpenAI Responses turn whose connection drops mid-stream can now recover the finished answer from the provider (on hosts that store results, such as Muse Code) instead of re-running the whole turn and discarding the reasoning already done. Storage is opt-in: pass `storeResponses: true`, set `PI_MUSE_STORE_RESPONSES=1`, or set a process-wide default with `configureProviderStoreResponses` ([#14293](https://github.com/can1357/oh-my-pi/pull/14293) and [#14534](https://github.com/can1357/oh-my-pi/pull/14534) by [@abilliontokens](https://github.com/abilliontokens)).
+- Fixed the auth broker exiting when a background OAuth refresh sweep cannot read the credential store; the failure is now logged and the next sweep retries ([#14538](https://github.com/can1357/oh-my-pi/issues/14538))
+- Fixed Anthropic OAuth billing headers changing during developer-first sessions and side turns, preserving the prompt-cache prefix ([#14495](https://github.com/can1357/oh-my-pi/issues/14495)).
+- Fixed OpenAI-compatible chat-completions gateways recording completed turns as client-cancelled because the connection closed before their `[DONE]` sentinel arrived ([#14481](https://github.com/can1357/oh-my-pi/issues/14481)).
+
 ## [18.6.1] - 2026-10-04
 
 ### Fixed
@@ -2290,41 +2327,4 @@
 - Fixed truncated Gemini and Gemma tool blocks from being emitted as plain text during streaming
 - Fixed Gemini/Gemma in-band tool-call parsing around Python comments, raw/unicode string literals, and Gemma close-token text inside string values.
 
-## [15.13.2] - 2026-06-15
-
-### Added
-
-- Added `jsonSchemaToTypeScript` to `@oh-my-pi/pi-ai/utils/schema` to render JSON Schema argument shapes as compact, human-readable TypeScript-style signatures
-- Added the generic `ToolExample` type (`ToolCallExample`/`ToolCompareExample`/`ToolNoteExample`, parameterized over a tool's argument shape) and an `examples` property on the `Tool` interface for defining tool-call examples once as data.
-- Added `renderToolExamples` (via `@oh-my-pi/pi-ai/grammar`) to render a tool's examples into an `<examples>` block in the model's native tool-call syntax, with an optional `_i` intent-field placeholder injected when intent tracing is active.
-- Added per-grammar `renderToolCall` rendering of a single tool-call invocation (the inner element only, without the parallel-call block envelope), distinct from `renderAssistantToolCalls` which renders a complete block of one or more parallel calls.
-- Added a `GrammarRenderOptions.example` flag to `renderToolCall`: when set, the invocation renders as the bare payload — Harmony emits just the JSON arguments, dropping the verbose `<|start|>…<|message|>…<|call|>` envelope — so `renderToolExamples` keeps `<examples>` blocks legible.
-- Added an `abortOnFabrication` parameter to `wrapInbandToolStream` (default `true`): when `false`, a fabricated in-band tool-result continuation is discarded without aborting the provider request instead of cutting the turn short.
-- Added `@oh-my-pi/pi-ai/utils/harmony-leak` export with helpers to detect, audit, and recover GPT-5 Harmony tool-call header leaks
-- Added the `@oh-my-pi/pi-ai/grammar` public entrypoint for grammar factories, prompt/call rendering, in-band scanning, history encoding, and related typed utilities
-- Added a unified in-band tool-call grammar engine with syntax-owned scanners, prompts, history rendering, tool-result rendering, and stream adaptation for GLM, Hermes/Qwen, Kimi, XML/Anthropic, DeepSeek, Harmony, and pi-native formats.
-
-### Changed
-
-- Changed Harmony in-band tool-call rendering to omit the `<|constrain|>json` marker before the payload in `commentary` channel calls
-- Changed tool inventory rendering to present each tool’s `Parameters` section as a simplified TypeScript-style signature derived from its wire schema
-- Added raw in-band tool-call block capture to parsed owned tool calls so debugging can inspect the exact model-emitted call syntax.
-- Moved the canonical `ToolCallSyntax` union to `@oh-my-pi/pi-catalog/identity` and re-exported it from `@oh-my-pi/pi-ai/grammar` so the catalog can own the syntax vocabulary without an `@oh-my-pi/pi-ai` runtime import; all existing import paths are unchanged.
-- Made tool-call argument validation more lenient for schema-directed scalar coercions, including object/array stringification and 0/1 boolean coercion.
-- Changed `renderToolInventory` (the verbose system-prompt inventory and `/dump`) to render each tool as a `# Tool: <name>` markdown section instead of a `<tool name="…">…</tool>` wrapper.
-
-### Fixed
-
-- Fixed Harmony leak handling support by adding `recoverHarmonyToolCall` plus leak-detection workflows for contaminated assistant messages so recoverable tool-call arguments can be safely truncated and retried
-- Fixed false-positive gating in Harmony leak heuristics using signal-based checks so unrelated text containing `to=functions...` is not treated as leaked tool-call markup
-- Routed Kimi, DeepSeek DSML, and plain thinking markup healing through the shared in-band scanners so provider leak repair and owned tool calling parse the same wire formats.
-- Fixed Cursor provider (`cursor-agent` API) streaming dropping large MCP tool-call arguments — most visibly the built-in `task` tool's `tasks` array on multi-subagent dispatches, which failed downstream schema validation with `tasks: Invalid input: expected array, received undefined`. Two upstream behaviors were fighting the stream handler in `packages/ai/src/providers/cursor.ts`: (1) `args_text_delta` carries the _cumulative_ args text so far per `agent.proto`, but the handler concatenated each snapshot onto the buffer, garbling the JSON; (2) `tool_call_completed` carries an `McpArgs` map that omits oversized parameters entirely and downgrades unparsable values to their raw string fallback, but the handler unconditionally overwrote the streamed args with that map. The handler now strips the already-buffered prefix from each `args_text_delta` snapshot (falling back to append when the snapshot doesn't extend the buffer) and merges the decoded `McpArgs` map into the streamed args — preserving streamed keys the completion frame omits and the structured value when the completion frame downgrades to a string. ([#2615](https://github.com/can1357/oh-my-pi/issues/2615))
-- Fixed Codex Responses stream mis-routing interleaved `function_call_arguments.delta` events when more than one tool call was open concurrently. The runtime tracked a singleton `currentItem`/`currentBlock`, so every delta — regardless of `item_id` — was appended to whichever item was most recently added, and `output_item.done` for the earlier call then overwrote a sibling's stored arguments (visible as `tasks: Invalid input: expected array, received undefined` on the `task` tool). Open items are now keyed by `item_id` with `output_index` fallback; deltas/done events route to the matching block, late deltas whose item already closed are dropped instead of corrupting a sibling, and `toolcall_*` stream events emit the right `contentIndex` per call ([#2619](https://github.com/can1357/oh-my-pi/issues/2619)).
-
-## [15.13.1] - 2026-06-15
-
-### Fixed
-
-- Fixed the auth-broker (`OMP_AUTH_BROKER_URL`) rejecting OAuth credentials that carry provider-specific extension fields (e.g. an MCP server's `tokenUrl`/`clientId`/`clientSecret`/`resource` embedded for self-contained token refresh): the OAuth credential wire schema was `.strict()`, so `POST /v1/credential` failed with `400 unrecognized_keys` and a broker-backed MCP reauth reported success while the reloaded credential lacked its refresh material and could no longer refresh. The OAuth wire schema now uses `.loose()` to preserve unknown fields — matching the field-preserving local SQLite store — so extra OAuth fields round-trip through broker set->get (envelope and API-key schemas stay strict).
-
-Older entries are archived in [packages/ai/CHANGELOG.md@bac7e83b5b0e](https://github.com/can1357/oh-my-pi/blob/bac7e83b5b0eb86c909c17830a6666efc359578b/packages/ai/CHANGELOG.md).
+Older entries are archived in [packages/ai/CHANGELOG.md@a20cc0d04b64](https://github.com/can1357/oh-my-pi/blob/a20cc0d04b64f4a68fcc559cbd258743d984c50e/packages/ai/CHANGELOG.md).

package/README.md

@@ -77,6 +77,7 @@ Unified LLM API with automatic model discovery, provider configuration, token an
 - **QwenCloud Token Plan** (supports `/login alibaba-token-plan`, `ALIBABA_TOKEN_PLAN_API_KEY`, or `BAILIAN_TOKEN_PLAN_API_KEY`; interactive login first selects a region — International (Singapore, default), China (Beijing) for 百炼 Token Plan keys, or a custom base URL — since region keys are non-interchangeable, then optionally stores a `home.qwencloud.com` Cookie request header for best-effort 5-hour and 7-day quota reporting)
   To enable quota reporting, sign in to the Token Plan dashboard, copy the `Cookie` request-header value from a `home.qwencloud.com` request in browser developer tools, and paste it at the second login prompt. Press Enter to skip; the Cookie is sensitive and session-lived, so rerun login when it expires.
 - **Cloudflare AI Gateway** (supports `/login cloudflare-ai-gateway`, or `CLOUDFLARE_AI_GATEWAY_API_KEY` with `CLOUDFLARE_ACCOUNT_ID` and `CLOUDFLARE_GATEWAY_ID`)
+- **Snowflake Cortex** (browser `/login snowflake`, or `SNOWFLAKE_ACCOUNT` + `SNOWFLAKE_PAT`; account-billed Cortex REST API)
 - **Ollama** (local OpenAI-compatible runtime; optional `OLLAMA_API_KEY`)
 - **Ollama Cloud** (hosted native Ollama API; requires `OLLAMA_CLOUD_API_KEY`)
 - **llama.cpp** (local OpenAI and Anthropic compatible inference server)
@@ -961,6 +962,7 @@ In Node.js environments, you can set environment variables to avoid passing API
 | ZenMux                | `ZENMUX_API_KEY`                                                                                                    |
 | vLLM                  | `VLLM_API_KEY`                                                                                                      |
 | Cloudflare AI Gateway | `CLOUDFLARE_AI_GATEWAY_API_KEY` + `CLOUDFLARE_ACCOUNT_ID` + `CLOUDFLARE_GATEWAY_ID`                                 |
+| Snowflake Cortex      | `SNOWFLAKE_PAT` + `SNOWFLAKE_ACCOUNT`                                                                               |
 | GitHub Copilot        | `COPILOT_GITHUB_TOKEN` or `GH_TOKEN` or `GITHUB_TOKEN`                                                              |
 
 `/login cloudflare-ai-gateway` collects and stores the gateway token, account ID, and gateway ID. For environment configuration, set all three Cloudflare values above. OMP derives provider endpoints from the account and gateway IDs.
@@ -1029,9 +1031,22 @@ Several providers support OAuth authentication (some also support static API key
 - **Google Gemini CLI** (Gemini 2.0/2.5 via Google Cloud Code Assist; free tier or paid subscription)
 - **Antigravity** (Free Gemini 3, Claude, GPT-OSS via Google Cloud)
 - **Qwen Portal** (Qwen OAuth token or API key)
+- **Snowflake Cortex** (Snowflake account OAuth with PKCE and refresh, subject to the account's local-application integration)
 
 For paid Cloud Code Assist subscriptions, set `GOOGLE_CLOUD_PROJECT` or `GOOGLE_CLOUD_PROJECT_ID` to your project ID.
 
+### Snowflake Cortex
+
+`/login snowflake` prompts for an account identifier (for example, `myorg-myaccount`), an HTTPS Snowflake account URL, or a Snowsight account link. It opens Snowflake's built-in `SNOWFLAKE$LOCAL_APPLICATION` OAuth flow using PKCE and a `127.0.0.1` callback (port 54551, with an ephemeral-port fallback). The stored account selects the inference endpoint; OAuth credentials cannot be sent to a different account through a custom model endpoint.
+
+The default inference role must hold either `SNOWFLAKE.CORTEX_USER` or the narrower, REST-only `SNOWFLAKE.CORTEX_REST_API_USER` (recommended for least privilege). `CORTEX_REST_API_USER` cannot be granted to a user directly; grant it to a custom role, and revoke `CORTEX_USER` from users who already hold it so the narrower control applies. The Cortex REST API is not available in China-region (`.snowflakecomputing.cn`) accounts. An administrator can check local-app availability with `SHOW SECURITY INTEGRATIONS LIKE 'SNOWFLAKE$LOCAL_APPLICATION'` and enable the integration or refresh issuance if necessary. When Snowflake issues a refresh token, omp refreshes the access token automatically. Without one, login remains valid until expiry; then sign in again or use the PAT environment alternative.
+
+For PAT authentication, set both `SNOWFLAKE_ACCOUNT` and `SNOWFLAKE_PAT`. Prefer a short-lived PAT restricted to a dedicated inference role and the required user-scoped network allowlist; do not disable network-policy enforcement. See [Snowflake PAT setup](https://docs.snowflake.com/en/user-guide/programmatic-access-tokens) and [local-application OAuth](https://docs.snowflake.com/en/user-guide/oauth-local-applications).
+
+Claude models use `/api/v2/cortex/v1/messages`; OpenAI models use `/api/v2/cortex/v1/chat/completions`. Both reuse omp's streaming transports and local tool execution. The 15 bundled models are a documented roster, not an account entitlement check: availability still depends on Cortex REST API enablement, role grants, model allowlists, and region. If authentication succeeds but Cortex returns `003001` ("This account is not allowed to access this endpoint"), Snowflake has not enabled Cortex REST for the account. [Self-service trial accounts disable AI features until a credit card is added](https://docs.snowflake.com/en/user-guide/admin-trial-account#label-trial-account-ai-features) (adding one does not end the trial); REST access can remain disabled even after AI SQL functions work, in which case Snowflake support must enable it. Cross-region inference requires an account administrator's explicit decision. `omp models snowflake --json` lists available models only after credentials are configured.
+
+This provider uses the [public, account-billed Cortex REST API](https://docs.snowflake.com/en/user-guide/snowflake-cortex/cortex-rest-api). CoCo-subscription coverage is unverified. Catalog prices are per-million-token estimates from [Consumption Table 6(b)](https://www.snowflake.com/legal-files/CreditConsumptionTable.pdf) at [$2 per AI Credit](https://docs.snowflake.com/en/user-guide/snowflake-cortex/pricing) for on-demand global routing, not your contract price. Output is capped at the REST API's documented 16,384-token maximum; context windows are conservative AI_COMPLETE limits, not verified REST maxima. Cortex compatibility rules limit explicit cache retention to five minutes. Paste an account identifier or current Snowsight link; legacy `app.snowflake.com/<region>/<locator>` links are rejected because they don't map uniformly to an account host.
+
 ### Vertex AI (ADC)
 
 Vertex AI models use Application Default Credentials (ADC):

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

@@ -220,6 +220,8 @@ export interface CheckCredentialsOptions {
     completionProbe?: CompletionProbe;
     /** Per-credential completion probe timeout (ms). Defaults to `timeoutMs`. */
     completionTimeoutMs?: number;
+    /** Providers whose credentials are skipped entirely (not probed, not reported). */
+    excludeProviders?: ReadonlySet<string>;
 }
 /**
  * Sentinel value placed in OAuth `refresh` fields when a credential is shared
@@ -424,6 +426,8 @@ export type AuthApiKeyOptions = {
     forceRefresh?: boolean;
     /** Explicit provider-401 recovery; generic force refreshes leave this unset. */
     refreshReason?: OAuthRefreshReason;
+    /** When false, select as `sessionId` would without recording the choice as that session's sticky credential. */
+    recordAffinity?: boolean;
 };
 /** Non-secret identity bound to the OAuth credential selected for one request attempt. */
 export interface OAuthRequestIdentity {

package/dist/types/auth-broker/refresher.d.ts

@@ -20,6 +20,11 @@ export declare class AuthBrokerRefresher {
     start(): void;
     stop(): void;
     getSchedule(): AuthBrokerRefresherSchedule;
-    /** Run one sweep. Exposed for tests. */
+    /**
+     * Run one sweep. Exposed for tests.
+     *
+     * Never rejects: callers fire it unawaited from a timer, so a failed sweep
+     * (e.g. an unreadable credential store) is logged and retried next interval.
+     */
     tick(): Promise<void>;
 }

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

@@ -43,6 +43,21 @@ export declare function isResponsesRequestBodyReadTimeout(message: {
     errorMessage?: string;
     requestBodyReadTimeoutFullReplay?: boolean;
 }): boolean;
+/**
+ * Codex code for the experimental native turn lane refusing a mid-response
+ * `response.steer`; the server then drops the in-flight response and closes
+ * the socket.
+ */
+export declare const CODEX_NATIVE_LANE_STEER_REJECTED_CODE = "unsupported_native_inflight_message";
+/**
+ * A Codex turn the native turn lane dropped because omp steered it. The
+ * rejection answers our own `response.steer`, not the model's health: the
+ * provider stops steering the session, so the same model replays cleanly.
+ */
+export declare function isCodexSteerRejection(message: {
+    api?: Api;
+    errorMessage?: string;
+}): 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. */

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

@@ -1,4 +1,4 @@
-import type { Api, Model } from "@oh-my-pi/pi-catalog/types";
+import { type Api, type ImageGenerationApi, type Model } from "@oh-my-pi/pi-catalog/types";
 import type { ImageGenerationOptions, ImageGenerationRequest, ImageGenerationResult } from "./types.js";
 export * from "./google-antigravity.js";
 export * from "./google-generative-ai.js";
@@ -6,8 +6,7 @@ export * from "./openai-hosted.js";
 export * from "./openai-images.js";
 export * from "./openrouter-images.js";
 export * from "./types.js";
-/** Catalog APIs {@link generateImage} serves; the hosted Responses pair needs an explicit carrier model. */
-export type ImageGenerationApi = "openai-images" | "openrouter-images" | "google-generative-ai" | "google-gemini-cli" | "openai-responses" | "openai-codex-responses";
+export type { ImageGenerationApi } from "@oh-my-pi/pi-catalog/types";
 /** Whether a catalog API generates images through one of the pi-ai image clients. */
 export declare function isImageGenerationApi(api: Api): api is ImageGenerationApi;
 /** Generate (or edit, when `request.inputImages` is set) images through the transport selected by the model's `api`. */

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

@@ -1,4 +1,5 @@
-import type { AnthropicOutputEffort, FetchImpl, Message, Model, ServiceTier, SimpleStreamOptions, StreamFunction, StreamOptions, Usage } from "../types.js";
+import type { Effort } from "@oh-my-pi/pi-catalog/effort";
+import type { AnthropicCompactionRequest, AnthropicOutputEffort, 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";
@@ -209,7 +210,7 @@ export type AnthropicSystemBlock = {
 type SystemBlockOptions = {
     includeClaudeCodeInstruction?: boolean;
     extraInstructions?: string[];
-    /** Text of the first user message — used as fingerprint seed for the billing header. */
+    /** Text of the first conversational wire user turn, used as the billing fingerprint seed. */
     firstUserMessageText?: string;
     /** Cache lifetime shared by the OAuth system breakpoint and later message breakpoints. */
     cacheControl?: AnthropicCacheControl;
@@ -234,6 +235,16 @@ export declare function budgetThinkingOutput(maxTokens: number | undefined, budg
     maxTokens: number;
     budgetTokens: number;
 };
+/**
+ * The effort whose thinking allowance an on-demand compaction request over
+ * `messages` gets. It sends no effort change of its own, so once an earlier
+ * request recorded an effort, the one it left in force applies, even when
+ * `requested` differs or is off. When that request named none, the API's
+ * per-model default applies, which is not known here: the request gets the
+ * largest effort's allowance (`max_tokens` is a cap, not spend). Without a
+ * recorded effort the request sets its own.
+ */
+export declare function resolveAnthropicCompactionEffort(model: Model<"anthropic-messages">, messages: readonly Message[], requested: Effort | undefined): Effort | undefined;
 /**
  * Whether the conversation has stopped being thinking-led, so routes with
  * `compat.stripThinkingHistory` drop the budget `thinking` config and replay
@@ -269,5 +280,7 @@ export declare function convertAnthropicMessages(messages: Message[], model: Mod
     dropAllThinking?: boolean;
     droppedThinkingBlocks?: ReadonlySet<string>;
     credentialId?: number;
+    /** On-demand compaction request: it ends inside the conversation, so it gets nothing live requests lack there. */
+    compactionRequest?: AnthropicCompactionRequest;
 }): AnthropicMessageParam[];
 export declare function normalizeAnthropicToolSchema(schema: unknown): unknown;

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

@@ -5,13 +5,16 @@
  * Sources, in priority order:
  *   1. `GOOGLE_APPLICATION_CREDENTIALS` env → file with `type: "service_account"` (RS256 JWT exchange)
  *     or `type: "authorized_user"` (refresh-token exchange).
- *   2. `~/.config/gcloud/application_default_credentials.json` (user ADC, same authorized_user flow).
+ *   2. gcloud user ADC: `%APPDATA%\gcloud\application_default_credentials.json` on Windows,
+ *     `~/.config/gcloud/application_default_credentials.json` elsewhere (authorized_user flow).
  *   3. GCE / Cloud Run metadata server (`metadata.google.internal`).
  *
  * Tokens are cached per source key and refreshed `GOOGLE_VERTEX_REFRESH_SKEW_MS` before expiry
  * (default 60s). Concurrent callers waiting on a refresh share the same in-flight promise.
  */
 import type { FetchImpl } from "../types.js";
+/** gcloud's user ADC file: `%APPDATA%\gcloud\…` on Windows, `~/.config/gcloud/…` elsewhere. */
+export declare function userAdcPath(platform?: typeof process.platform, appData?: string | undefined): string;
 /**
  * Returns a Bearer access token suitable for the `Authorization` header on Vertex AI calls.
  * The token is cached in module scope and refreshed `GOOGLE_VERTEX_REFRESH_SKEW_MS` ms before it expires.

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

@@ -41,7 +41,7 @@
  *   // Inspect calls afterwards.
  *   expect(mock.calls).toHaveLength(2);
  */
-import type { AnthropicFallbackCreditHandle, Api, Context, Model, SimpleStreamOptions, StopDetails, StopReason, Usage } from "../types.js";
+import type { AnthropicFallbackCreditHandle, Api, Context, Model, ServiceTier, SimpleStreamOptions, StopDetails, StopReason, Usage } from "../types.js";
 import { AssistantMessageEventStream } from "../utils/event-stream.js";
 /** The API string this provider serves. */
 export declare const MOCK_API: "mock";
@@ -78,6 +78,8 @@ export interface MockResponse {
     usage?: Partial<Omit<Usage, "cost">> & {
         cost?: Partial<Usage["cost"]>;
     };
+    /** Service tier the mock reports serving the turn, as a real provider's response echo would. */
+    serviceTier?: ServiceTier;
     /** Pre-set responseId. */
     responseId?: string;
     /** If set, the stream emits a terminal error event instead of completing. */

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

@@ -906,60 +906,6 @@ export declare namespace Response {
              */
             type: "error";
         }
-        /**
-         * A moderation result produced for the response input or output.
-         */
-        interface ModerationResult {
-            /**
-             * A dictionary of moderation categories to booleans, True if the input is flagged
-             * under this category.
-             */
-            categories: {
-                [key: string]: boolean;
-            };
-            /**
-             * Which modalities of input are reflected by the score for each category.
-             */
-            category_applied_input_types: {
-                [key: string]: Array<"text" | "image">;
-            };
-            /**
-             * A dictionary of moderation categories to scores.
-             */
-            category_scores: {
-                [key: string]: number;
-            };
-            /**
-             * A boolean indicating whether the content was flagged by any category.
-             */
-            flagged: boolean;
-            /**
-             * The moderation model that produced this result.
-             */
-            model: string;
-            /**
-             * The object type, which was always `moderation_result` for successful moderation
-             * results.
-             */
-            type: "moderation_result";
-        }
-        /**
-         * An error produced while attempting moderation for the response input or output.
-         */
-        interface Error {
-            /**
-             * The error code.
-             */
-            code: string;
-            /**
-             * The error message.
-             */
-            message: string;
-            /**
-             * The object type, which was always `error` for moderation failures.
-             */
-            type: "error";
-        }
     }
 }
 /**

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

@@ -16,9 +16,9 @@ export interface OpenAIResponsesOptions extends StreamOptions {
     /**
      * Stateful turns: chain via `previous_response_id` + delta input instead of
      * replaying the full transcript. Forces `store: true` (the platform only
-     * resolves stored responses). Defaults ON against the official OpenAI API
-     * and OFF for other Responses endpoints; `PI_OPENAI_STATEFUL` overrides the
-     * default, and `false` here vetoes everything. Requires `sessionId` +
+     * resolves stored responses). Precedence: this option, then
+     * `PI_OPENAI_STATEFUL`, then `compat.statefulResponses`, then ON against the
+     * official OpenAI API and OFF elsewhere. Requires `sessionId` +
      * `providerSessionState`. Falls back to a full replay whenever history
      * mutates or the server reports a stale id.
      */
@@ -60,6 +60,27 @@ export interface OpenAIResponsesOptions extends StreamOptions {
     /** Opt-in GPT-5.6+ prompt-cache policy. Unsupported explicit mode fails locally. */
     promptCache?: OpenAIPromptCacheOptions;
 }
+/**
+ * Poll a stored Responses result until it reaches an adoptable terminal state.
+ * 404s, 5xx, and transport failures mean "not yet" (an in-flight run only
+ * becomes retrievable once the server finishes it); any other status, a
+ * mismatched id, or a failed/cancelled run ends the poll immediately. The
+ * whole recovery is bounded by one wall-clock deadline: each request's timeout
+ * is clamped to the time left, and no sleep may cross the deadline, so a
+ * stalled host cannot hold an already-failed turn past it. Returns the
+ * terminal object, or undefined on give-up/abort.
+ *
+ * @internal Exported for tests.
+ */
+export declare function pollOpenAIResponsesResultForCompletion(args: {
+    fetchImpl: NonNullable<StreamOptions["fetch"]>;
+    url: string;
+    headers: Record<string, string>;
+    responseId: string;
+    signal?: AbortSignal;
+    /** Sleep between polls; defaults to a real wait honoring `signal`. */
+    wait?: (ms: number, signal?: AbortSignal) => Promise<void>;
+}): Promise<Record<string, unknown> | undefined>;
 interface OpenAIResponsesProviderSessionState extends ProviderSessionState, OpenAIStrictToolsState, OpenAIReasoningEffortFallbackState {
     nativeHistoryReplayWarmed: boolean;
     /** Stateful `previous_response_id` chain baselines, keyed by baseUrl/model/session. */
@@ -85,6 +106,14 @@ interface OpenAIResponsesChainState {
     /** Set once chaining is judged unsupported for this session (circuit breaker). */
     disabled: boolean;
 }
+/**
+ * Set the process-wide storage default per provider id, used when a request
+ * leaves `storeResponses` unset. Hosts call this from their settings so every
+ * request follows the setting, including direct `streamSimple`/`completeSimple`
+ * side calls that do not pass per-request options. `PI_MUSE_STORE_RESPONSES`
+ * still overrides it.
+ */
+export declare function configureProviderStoreResponses(byProvider: Readonly<Record<string, boolean>> | undefined): void;
 /**
  * Drop the account-bound half of every retained `openai-responses` record in
  * `states`: the stateful `previous_response_id` chain baselines.

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

@@ -76,8 +76,11 @@ export declare function applyOpenAIServiceTier(params: {
  * resolved request tier. Scoped to `provider: "openai"` (the only standard
  * Responses biller) so an echoed `service_tier` from an Azure/OpenRouter/Copilot
  * proxy can never skew those costs.
+ *
+ * Returns the tier the turn ran on for the caller to record on the message, and
+ * counts the premium request the tier bills.
  */
-export declare function applyOpenAIResponsesServiceTierCost(model: Pick<Model, "provider" | "serviceTierCost">, usage: AssistantMessage["usage"], responseServiceTier: unknown, requestServiceTier: ServiceTier | null | undefined): void;
+export declare function applyOpenAIResponsesServiceTierCost(model: Pick<Model, "provider" | "serviceTierCost" | "api" | "identity">, usage: AssistantMessage["usage"], responseServiceTier: unknown, requestServiceTier: ServiceTier | null | undefined): ServiceTier | undefined;
 /**
  * Reconcile token-price estimates with a gateway's authoritative account charge.
  * BYOK turns (`is_byok: true`) price from the provider spend in

package/dist/types/registry/oauth/cursor.d.ts

@@ -1,3 +1,4 @@
+import type { FetchImpl } from "../../types.js";
 import type { OAuthController, OAuthCredentials } from "./types.js";
 export interface CursorAuthParams {
     verifier: string;
@@ -13,6 +14,13 @@ export declare function pollCursorAuth(uuid: string, verifier: string): Promise<
 export declare function loginCursor(onAuthUrl: (url: string) => void, onPollStart?: () => void): Promise<OAuthCredentials>;
 export declare function loginCursorHook(callbacks: OAuthController): Promise<OAuthCredentials>;
 export declare function refreshCursorToken(apiKeyOrRefreshToken: string): Promise<OAuthCredentials>;
-export declare function refreshCursorHook(credentials: OAuthCredentials): Promise<OAuthCredentials>;
+export declare function refreshCursorHook(credentials: OAuthCredentials, signal?: AbortSignal): Promise<OAuthCredentials>;
+/** Request headers that present `accessToken` to cursor.com as its user's web session. */
+export declare function cursorSessionHeaders(userId: string, accessToken: string): Record<string, string>;
+/**
+ * Email of the Cursor account that owns `accessToken`, read from its cursor.com
+ * profile. Undefined when the token names no user or the profile names another.
+ */
+export declare function fetchCursorAccountEmail(accessToken: string, fetchImpl?: FetchImpl, signal?: AbortSignal): Promise<string | undefined>;
 export declare function extractCursorAccessTokenUserId(accessToken: string): string | undefined;
 export declare function isCursorTokenExpiringSoon(token: string, thresholdSeconds?: number): boolean;

package/dist/types/registry/oauth/index.d.ts

@@ -43,3 +43,5 @@ export declare function getOAuthApiKey(provider: OAuthProvider, credentials: Rec
  * Get list of OAuth providers.
  */
 export declare function getOAuthProviders(): OAuthProviderInfo[];
+/** Provider id that stores `providerId`'s credentials: login aliases (`openai-codex-device`) map to their target (`openai-codex`). */
+export declare function getOAuthCredentialProvider(providerId: string): string;

package/dist/types/registry/oauth/snowflake.d.ts

@@ -0,0 +1,3 @@
+import type { OAuthController, OAuthCredentials } from "./types.js";
+export declare function loginSnowflake(ctrl: OAuthController): Promise<OAuthCredentials>;
+export declare function refreshSnowflakeToken(credentials: OAuthCredentials, signal?: AbortSignal): Promise<OAuthCredentials>;

package/dist/types/registry/snowflake.d.ts

@@ -0,0 +1,4 @@
+import type { ProviderTransport } from "./build.js";
+/** Normalize account identifiers and Snowsight links without accepting arbitrary credential-receiving hosts. */
+export declare function normalizeSnowflakeAccountUrl(input: string): string;
+export declare const snowflakeTransport: ProviderTransport;

package/dist/types/types.d.ts

@@ -157,18 +157,31 @@ export declare function shouldSendServiceTier(serviceTier: ServiceTier | null |
  */
 export declare function realizesPriorityServiceTier(serviceTier: ServiceTier | null | undefined, model: ServiceTierModel): boolean;
 /**
- * Premium-request weight contributed by a priority request to a provider that
- * realizes it and bills extra. Mirrors GitHub Copilot's `premiumRequests`
- * accounting so the "premium requests" stat aggregates priority traffic across
- * the OpenAI family, direct Anthropic fast mode, and Google priority.
+ * Premium-request weight contributed by a request a provider bills above
+ * standard. Priority (Fast mode) counts 1 on every provider that realizes it;
+ * `ultrafast` counts 1 on the OpenAI family, where it is a premium serving tier
+ * (its cost premium is recorded separately in `usage.cost`). Mirrors GitHub
+ * Copilot's `premiumRequests` accounting so the "premium requests" stat
+ * aggregates premium traffic across the OpenAI family, direct Anthropic fast
+ * mode, and Google priority.
  *
- * Returns 1 only when priority is actually realized on the wire for `model`
- * (see {@link realizesPriorityServiceTier}) and the provider bills it as a
- * premium request. OpenRouter is excluded — it bills per its own pricing, not
- * Copilot-premium semantics — as are Bedrock/Vertex Claude, where priority is
- * silently dropped.
+ * Returns 1 only when the tier is actually realized on the wire for `model`
+ * (see {@link realizesPriorityServiceTier} and {@link shouldSendServiceTier})
+ * and the provider bills it as a premium request. OpenRouter is excluded — it
+ * bills per its own pricing, not Copilot-premium semantics — as are
+ * Bedrock/Vertex Claude, where priority is silently dropped.
+ *
+ * Pass `served: true` when the tier is the one the provider reported serving
+ * (an assistant message's {@link AssistantMessage.serviceTier}) rather than a
+ * requested setting: realization is then already proven, so the wire gate is
+ * skipped and a model without discovery metadata (a stats-backfill row) still
+ * counts.
  */
-export declare function getPriorityPremiumRequests(serviceTier: ServiceTier | null | undefined, model: ServiceTierModel): number;
+export declare function getPremiumServiceTierRequests(serviceTier: ServiceTier | null | undefined, model: ServiceTierModel, options?: {
+    served?: boolean;
+}): number;
+/** Parse a provider-reported `service_tier` echo into a known tier, or `undefined` for anything else. */
+export declare function parseServiceTier(value: unknown): ServiceTier | undefined;
 /**
  * Coerce a persisted service-tier value to a {@link ServiceTierByFamily}. Newer
  * sessions store the family map directly; legacy sessions stored a single
@@ -215,6 +228,11 @@ export interface CodexCompactionRequestContext extends CodexCompactionMetadata {
 export interface AnthropicCompactionRequest {
     /** Custom summarization prompt; replaces the API default entirely when set. */
     instructions?: string;
+    /**
+     * Replayed summaries' file metadata due before this time (ms) ends the request;
+     * later metadata replays with the retained tail, which the new summary carries.
+     */
+    filesDueBefore?: number;
 }
 /** OpenAI's GPT-5.6+ explicit prompt-cache controls. */
 export interface OpenAIPromptCacheOptions {
@@ -333,6 +351,16 @@ export interface StreamOptions {
      * `false` so `previous_response_id` cannot explain a result.
      */
     statefulResponses?: boolean;
+    /**
+     * Store this request's result server-side on hosts that support it
+     * (`compat.storeResponses`, e.g. Muse Code), so a stream that drops
+     * mid-turn resumes from `GET /responses/{id}` instead of re-running the
+     * turn. Privacy: stored runs retain prompts and outputs on the provider.
+     * Unset falls back to `PI_MUSE_STORE_RESPONSES`, then the host's
+     * `configureProviderStoreResponses` default, else off. Ignored on hosts
+     * without the capability.
+     */
+    storeResponses?: boolean;
     /**
      * Disable native reasoning when the caller supplies an external scratchpad.
      * OpenAI Responses emits `reasoning: { effort: "none" }`; Anthropic and
@@ -363,6 +391,8 @@ export interface StreamOptions {
      * are not covered.
      */
     maxInFlightRequests?: Record<string, number>;
+    /** @internal Keep the in-flight permit until a provider's bounded terminal drain finishes. */
+    waitForTerminalDrain?: boolean;
     /**
      * Optional callback for inspecting or replacing provider payloads before sending.
      * Return undefined to keep the payload unchanged.
@@ -820,11 +850,31 @@ export interface AnthropicCompactionPayload {
     encryptedContent?: string;
     /**
      * Harness-appended file metadata (`<files>` section) kept out of the
-     * byte-identical block. Replayed as a user message after the native block:
-     * the converter replaces the summary message with the block and skips its
-     * text, so without this the metadata would be invisible to this provider.
+     * byte-identical block. The converter replaces the summary message with the
+     * block and skips its text, so it replays this as a user message after the
+     * block's retained tail: before the first message created after the summary.
      */
     filesText?: string;
+    /**
+     * File metadata of earlier summaries whose replay position lies inside this
+     * summary's retained tail. Retained messages must reach the API unchanged,
+     * so each keeps replaying where it did: before the first message created
+     * after `after` (the earlier summary's commit time).
+     */
+    retainedFiles?: AnthropicCompactionFiles[];
+    /**
+     * Set on summaries whose retained tail replays unchanged: file metadata
+     * after the tail, earlier metadata at `retainedFiles`. Summaries persisted
+     * without it keep their original layout (metadata after the first retained
+     * turn), since later thinking was signed against those bytes.
+     */
+    exactTail?: true;
+}
+/** File metadata replayed at a fixed point of a natively compacted conversation. */
+export interface AnthropicCompactionFiles {
+    text: string;
+    /** Replays before the first message created after this time (ms). */
+    after: number;
 }
 export type ProviderPayload = OpenAIResponsesHistoryPayload | AnthropicMessagePayload | AnthropicCompactionPayload;
 /** Provider-reported rewrite applied to request content before inference. */
@@ -928,6 +978,15 @@ export interface AssistantMessage {
      * other than what was requested.
      */
     upstreamModel?: string;
+    /**
+     * Service tier the provider reported serving this turn, when the API echoes
+     * one (`response.service_tier`), falling back to the tier the request carried
+     * when the response omits the echo. Absent when the provider reports no tier
+     * or the echo cannot be trusted (proxies). This is the tier the turn actually
+     * ran on, which is what cost, premium-request, and speed accounting key on —
+     * the session's live setting may already have changed.
+     */
+    serviceTier?: ServiceTier;
     usage: Usage;
     stopReason: StopReason;
     stopDetails?: StopDetails | null;

package/dist/types/utils/idle-iterator.d.ts

@@ -138,6 +138,12 @@ export interface TerminalGraceIteratorOptions {
      * the transport until that pending read settles.
      */
     onGraceEnd?: () => void;
+    /**
+     * Wait for the bounded drain when the consumer returns early. Capped
+     * requests must not release their in-flight permit while the transport
+     * still owns a live connection.
+     */
+    awaitDrainOnReturn?: boolean;
 }
 /**
  * Yields items from an async iterable until the consumer marks the stream
@@ -148,5 +154,10 @@ export interface TerminalGraceIteratorOptions {
  * hangs on `iterator.next()` until the idle watchdog converts an
  * already-successful turn into a timeout error. Grace expiry is a clean end
  * of iteration, never an error.
+ *
+ * A consumer that stops early (`break`) after `finishedAtMs()` is set leaves
+ * the source draining until `[DONE]`/EOF or the same grace deadline. Without
+ * `awaitDrainOnReturn`, the consumer is not held up; capped requests await
+ * the drain before completing and releasing their in-flight permit.
  */
 export declare function iterateWithTerminalGrace<T>(iterable: AsyncIterable<T>, options: TerminalGraceIteratorOptions): AsyncGenerator<T>;