@oh-my-pi/pi-ai 18.1.4 → 18.1.6

package/CHANGELOG.md

@@ -2,6 +2,49 @@
 
 ## [Unreleased]
 
+## [18.1.6] - 2026-09-03
+
+### Breaking Changes
+
+- Renamed `claudeCodeSessionId` to `sessionId` in `AnthropicClientOptionsArgs`.
+- Renamed `openAISessionId` to `sessionId` in `OpenAIRequestSetupOptions`.
+
+### Added
+
+- Added Amazon Bedrock `requestMetadata` support for cost and usage attribution in AWS invocation logs.
+
+### Changed
+
+- Codex GPT-5.6 requests now use full Responses by default, enabling independent tool calls to run in parallel; provider-native compaction continues to use catalog-selected Responses Lite.
+- Inference requests now identify as omp by default while preserving explicit provider and OAuth User-Agent fingerprints. Amazon Bedrock requests use an `omp/<version>` User-Agent by default and honor configured `User-Agent` overrides.
+
+### Fixed
+
+- Fixed Antigravity usage reporting to match the official client's five-hour and weekly quota buckets.
+- Anthropic and OpenRouter credit-exhaustion errors now automatically switch to a sibling account instead of stopping the turn with a retry hint.
+- Fixed OpenCode Go and Zen requests by including the required stable per-conversation session identification.
+- Improved Anthropic prompt caching so explicit cache breakpoints preserve reusable tools and system prompts when the message tail changes.
+
+## [18.1.5] - 2026-09-03
+
+### Added
+
+- Added `/login abliteration` with API key validation against `/v1/models`, supporting the `ABLITERATION_API_KEY` and `ABLIT_KEY` environment variables.
+
+### Changed
+
+- Modernized provider authentication and token refresh across the catalog, with shared support for API-key, authorization-code, and device-code sign-in flows and clearer sign-in progress messages for OpenRouter, Kimi, and xAI.
+
+### Fixed
+
+- GitHub Copilot now uses the official Copilot CLI identity and OAuth application for requests and new sign-ins, restoring access to client-gated models while preserving existing credentials.
+- GitHub Copilot now reports `model_not_supported` responses immediately instead of repeatedly retrying unsupported models.
+- Improved account recovery after Google rate limits are lifted earlier than the reported reset time.
+- Fixed unmetered autocomplete models being reported as exhausted when quota is limited.
+- Fixed Gemini 3 cross-model sessions in Cloud Code Assist when replaying tool calls without a thought signature.
+- Fixed Cursor models behind an authentication gateway incorrectly retrying valid client-declared tool calls.
+- Fixed reasoning from models that prefill `<think>` (including DeepSeek-R1 and hosted Qwen3-Thinking) being shown in the response instead of as a separate thinking block.
+
 ## [18.1.3] - 2026-09-02
 
 ### Fixed
@@ -163,7 +206,7 @@
 - Fixed Codex continuations, retries, and compaction replacing or dropping the turn-scoped sticky-routing token ([#9277](https://github.com/can1357/oh-my-pi/issues/9277)).
 - Fixed Codex Responses append chains falling back to full-context replay when replay-sanitized assistant items differ only by output-only IDs or lifecycle status.
 - Fixed Cursor usage reporting “no usage data” for plans without a numeric legacy request cap.
-- Fixed DeepSeek models rejecting requests with HTTP 400 `unknown variant \`image_url\`, expected \`text\`` when screenshots or image-producing tool results are present in conversation history or when `model.input` claims vision capability; `convertMessages` in `openai-completions` now strips `image_url` content parts and injects non-vision image placeholders for all DeepSeek endpoints.
+- Fixed DeepSeek models rejecting requests with HTTP 400 `unknown variant \`image_url\`, expected \`text\``when screenshots or image-producing tool results are present in conversation history or when`model.input`claims vision capability;`convertMessages`in`openai-completions`now strips`image_url` content parts and injects non-vision image placeholders for all DeepSeek endpoints.
 - Fixed `PI_PROXY` covering only provider streams: OAuth token refresh and login, usage probes, and model discovery went out through the bare global `fetch` and ignored it, so a region-blocked token endpoint answered `403 Request not allowed` (Anthropic `/v1/oauth/token`) and disabled the credential while the proxied stream itself worked. `installGlobalProxyFetch()` now routes the process-wide `fetch` through `PI_PROXY`; a per-request proxy such as `PI_PROXY_<PROVIDER>` still wins, and loopback / private-range / `NO_PROXY` targets stay direct.
 - Fixed Anthropic inference ignoring every proxy setting. `coworkFetch` runs on `node:https`, whose Bun shim discards both `agent.createConnection` and `options.createConnection`: the CONNECT tunnel to `PI_PROXY` was built, TLS-negotiated, then abandoned, and the request dialed `api.anthropic.com` on the default route (measured at the proxy: 581 bytes of handshake, zero request bytes). On a region-blocked egress that returned `403 {"type":"forbidden","message":"Request not allowed"}` with the proxy apparently configured. Proxied requests now go through Bun's own `fetch`, which honors `init.proxy`, trading the Cowork TLS/header profile for a proxy that actually carries the traffic; the dead tunnel plumbing is gone from the transport. `node:http2` (Cursor) does honor `createConnection` and is unaffected.
 - Fixed `cowork-fetch` capturing `globalThis.fetch` at module load, so a proxy wrapper installed later in startup was ignored on its fallback path.
@@ -233,7 +276,7 @@
 
 ### Changed
 
-- Fixed Gemini thought summaries occasionally leaking a raw `` ```thinking `` / `` ``````thinking `` fence delimiter into the reasoning block, so it no longer shows up as fence spam in the thinking display or persisted transcripts ([#8719](https://github.com/can1357/oh-my-pi/issues/8719)).
+- Fixed Gemini thought summaries occasionally leaking a raw ` ```thinking ` / ` ``````thinking ` fence delimiter into the reasoning block, so it no longer shows up as fence spam in the thinking display or persisted transcripts ([#8719](https://github.com/can1357/oh-my-pi/issues/8719)).
 - Fixed the OpenCode Go login prompting for an "OpenCode Zen API key": the shared login flow now names the provider you selected, so connecting OpenCode Go asks for an OpenCode Go key (the `opencode.ai/auth` console is still shared, as documented upstream) ([#8738](https://github.com/can1357/oh-my-pi/issues/8738)).
 - Fixed Anthropic-compatible endpoints with strict prompt validation (e.g. Z.AI GLM `api.z.ai/api/anthropic`, which rejects the whole request with `400 code 1213 "The prompt parameter was not received normally"`) failing sessions once a tool returned empty output on a vision-capable model: empty successful `tool_result` blocks now encode as `content: ""` instead of `content: []`, which both the official API and strict compatible endpoints accept.
 - Fixed `retry.usageReservePct` (Reserve Margin) ignoring Claude Fable/Mythos weekly tier usage until it hit 100%, so a Fable model kept serving turns past the configured reserve; reserve health now honors the mapped tier row while credential-wide hard blocks still require confirmed exhaustion ([#8773](https://github.com/can1357/oh-my-pi/issues/8773)).
@@ -1285,7 +1328,7 @@
 
 - Added a third streaming thinking-loop detection heuristic to catch "progress-lexicon stalls" where models endlessly reshuffle motivational filler without introducing new vocabulary or concrete technical references
 - Added branded wordmark and logo animation to authentication flow
-- Added a third streaming thinking-loop detection shape — a *progress-lexicon stall* — alongside verbatim tail repetition and near-duplicate (trigram) segments. It catches reasoning-summarizer loops that reshuffle the same motivational filler ("just doing it, pushing ahead, maintaining momentum") into fresh word order every paragraph: word-trigrams never cluster, but a run of substantial segments that recycle the recent vocabulary and introduce no *new* concrete reference (path / identifier / code-span) trips the guard. Summarizer title/heading lines (`**Bold Title**`, `## Heading`) are stripped before analysis so their ever-changing wording cannot mask the stall by inflating novelty. Calibrated against 537k real non-Gemini reasoning blocks (zero false positives at novelty floor 0.2 / run length 8; the real loop sustains runs of 10+).
+- Added a third streaming thinking-loop detection shape — a _progress-lexicon stall_ — alongside verbatim tail repetition and near-duplicate (trigram) segments. It catches reasoning-summarizer loops that reshuffle the same motivational filler ("just doing it, pushing ahead, maintaining momentum") into fresh word order every paragraph: word-trigrams never cluster, but a run of substantial segments that recycle the recent vocabulary and introduce no _new_ concrete reference (path / identifier / code-span) trips the guard. Summarizer title/heading lines (`**Bold Title**`, `## Heading`) are stripped before analysis so their ever-changing wording cannot mask the stall by inflating novelty. Calibrated against 537k real non-Gemini reasoning blocks (zero false positives at novelty floor 0.2 / run length 8; the real loop sustains runs of 10+).
 - Added CoreWeave Serverless Inference provider login support via `COREWEAVE_API_KEY` and `WANDB_API_KEY` fallback.
 
 ### Changed
@@ -1429,7 +1472,7 @@
 - Fixed tool call ID normalization for Anthropic-compatible models
 - Fixed Anthropic Messages replay sanitizing malformed tool-call IDs, including aborted native tool calls with empty IDs, so retries no longer send invalid `tool_use.id` / `tool_result.tool_use_id` pairs.
 - Fixed the Codex Responses WebSocket transport attributing a prior turn's output to the current one on a reused connection: a trailing/duplicate frame from a cleanly-completed previous response that slipped past the queue drain could be consumed as this request's terminal (ending the turn with empty output) or as a stale tool call. Frames are now keyed by `response.id` — a frame carrying the previous response's id is dropped, and one carrying a third id (or a regressed `sequence_number`) fails closed so the turn retries instead of mixing two responses' streams. Idless frames (deltas, the rate-limit/metadata preamble, `response.created`-less streams) still pass through, matching upstream codex-rs.
-- Fixed `transformMessages` pulling an earlier, orphaned tool result onto a later tool call that reused the same id (left behind when compaction folded the originating `tool_use` into a summary). The pending-call flush now pairs each call with a result positioned *after* its assistant turn, so a reused id surfaces its own output rather than a prior turn's.
+- Fixed `transformMessages` pulling an earlier, orphaned tool result onto a later tool call that reused the same id (left behind when compaction folded the originating `tool_use` into a summary). The pending-call flush now pairs each call with a result positioned _after_ its assistant turn, so a reused id surfaces its own output rather than a prior turn's.
 - Fixed DashScope 429 rate-limit messages that mention authorization being classified as credential failures, preventing valid API keys from being invalidated after throttling. ([#3172](https://github.com/can1357/oh-my-pi/issues/3172))
 - Fixed OpenCode Go `401 Insufficient balance` quota errors being treated as unknown failures instead of usage-limit errors, restoring credential rotation and fallback chains. ([#3169](https://github.com/can1357/oh-my-pi/issues/3169))
 
@@ -1705,7 +1748,7 @@
 - Added `wrapInbandToolStream` function to process streaming responses with in-band tool call parsing
 - Added `ThinkingInbandScanner` for parsing thinking/reasoning blocks across dialects
 - Added `OwnedStream` class for managing dialect-aware streaming with tool call events
-- Added in-band thinking channels to every dialect that was missing one: `gemini` (a ```` ```thinking ```` fence mirroring ```` ```tool_code ````), `gemma` (its native `<|channel>thought…<channel|>` reasoning channel), `kimi` (`<think>…</think>`), and `pi` (`<thinking>…</thinking>`). Each scanner now parses reasoning into thinking events instead of leaking chain-of-thought into the visible reply, and every dialect's `renderThinking` is a real channel that round-trips back through its scanner (no passthrough renderers).
+- Added in-band thinking channels to every dialect that was missing one: `gemini` (a ` ```thinking ` fence mirroring ` ```tool_code `), `gemma` (its native `<|channel>thought…<channel|>` reasoning channel), `kimi` (`<think>…</think>`), and `pi` (`<thinking>…</thinking>`). Each scanner now parses reasoning into thinking events instead of leaking chain-of-thought into the visible reply, and every dialect's `renderThinking` is a real channel that round-trips back through its scanner (no passthrough renderers).
 
 ### Changed
 
@@ -1729,7 +1772,7 @@
 
 ### Added
 
-- Added the `gemini` in-band tool-call syntax with Python-style ```tool_code``` blocks and `default_api` invocations
+- Added the `gemini` in-band tool-call syntax with Python-style `tool_code` blocks and `default_api` invocations
 - Added the `gemma` token-delimited in-band tool-call syntax using `<|tool_call>` and `<|tool_response>` blocks
 - Added `gemini` and `gemma` to owned stream tool-result token detection so their tool responses are recognized
 - Fixed truncated Gemini and Gemma tool blocks from being emitted as plain text during streaming
@@ -1774,7 +1817,7 @@
 - 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 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
@@ -1983,7 +2026,7 @@
 
 ### Breaking Changes
 
-- The model catalog moved to the new `@oh-my-pi/pi-catalog` package. Deep subpath exports `@oh-my-pi/pi-ai/models.json`, `/models`, `/model-cache`, `/model-manager`, `/model-thinking`, `/effort`, `/provider-models*`, `/utils/discovery*`, `/providers/openai-codex/constants`, `/providers/google-gemini-headers`, and `/providers/openai-completions-compat` are gone — import the `@oh-my-pi/pi-catalog` equivalents (`/models.json`, `/models`, `/model-cache`, `/model-manager`, `/model-thinking`, `/effort`, `/provider-models*`, `/discovery*`, `/wire/codex`, `/wire/gemini-headers`, `/compat/openai`). The pi-ai root barrel re-exports only the model/effort *types* its own signatures use (`Model`, `Api`, `ThinkingConfig`, `Effort`, `Usage`, compat interfaces) — catalog *values* (`getBundledModel(s)`, `calculateCost`, `modelsAreEqual`, `clampThinkingLevelForModel`, `DEFAULT_MODEL_PER_PROVIDER`, …) must be imported from `@oh-my-pi/pi-catalog`.
+- The model catalog moved to the new `@oh-my-pi/pi-catalog` package. Deep subpath exports `@oh-my-pi/pi-ai/models.json`, `/models`, `/model-cache`, `/model-manager`, `/model-thinking`, `/effort`, `/provider-models*`, `/utils/discovery*`, `/providers/openai-codex/constants`, `/providers/google-gemini-headers`, and `/providers/openai-completions-compat` are gone — import the `@oh-my-pi/pi-catalog` equivalents (`/models.json`, `/models`, `/model-cache`, `/model-manager`, `/model-thinking`, `/effort`, `/provider-models*`, `/discovery*`, `/wire/codex`, `/wire/gemini-headers`, `/compat/openai`). The pi-ai root barrel re-exports only the model/effort _types_ its own signatures use (`Model`, `Api`, `ThinkingConfig`, `Effort`, `Usage`, compat interfaces) — catalog _values_ (`getBundledModel(s)`, `calculateCost`, `modelsAreEqual`, `clampThinkingLevelForModel`, `DEFAULT_MODEL_PER_PROVIDER`, …) must be imported from `@oh-my-pi/pi-catalog`.
 - `ProviderDefinition` is now auth-only: `defaultModel`, `createModelManagerOptions`, `catalogDiscovery`, `dynamicModelsAuthoritative`, `allowUnauthenticated`, and `specialModelManager` moved to pi-catalog's `CATALOG_PROVIDERS` table, and `KnownProviderId` was replaced by pi-catalog's `KnownProvider` (registry completeness is enforced by a compile-time check against that union). The pure GitHub Copilot key/endpoint helpers moved from `registry/oauth/github-copilot` to `@oh-my-pi/pi-catalog/wire/github-copilot`.
 
 ### Added
@@ -2072,7 +2115,7 @@
 - Fixed `AnthropicMessagesClient` spreading `fetchOptions` after the core request fields, letting a caller-supplied `signal`/`method`/`body` silently disconnect the timeout controller or corrupt the request. Transport extras (TLS) still pass through; core fields now always win.
 - Fixed Foundry mTLS/CA material being cached for the process lifetime when the env vars point at files: the cache key now folds in the file mtime so on-disk certificate rotation takes effect.
 - Fixed the Claude Code fingerprint version drifting across surfaces: the usage endpoint (`claude-cli/2.1.160`) and OAuth bootstrap (`claude-code/2.1.160`) pinned a stale version while `/v1/messages` reported 2.1.165; both now derive from `claudeCodeVersion`.
-- Fixed a system prompt that merely *mentions* `x-anthropic-billing-header:` mid-text suppressing the entire Claude Code system-block injection (billing header, instruction, and cch attestation); the resumed-session guard now anchors with `startsWith`.
+- Fixed a system prompt that merely _mentions_ `x-anthropic-billing-header:` mid-text suppressing the entire Claude Code system-block injection (billing header, instruction, and cch attestation); the resumed-session guard now anchors with `startsWith`.
 - Fixed lone surrogates in cross-API tool-call arguments reaching Anthropic's strict UTF-8 validation: replayed OpenAI/Google-origin `tool_use.input` string leaves are now deep-sanitized with `toWellFormed()`, while same-API Anthropic arguments stay byte-identical to keep prompt-cache prefixes stable.
 - Bounded the many-image resize fan-out to 4 concurrent decodes (it previously decoded every oversized image at once, two encode pipelines each — multi-GB transient memory at the 20+-image threshold that activates the feature).
 - Fixed `mergeHeaders` merging case-sensitively on the Copilot/client-options path, where a miscased user-configured header (e.g. `authorization` next to the synthesized `Authorization`) survived as two keys that the `Headers` constructor joins comma-separated on the wire.

package/README.md

@@ -1090,56 +1090,31 @@ For the current API-key onboarding flows, the library covers Together, Moonshot,
 
 ### Programmatic OAuth
 
-The library provides login and token refresh functions. Credential storage is the caller's responsibility.
+Provider login and refresh behavior is exposed through the registry. Credential storage is the caller's responsibility.
 
 ```typescript
 import {
-	// Login functions (return credentials, do not store)
-	loginAnthropic,
-	loginOpenAICodex,
-	loginGitHubCopilot,
-	loginGeminiCli,
-	loginAntigravity,
-	loginCloudflareAiGateway,
-	loginHuggingface,
-	loginLiteLLM,
-	loginMoonshot,
-	loginNvidia,
-	loginNanoGPT,
-	loginQianfan,
-	loginQwenPortal,
-	loginTogether,
-	loginVenice,
-	loginVllm,
-	loginXiaomi,
-
-	// Token management
+	getProviderDefinition,
 	refreshOAuthToken, // (provider, credentials) => new credentials
 	getOAuthApiKey, // (provider, credentialsMap) => { newCredentials, apiKey } | null
-
-	// Types
-	type OAuthProvider, // includes 'anthropic', 'openai-codex', 'github-copilot', 'google-gemini-cli', 'google-antigravity', 'together', 'moonshot', 'qianfan', 'nvidia', 'nanogpt', 'novita', 'huggingface', 'venice', 'xiaomi', 'vllm', 'litellm', 'cloudflare-ai-gateway', 'qwen-portal', ...
+	type OAuthProvider,
 	type OAuthCredentials,
 } from "@oh-my-pi/pi-ai";
-```
 
-`loginOpenAICodex` accepts an optional `originator` value used in the OAuth flow:
-
-```typescript
-await loginOpenAICodex({
+const provider = getProviderDefinition("openai-codex");
+const credentials = await provider?.login?.({
 	onAuth: ({ url }) => console.log(url),
-	originator: "my-cli",
 });
 ```
 
 ### Login Flow Example
 
 ```typescript
-import { loginGitHubCopilot } from "@oh-my-pi/pi-ai";
+import { getProviderDefinition } from "@oh-my-pi/pi-ai";
 import * as fs from "node:fs";
 
-const credentials = await loginGitHubCopilot({
-	onAuth: (url, instructions) => {
+const credentials = await getProviderDefinition("github-copilot")?.login?.({
+	onAuth: ({ url, instructions }) => {
 		console.log(`Open: ${url}`);
 		if (instructions) console.log(instructions);
 	},

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

@@ -1,6 +1,15 @@
 import type { InbandScanEvent, InbandScanner } from "./types.js";
+export interface ThinkingInbandScannerOptions {
+    /**
+     * Report a bare reasoning close tag (no open seen) as an `impliedThinkingEnd`
+     * event instead of passing it through as text. Off by default: only a
+     * consumer that owns the whole message can reclassify the text before it.
+     */
+    readonly impliedOpen?: boolean;
+}
 export declare class ThinkingInbandScanner implements InbandScanner {
     #private;
+    constructor(options?: ThinkingInbandScannerOptions);
     feed(text: string): InbandScanEvent[];
     flush(): InbandScanEvent[];
 }

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

@@ -12,6 +12,16 @@ export type InbandScanEvent = {
 } | {
     type: "thinkingEnd";
     thinking: string;
+}
+/**
+ * A reasoning close tag with no open in this stream. Chat templates that
+ * prefill the opener into the prompt (DeepSeek-R1, Qwen3-Thinking) make the
+ * model stream only the close, so everything emitted as `text` before this
+ * event was reasoning. Only {@link ThinkingInbandScanner} with `impliedOpen`
+ * emits it.
+ */
+ | {
+    type: "impliedThinkingEnd";
 } | {
     type: "toolStart";
     id: string;

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

@@ -87,13 +87,6 @@ export declare function isFastModeUnsupported(error: unknown): boolean;
  * fail identically) nor surface as an auth failure.
  */
 export declare function isClinePassSurfaceGateMessage(errorMessage: string | undefined): boolean;
-/**
- * GitHub Copilot 400 `model_not_supported` response for a model advertised by
- * `/models` — transient fleet skew, not a malformed request. Reads the
- * structural `code` through the SDK/body envelopes, then falls back to the
- * stringified body both SDK families put in `message`.
- */
-export declare function isCopilotTransientModelError(error: unknown): boolean;
 export declare function classifyMessage(message: {
     api?: Api;
     provider?: string;

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

@@ -7,13 +7,6 @@
  * may match more. Use this when you only have a `status: number`.
  */
 export declare function isTransientStatus(status: number | undefined): boolean;
-/** Hook for provider-specific transient detection that the error module must not import directly. */
-export interface ProviderRetryableHooks {
-    /** Provider id of the failing request, used to gate provider-specific checks. */
-    provider?: string;
-    /** Provider-specific transient predicate (e.g. Copilot model-availability 400s). */
-    isProviderTransient?: (error: Error) => boolean;
-}
 /**
  * Whether a provider stream error should be retried against the same credential.
  *
@@ -21,7 +14,7 @@ export interface ProviderRetryableHooks {
  * here — they are owned by the credential-rotation layer (auth-gateway /
  * `streamSimple` a/b/c policy), not this seconds-scale provider backoff.
  *
- * Provider-specific transient cases are injected via {@link ProviderRetryableHooks}
- * so this stays free of provider imports.
+ * Every 4xx other than 408/429 is terminal: a request the provider rejected
+ * as malformed, unauthorized, or unentitled fails identically on replay.
  */
-export declare function isProviderRetryableError(error: unknown, hooks?: ProviderRetryableHooks): boolean;
+export declare function isProviderRetryableError(error: unknown): boolean;

package/dist/types/index.d.ts

@@ -46,7 +46,6 @@ export * from "./utils/anthropic-auth.js";
 export * from "./utils/event-stream.js";
 export * from "./utils/glyph-codec.js";
 export * from "./utils/openrouter-headers.js";
-export * from "./utils/retry.js";
 export * from "./utils/schema/index.js";
 export * from "./utils/thinking-loop.js";
 export * from "./utils/tool-call-loop-guard.js";

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

@@ -47,5 +47,12 @@ export interface BedrockOptions extends StreamOptions {
      * we omit it for them.
      */
     thinkingDisplay?: BedrockThinkingDisplay;
+    /**
+     * Per-request Bedrock invocation-log tags. Merged over `model.requestMetadata`
+     * (per-call entries win on key collision). AWS caps the result at 16 entries;
+     * keys 1-256 chars, values 0-256 chars, both limited to
+     * `[a-zA-Z0-9\s:_@$#=/+,-.]`. Entries outside those limits are dropped.
+     */
+    requestMetadata?: Record<string, string>;
 }
 export declare const streamBedrock: StreamFunction<"bedrock-converse-stream">;

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

@@ -164,7 +164,7 @@ export type AnthropicClientOptionsArgs = {
     disableStrictTools?: boolean;
     fetch?: FetchImpl;
     maxRetryDelayMs?: number;
-    claudeCodeSessionId?: string;
+    sessionId?: string;
 };
 export type AnthropicClientOptionsResult = {
     isOAuthToken: boolean;
@@ -188,13 +188,6 @@ export type AnthropicClientOptionsResult = {
  * omitted there.
  */
 export declare function resolveAnthropicCustomHeadersForBaseUrl(baseUrl: string | undefined): Record<string, string> | undefined;
-/**
- * Whether an Anthropic (or Copilot-over-Anthropic) stream error should be
- * retried. The classification lives in {@link AIError.isProviderRetryableError};
- * this wrapper injects the Copilot-specific model-availability transient check,
- * which the error module must not import directly.
- */
-export declare function isProviderRetryableError(error: unknown, provider?: string): boolean;
 export type AnthropicUsageLike = {
     cache_creation?: {
         ephemeral_5m_input_tokens?: number | null;

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

@@ -12,6 +12,8 @@ export interface CursorOptions extends StreamOptions {
     conversationId?: string;
     execHandlers?: CursorExecHandlers;
     onToolResult?: CursorToolResultHandler;
+    /** Treat unhandled MCP calls as accepted handoffs to an external executor. */
+    externalToolExecutor?: boolean;
     /** Wire model id selected after thinking-effort routing (`resolveWireModelId`). */
     wireModelId?: string;
 }
@@ -104,7 +106,7 @@ export interface UsageState {
     sawTokenDelta: boolean;
 }
 /** Exported for tests: drives one Cursor server message through the stream (exec waits mark the stream busy). */
-export declare function handleServerMessage(msg: AgentServerMessage, output: AssistantMessage, stream: AssistantMessageEventStream, state: BlockState, blobStore: Map<string, Uint8Array>, h2Request: http2.ClientHttp2Stream, execHandlers: CursorExecHandlers | undefined, onToolResult: CursorToolResultHandler | undefined, usageState: UsageState, requestContextTools: McpToolDefinition[], requestContextRules?: CursorRule[], onConversationCheckpoint?: (checkpoint: ConversationStateStructure) => void): Promise<void>;
+export declare function handleServerMessage(msg: AgentServerMessage, output: AssistantMessage, stream: AssistantMessageEventStream, state: BlockState, blobStore: Map<string, Uint8Array>, h2Request: http2.ClientHttp2Stream, execHandlers: CursorExecHandlers | undefined, onToolResult: CursorToolResultHandler | undefined, usageState: UsageState, requestContextTools: McpToolDefinition[], requestContextRules?: CursorRule[], onConversationCheckpoint?: (checkpoint: ConversationStateStructure) => void, externalToolExecutor?: boolean): Promise<void>;
 /**
  * Exported for tests: verifies handler is invoked with correct `this` when passed as bound.
  *

package/dist/types/providers/inference-headers.d.ts

@@ -0,0 +1,24 @@
+/** Shared inference request identity headers. */
+import type { FetchImpl } from "../types.js";
+/** Options controlling provider and protocol inference headers. */
+export interface InferenceHeaderOptions {
+    provider: string;
+    protocol: "anthropic" | "google" | "openai";
+    sessionId?: string;
+}
+/** Set a header unless the map already contains that field under any casing. */
+export declare function setHeaderIfAbsent(headers: Record<string, string>, name: string, value: string): void;
+/**
+ * Project omp's identity and authoritative conversation id onto the headers
+ * understood by the active inference protocol and host.
+ */
+export declare function applyInferenceHeaders(headers: Record<string, string>, options: InferenceHeaderOptions): void;
+/**
+ * Apply omp's process-wide inference User-Agent default. Any explicit header,
+ * including Anthropic and Codex OAuth fingerprints, remains authoritative.
+ *
+ * Plain-object headers stay plain objects: custom `fetch` implementations
+ * (proxies, tests) index `init.headers` by name and must not be handed a
+ * `Headers` instance instead.
+ */
+export declare function withInferenceUserAgent(fetchImpl: FetchImpl): FetchImpl;

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

@@ -21,10 +21,8 @@ export interface CodexRequestOptions {
     textVerbosity?: "low" | "medium" | "high";
     include?: string[];
     /**
-     * Responses Lite transport override; defaults to the model's
-     * `useResponsesLite`. Lite moves instructions/tools into input items,
-     * strips image detail, and disables parallel tool calling (codex-rs
-     * `use_responses_lite`).
+     * Responses Lite transport opt-in. Normal inference defaults to full
+     * Responses so the model can emit independent tool calls in parallel.
      */
     responsesLite?: boolean;
 }
@@ -70,13 +68,12 @@ export interface RequestBody {
     [key: string]: unknown;
 }
 /**
- * Resolve whether a Codex request uses the Responses Lite transport: an
- * explicit option wins, then the `PI_CODEX_RESPONSES_LITE` env override
- * (`1`/`true` forces Lite, `0`/`false` forces the full Responses body),
- * otherwise the model's catalog flag (codex-rs `model_info.use_responses_lite`)
- * decides.
+ * Resolve whether a Codex request explicitly opts into Responses Lite.
+ *
+ * Provider-native compaction passes the model's `useResponsesLite` flag as an
+ * explicit option; normal inference defaults to the full Responses contract.
  */
-export declare function resolveCodexResponsesLite(model: Model<"openai-codex-responses">, requested: boolean | undefined): boolean;
+export declare function resolveCodexResponsesLite(requested: boolean | undefined): boolean;
 /**
  * Structural view of a Responses-style body mutated by the Lite rewrite.
  * Loose (`unknown`) property types let the turn transformer (`RequestBody`)

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

@@ -12,13 +12,9 @@ export interface OpenAICodexResponsesOptions extends StreamOptions {
     preferWebsockets?: boolean;
     serviceTier?: ServiceTier;
     /**
-     * Responses Lite transport override; defaults to the model's catalog
-     * `useResponsesLite` flag (codex-rs `use_responses_lite`). Sends
-     * `x-openai-internal-codex-responses-lite: true` on HTTP requests and on the
-     * WebSocket upgrade (the marker is connection-scoped there, so lite and
-     * non-lite turns never share a pooled socket), moves instructions/tools
-     * into input items, strips image detail, and disables parallel tool
-     * calling — mirroring codex-rs.
+     * Responses Lite transport opt-in. Normal inference defaults to full
+     * Responses; provider-native compaction explicitly follows the model's
+     * `useResponsesLite` flag.
      */
     responsesLite?: boolean;
     /**

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

@@ -56,7 +56,7 @@ export interface OpenAIRequestSetupOptions {
         apiVersion: string;
         deploymentName: string;
     };
-    openAISessionId?: string;
+    sessionId?: string;
     promptCacheSessionId?: string;
 }
 export interface OpenAIRequestSetup {

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

@@ -1,10 +1,3 @@
-export declare const amazonBedrockProvider: {
-    readonly id: "amazon-bedrock";
-    readonly name: "Amazon Bedrock";
-    readonly envKeys: () => string | undefined;
-    readonly mapSimpleOptions: (options: import("../index.js").SimpleStreamOptions) => {
-        region: string | undefined;
-        profile: string | undefined;
-        bearerToken: string | undefined;
-    };
-};
+import type { ProviderTransport } from "./build.js";
+/** Amazon Bedrock request shaping; auth policy lives in `rules/auth/amazon-bedrock.kdl`. */
+export declare const amazonBedrockTransport: ProviderTransport;

package/dist/types/registry/bedrock-mantle.d.ts

@@ -1,22 +1,3 @@
-import type { Model } from "../types.js";
-import { resolveAwsRegistryApiKey } from "./aws.js";
-export declare const bedrockMantleProvider: {
-    readonly id: "bedrock-mantle";
-    readonly name: "Amazon Bedrock Mantle";
-    readonly envKeys: typeof resolveAwsRegistryApiKey;
-    readonly allowsMissingApiKey: true;
-    readonly prepareRequest: (model: Model<import("@oh-my-pi/pi-catalog").Api>, options: import("../index.js").StreamOptions) => import("../providers/bedrock-mantle.js").PreparedBedrockMantleRequest;
-    readonly mapSimpleOptions: (options: import("../index.js").SimpleStreamOptions) => {
-        providerOptions: Readonly<Record<string, unknown>> | undefined;
-    };
-    readonly prepareModelDiscovery: (config: import("./types.js").ProviderModelDiscoveryConfig) => {
-        baseUrl?: string;
-        fetch?: import("@oh-my-pi/pi-utils").FetchImpl;
-        apiKey: undefined;
-        authenticated: false;
-    } | {
-        authenticated: true;
-        baseUrl: string;
-        fetch: import("@oh-my-pi/pi-utils").FetchImpl;
-    };
-};
+import type { ProviderTransport } from "./build.js";
+/** Bedrock Mantle request/discovery shaping; auth policy lives in `rules/auth/bedrock-mantle.kdl`. */
+export declare const bedrockMantleTransport: ProviderTransport;

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

@@ -0,0 +1,11 @@
+/**
+ * Projects one compiled auth policy (`rules/auth/<id>.kdl`) plus the
+ * provider's optional TypeScript transport hooks into the
+ * {@link ProviderDefinition} the rest of `@oh-my-pi/pi-ai` consumes.
+ */
+import type { CompiledAuthProvider } from "@oh-my-pi/pi-catalog/compat/types";
+import type { ProviderDefinition } from "./types.js";
+/** Request/model shaping a provider implements in TypeScript beside its KDL auth policy. */
+export type ProviderTransport = Pick<ProviderDefinition, "prepareModel" | "prepareRequest" | "mapSimpleOptions" | "prepareModelDiscovery">;
+/** Materializes the registry definition for one compiled policy. */
+export declare function buildProviderDefinition(policy: CompiledAuthProvider, transport?: ProviderTransport): ProviderDefinition;

package/dist/types/registry/cloudflare-ai-gateway.d.ts

@@ -1,13 +1,3 @@
-import type { OAuthController, OAuthLoginCallbacks } from "./oauth/types.js";
-/** Collect the gateway credential used by CLI, setup-wizard, and TUI login callers. */
-export declare function loginCloudflareAiGateway(options: OAuthController): Promise<string>;
-export declare const cloudflareAiGatewayProvider: {
-    readonly id: "cloudflare-ai-gateway";
-    readonly name: "Cloudflare AI Gateway";
-    readonly prepareModel: (model: import("@oh-my-pi/pi-catalog").Model<import("@oh-my-pi/pi-catalog").Api>) => import("@oh-my-pi/pi-catalog").Model<import("@oh-my-pi/pi-catalog").Api>;
-    readonly prepareRequest: (model: import("@oh-my-pi/pi-catalog").Model<import("@oh-my-pi/pi-catalog").Api>, options: import("../index.js").StreamOptions) => {
-        model: import("@oh-my-pi/pi-catalog").Model<import("@oh-my-pi/pi-catalog").Api>;
-        options: import("../index.js").StreamOptions;
-    };
-    readonly login: (cb: OAuthLoginCallbacks) => Promise<string>;
-};
+import type { ProviderTransport } from "./build.js";
+/** Cloudflare AI Gateway model/request shaping; login lives in `oauth/cloudflare-ai-gateway.ts` + its auth rule. */
+export declare const cloudflareAiGatewayTransport: ProviderTransport;

package/dist/types/registry/engine/api-key.d.ts

@@ -0,0 +1,8 @@
+/**
+ * `login "api-key"` engine: open the provider's key page, prompt for a paste,
+ * optionally validate the key against a declared probe, return the key.
+ */
+import type { CompiledApiKeyLogin } from "@oh-my-pi/pi-catalog/compat/types";
+import type { OAuthController } from "../oauth/types.js";
+/** Builds the login function for one `login "api-key"` rule; `label` is the provider display name. */
+export declare function createApiKeyLogin(rule: CompiledApiKeyLogin, label: string): (options: OAuthController) => Promise<string>;

package/dist/types/registry/engine/common.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Shared machinery for the declarative login engines: resolving KDL values
+ * (env overrides, obfuscation, hooks), `{placeholder}` templating, token
+ * endpoint requests and token-response → `OAuthCredentials` projection.
+ */
+import type { CompiledAuthValue, CompiledCredentialMap, CompiledOAuthRequest, CompiledUserinfo } from "@oh-my-pi/pi-catalog/compat/types";
+import type { FetchImpl } from "../../types.js";
+import type { AfterExchangeHook, ExchangeContext, HeadersHook, LoginHook, RefreshHook } from "../hooks/types.js";
+import type { OAuthCredentials } from "../oauth/types.js";
+/** Far-future epoch ms: credentials that never expire (durable minted keys, session JWTs). */
+export declare const NEVER_EXPIRES = 8640000000000000;
+/** Substitution values available to `{placeholder}` templates in KDL params/URLs. */
+export type TemplateVars = Record<string, string | undefined>;
+export declare function loadLoginHook(name: string): Promise<LoginHook>;
+export declare function loadRefreshHook(name: string): Promise<RefreshHook>;
+export declare function loadAfterExchangeHook(name: string): Promise<AfterExchangeHook>;
+export declare function loadHeadersHook(name: string): Promise<HeadersHook>;
+/** Resolves a KDL value node: env overrides first, then the (possibly encoded) literal or hook. */
+export declare function resolveValue(value: CompiledAuthValue, signal?: AbortSignal): Promise<string>;
+/** Replaces `{name}` placeholders; unknown or undefined placeholders resolve to the empty string. */
+export declare function template(text: string, vars: TemplateVars): string;
+/** Reads a dot path (`data.user.email`) from a parsed JSON body. */
+export declare function jsonPath(body: unknown, path: string): unknown;
+/** Decodes a JWT payload without verification; `null` for malformed tokens. */
+export declare function decodeJwtPayload(token: string): Record<string, unknown> | null;
+/** Epoch ms of a JWT `exp` claim minus `skewMs`, or undefined when absent. */
+export declare function jwtExpiryMs(token: string, skewMs: number): number | undefined;
+/**
+ * Projects a token response onto `OAuthCredentials` per the rule's
+ * `credential` map. A missing refresh token keeps `previous.refresh` (refresh
+ * grants that do not rotate) or falls back to the empty string.
+ */
+export declare function mapCredentials(map: CompiledCredentialMap, body: unknown, provider: string, previous?: OAuthCredentials): OAuthCredentials;
+export interface RequestContext {
+    provider: string;
+    fetch: FetchImpl;
+    signal?: AbortSignal;
+    /** Extra headers merged under the rule's declared headers. */
+    headers?: Record<string, string>;
+}
+/**
+ * Performs one declared token-style POST. `standardParams` are the grant's
+ * baseline (included when the rule keeps `standard=#true`), `params` the
+ * rule's declared extras; both are templated with `vars`.
+ */
+export declare function postTokenRequest(request: CompiledOAuthRequest, standardParams: Record<string, string | undefined>, vars: TemplateVars, context: RequestContext, errorKind: "token-exchange" | "token-refresh" | "device-auth"): Promise<{
+    body: unknown;
+    response: Response;
+}>;
+/** Bearer GET declared by `userinfo`; failures leave identity fields unset. */
+export declare function applyUserinfo(userinfo: CompiledUserinfo | undefined, credentials: OAuthCredentials, context: RequestContext): Promise<OAuthCredentials>;
+/** Runs the rule's after-exchange / after-refresh hook, if declared. */
+export declare function applyAfterExchange(hook: string | undefined, credentials: OAuthCredentials, context: ExchangeContext): Promise<OAuthCredentials>;
+export declare function describeError(error: unknown): string;
+export declare function throwIfCancelled(signal: AbortSignal | undefined): void;

package/dist/types/registry/engine/device-code.d.ts

@@ -0,0 +1,9 @@
+/**
+ * `login "device-code"` engine: RFC 8628 device authorization — request a
+ * user code, show the verification URL, poll the token endpoint until the
+ * grant completes, then project / enrich the credentials.
+ */
+import type { CompiledDeviceCodeLogin } from "@oh-my-pi/pi-catalog/compat/types";
+import type { OAuthController, OAuthCredentials } from "../oauth/types.js";
+/** Builds the login function for one `login "device-code"` rule. */
+export declare function createDeviceCodeLogin(rule: CompiledDeviceCodeLogin, provider: string): (ctrl: OAuthController) => Promise<OAuthCredentials>;

package/dist/types/registry/engine/oauth-code.d.ts

@@ -0,0 +1,27 @@
+/**
+ * `login "oauth-code"` engine: authorization-code grant (optionally PKCE)
+ * through the loopback callback server, followed by the declared token
+ * exchange, credential projection, userinfo enrichment and after-exchange hook.
+ */
+import type { CompiledAuthProvider, CompiledCallback, CompiledOAuthCodeLogin } from "@oh-my-pi/pi-catalog/compat/types";
+import { OAuthCallbackFlow, type OAuthCallbackFlowOptions } from "../oauth/callback-server.js";
+import type { OAuthController, OAuthCredentials } from "../oauth/types.js";
+/**
+ * Callback-server options for a rule. A `redirect-uri-env` override is
+ * advertised verbatim with random-port fallback disabled; HTTP loopback
+ * overrides also bind the listener to the URI's host/port/path.
+ */
+export declare function resolveCallbackOptions(callback: CompiledCallback, provider: string, signal?: AbortSignal): Promise<OAuthCallbackFlowOptions>;
+/** Generic authorization-code flow driven by one compiled rule. */
+export declare class DeclarativeOAuthCodeFlow extends OAuthCallbackFlow {
+    #private;
+    constructor(ctrl: OAuthController, rule: CompiledOAuthCodeLogin, policy: CompiledAuthProvider, options: OAuthCallbackFlowOptions);
+    generateState(): string;
+    generateAuthUrl(state: string, redirectUri: string): Promise<{
+        url: string;
+        instructions?: string;
+    }>;
+    exchangeToken(code: string, state: string, redirectUri: string): Promise<OAuthCredentials>;
+}
+/** Builds the login function for one `login "oauth-code"` rule. */
+export declare function createOAuthCodeLogin(rule: CompiledOAuthCodeLogin, policy: CompiledAuthProvider): (ctrl: OAuthController) => Promise<OAuthCredentials>;