@oh-my-pi/pi-ai 18.6.0 → 18.6.3

package/CHANGELOG.md

@@ -2,6 +2,37 @@
 
 ## [Unreleased]
 
+## [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
+
+- Fixed compatibility with Command Code DeepSeek and other DeepSeek-family models by preserving the reasoning context required for warm OpenAI Responses sessions and correctly handling incomplete DSML tool-call wrappers in visible output.
+
 ## [18.6.0] - 2026-10-03
 
 ### Fixed
@@ -2284,41 +2315,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/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/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/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

@@ -215,6 +215,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 +338,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 +378,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 +837,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. */

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>;

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

@@ -63,10 +63,10 @@ export declare class StreamMarkupHealing {
     /** Drain accumulated tool calls from calls to {@link feed}. */
     drainCompleted(): HealedToolCall[];
     /**
-     * Flush held-back stream-end fragments as ordered events. Partial tool-call
-     * sections/envelopes are dropped by the delegated scanners; unterminated
-     * thinking blocks are emitted as thinking, matching the previous MiniMax parser
-     * behavior.
+     * Flush held-back stream-end fragments as ordered events. Partial tool calls
+     * are dropped by the delegated scanners; a DSML wrapper without an invoke
+     * remains visible for agent-layer leak recovery. Unterminated thinking blocks
+     * are emitted as thinking.
      */
     flushEvents(): StreamMarkupHealingEvent[];
     /** Flush held-back text only. Reconstructed calls are retained for {@link drainCompleted}. */

package/dist/types/utils.d.ts

@@ -34,6 +34,12 @@ export declare function stripOpenAIResponsesOutputOnlyStatusesForReplay<TItem ex
     type?: unknown;
     status?: unknown;
 }>(items: TItem[]): TItem[];
+/** Clamp replayed images without changing item identities or other native replay fields. */
+export declare function clampOpenAIResponsesImageDetailForReplay<TItem extends {
+    type?: unknown;
+    detail?: unknown;
+    content?: unknown;
+}>(items: TItem[], supportsImageDetailOriginal: boolean): TItem[];
 export declare function sanitizeOpenAIResponsesHistoryItemsForReplay(items: Array<Record<string, unknown>>, options?: OpenAIResponsesReplaySanitizeOptions): ResponseInput;
 /** Strip reasoning IDs whose only linked native output is a computer call that will be demoted. */
 export declare function stripOpenAIResponsesComputerLinkedReasoningIdsForReplay(items: ResponseInput): ResponseInput;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@oh-my-pi/pi-ai",
-	"version": "18.6.0",
+	"version": "18.6.3",
 	"description": "Unified LLM API with automatic model discovery and provider configuration",
 	"keywords": [
 		"ai",
@@ -155,11 +155,11 @@
 		"fmt": "oxfmt --no-error-on-unmatched-pattern 'src/**/*.{ts,tsx}' '{test,bench,examples,scripts}/**/*.ts' '*.ts'"
 	},
 	"dependencies": {
-		"@oh-my-pi/omptype": "18.6.0",
-		"@oh-my-pi/pi-catalog": "18.6.0",
-		"@oh-my-pi/pi-natives": "18.6.0",
-		"@oh-my-pi/pi-utils": "18.6.0",
-		"@oh-my-pi/pi-wire": "18.6.0"
+		"@oh-my-pi/omptype": "18.6.3",
+		"@oh-my-pi/pi-catalog": "18.6.3",
+		"@oh-my-pi/pi-natives": "18.6.3",
+		"@oh-my-pi/pi-utils": "18.6.3",
+		"@oh-my-pi/pi-wire": "18.6.3"
 	},
 	"devDependencies": {
 		"@types/bun": "^1.3.14"

package/src/auth/cascade.ts

@@ -356,7 +356,9 @@ export class KeyCascade implements KeysApi {
 			credential => credential.source === "login" && !this.isKeylessFallback(provider, credential),
 		);
 		if (loginApiKeySelection) {
-			this.#deps.affinity.record(provider, sessionId, "api_key", loginApiKeySelection.index);
+			if (options?.recordAffinity !== false) {
+				this.#deps.affinity.record(provider, sessionId, "api_key", loginApiKeySelection.index);
+			}
 			const credentialId = onCredentialId
 				? this.#deps.pool.entries(provider)[loginApiKeySelection.index]?.id
 				: undefined;
@@ -382,7 +384,9 @@ export class KeyCascade implements KeysApi {
 			credential => credential.source !== "login",
 		);
 		if (apiKeySelection) {
-			this.#deps.affinity.record(provider, sessionId, "api_key", apiKeySelection.index);
+			if (options?.recordAffinity !== false) {
+				this.#deps.affinity.record(provider, sessionId, "api_key", apiKeySelection.index);
+			}
 			const credentialId = onCredentialId ? this.#deps.pool.entries(provider)[apiKeySelection.index]?.id : undefined;
 			const apiKey = await this.#deps.overrides.resolve(apiKeySelection.credential.key);
 			if (apiKey !== undefined && credentialId !== undefined) onCredentialId?.(credentialId);

package/src/auth/health.ts

@@ -283,6 +283,7 @@ export class CredentialHealth implements HealthApi {
 		const results: CredentialHealthResult[] = [];
 		for (const row of stored) {
 			options?.signal?.throwIfAborted();
+			if (options?.excludeProviders?.has(row.provider)) continue;
 			const base: CredentialHealthResult = {
 				id: row.id,
 				provider: row.provider,

package/src/auth/select.ts

@@ -1055,7 +1055,9 @@ export class CredentialSelector {
 				}
 			}
 			this.#deps.pool.noteBearer(provider, result.apiKey, credentialId);
-			this.#deps.affinity.record(provider, sessionId, "oauth", selection.index);
+			if (options?.recordAffinity !== false) {
+				this.#deps.affinity.record(provider, sessionId, "oauth", selection.index);
+			}
 			return { apiKey: result.apiKey, credential: updated, credentialId };
 		} catch (error) {
 			const errorMsg = String(error);

package/src/auth/types.ts

@@ -257,6 +257,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>;
 }
 
 // ─────────────────────────────────────────────────────────────────────────────
@@ -487,6 +489,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. */

package/src/auth-broker/refresher.ts

@@ -75,7 +75,12 @@ export class AuthBrokerRefresher {
 		};
 	}
 
-	/** 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.
+	 */
 	async tick(): Promise<void> {
 		if (this.#running) return;
 		this.#running = true;
@@ -94,6 +99,8 @@ export class AuthBrokerRefresher {
 				targets.push(entry.id);
 			}
 			await Promise.all(targets.map(id => this.#refreshOne(id)));
+		} catch (error) {
+			logger.warn("auth-broker refresh sweep failed", { error: String(error) });
 		} finally {
 			this.#running = false;
 			this.#nextSweepAt = this.#now() + this.#refreshIntervalMs;

package/src/dialect/deepseek.ts

@@ -128,6 +128,8 @@ export class DeepSeekInbandScanner implements InbandScanner {
 	#dsmlParamName = "";
 	#dsmlParamIsString = true;
 	#dsmlParamRaw = "";
+	/** Unclassified wrapper text is kept until an invoke proves it is a tool call. */
+	#pendingDsmlSection: string | undefined;
 	#rawBlock = "";
 	#stripLeadingWhitespace = false;
 	/**
@@ -194,6 +196,12 @@ export class DeepSeekInbandScanner implements InbandScanner {
 			if (!this.#consumeDsmlParam(final, events)) break;
 		}
 		if (final && this.#state === "thinking") this.#endThinking(events);
+		if (final && this.#pendingDsmlSection !== undefined) {
+			this.#emitText(this.#pendingDsmlSection + this.#buffer, events);
+			this.#pendingDsmlSection = undefined;
+			this.#buffer = "";
+			this.#state = "outside";
+		}
 		if (final && this.#buffer.length === 0 && this.#rawBlock.length > 0) this.#rawBlock = "";
 		return events;
 	}
@@ -249,6 +257,7 @@ export class DeepSeekInbandScanner implements InbandScanner {
 					? DSML_TOOL_CALLS_OPEN_FULLWIDTH
 					: DSML_TOOL_CALLS_OPEN_ASCII;
 				this.#buffer = this.#buffer.slice(openToken.length);
+				this.#pendingDsmlSection = openToken;
 				this.#state = "dsmlSection";
 				return;
 			}
@@ -381,16 +390,25 @@ export class DeepSeekInbandScanner implements InbandScanner {
 	}
 
 	#consumeDsmlSection(final: boolean, events: InbandScanEvent[]): boolean {
+		const initial = this.#buffer;
 		while (this.#buffer.length > 0) {
 			this.#skipWhitespace();
 			const close = this.#matchingDsmlClose(DSML_TOOL_CALLS_CLOSE_FULLWIDTH, DSML_TOOL_CALLS_CLOSE_ASCII);
 			if (close) {
+				if (this.#pendingDsmlSection !== undefined) {
+					this.#emitText(
+						this.#pendingDsmlSection + initial.slice(0, initial.length - this.#buffer.length) + close,
+						events,
+					);
+					this.#pendingDsmlSection = undefined;
+				}
 				this.#buffer = this.#buffer.slice(close.length);
 				this.#state = "outside";
 				return true;
 			}
 			const invoke = this.#matchDsmlOpen("invoke");
 			if (invoke) {
+				this.#pendingDsmlSection = undefined;
 				this.#rawBlock = invoke.raw;
 				this.#name = invoke.name;
 				this.#id = mintToolCallId();
@@ -404,12 +422,15 @@ export class DeepSeekInbandScanner implements InbandScanner {
 					(this.#buffer.startsWith("<｜DSML｜invoke") || this.#buffer.startsWith("<|DSML|invoke")) &&
 					!this.#buffer.includes(">")
 				)
-					return false;
-				if (partialSuffixOverlapAny(this.#buffer, DSML_SECTION_TOKENS) === this.#buffer.length) return false;
+					break;
+				if (partialSuffixOverlapAny(this.#buffer, DSML_SECTION_TOKENS) === this.#buffer.length) break;
 			}
-			if (this.#buffer.length === 0) return false;
+			if (this.#buffer.length === 0) break;
 			this.#buffer = this.#buffer.slice(1);
 		}
+		if (this.#pendingDsmlSection !== undefined) {
+			this.#pendingDsmlSection += initial.slice(0, initial.length - this.#buffer.length);
+		}
 		return final;
 	}