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

package/CHANGELOG.md

@@ -2,6 +2,29 @@
 
 ## [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
@@ -183,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.
@@ -253,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)).
@@ -1305,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
@@ -1449,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))
 
@@ -1725,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
 
@@ -1749,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
@@ -1794,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
@@ -2003,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
@@ -2092,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/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;

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/types.d.ts

@@ -463,6 +463,13 @@ export interface SimpleStreamOptions extends Omit<StreamOptions, "apiKey"> {
     guardrailIdentifier?: string;
     guardrailVersion?: string;
     guardrailTrace?: "enabled" | "disabled" | "enabled_full";
+    /**
+     * Bedrock invocation-log tags forwarded through transports that do not dispatch
+     * directly to the Bedrock provider. Unlike the guardrail fields above, these
+     * MERGE per key with the model's own `requestMetadata` (these win) rather than
+     * replacing it wholesale — they are independent attribution tags, not one value.
+     */
+    requestMetadata?: Record<string, string>;
     /** Optional tool choice override for compatible providers */
     toolChoice?: ToolChoice;
     /** OpenAI service tier for processing priority/cost control. Ignored by non-OpenAI providers. */

package/dist/types/utils.d.ts

@@ -1,6 +1,13 @@
 import type { ResponseInput } from "./providers/openai-responses-wire.js";
 import type { CacheRetention, OpenAIResponsesHistoryPayload, ProviderPayload } from "./types.js";
 export { isRecord } from "@oh-my-pi/pi-utils";
+/**
+ * Read a header value ignoring key casing. HTTP header names are
+ * case-insensitive, but `Record<string, string>` header bags are not, so a
+ * config-authored `User-Agent` and a caller-authored `user-agent` are the same
+ * header to every provider that lowercases before merging.
+ */
+export declare function getHeaderCaseInsensitive(headers: Record<string, string> | undefined, headerName: string): string | undefined;
 export declare function normalizeSystemPrompts(systemPrompt: readonly string[] | string | undefined | null): string[];
 export declare function normalizeToolCallId(id: string): string;
 type ResponsesToolItemIdPrefix = "fc" | "ctc";

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-ai",
-	"version": "18.1.5",
+	"version": "18.1.6",
 	"description": "Unified LLM API with automatic model discovery and provider configuration",
 	"homepage": "https://omp.sh",
 	"author": "Stencil Labs, Inc.",
@@ -37,10 +37,10 @@
 		"fmt": "oxfmt --no-error-on-unmatched-pattern 'src/**/*.{ts,tsx}' '{test,bench,examples,scripts}/**/*.ts' '*.ts'"
 	},
 	"dependencies": {
-		"@oh-my-pi/omptype": "18.1.5",
-		"@oh-my-pi/pi-catalog": "18.1.5",
-		"@oh-my-pi/pi-utils": "18.1.5",
-		"@oh-my-pi/pi-wire": "18.1.5"
+		"@oh-my-pi/omptype": "18.1.6",
+		"@oh-my-pi/pi-catalog": "18.1.6",
+		"@oh-my-pi/pi-utils": "18.1.6",
+		"@oh-my-pi/pi-wire": "18.1.6"
 	},
 	"devDependencies": {
 		"@types/bun": "^1.3.14"

package/src/error/rate-limit.ts

@@ -24,6 +24,12 @@ const SERVER_ERROR_BACKOFF_MS = 20 * 1000; // 20s
 const ACCOUNT_RATE_LIMIT_PATTERN =
 	/\baccount(?:'s)?\b[^\n]{0,80}\brate.?limit\b|\brate.?limit\b[^\n]{0,80}\baccount\b/i;
 const INSUFFICIENT_BALANCE_PATTERN = /insufficient.?balance/i;
+// Prepaid-credit exhaustion phrased around the credit balance rather than a
+// quota: Anthropic "This request would exceed your available credits given
+// your current in-flight requests" (402), OpenRouter "Insufficient credits",
+// "credits exhausted". Account-local, so rotate to a sibling credential.
+const CREDITS_EXHAUSTED_PATTERN =
+	/\b(?:exceed\w*|insufficient|not enough)\b[^\n]{0,40}\bcredits?\b|\bcredits?\b[^\n]{0,40}\b(?:exhausted|depleted)\b/i;
 const SPEND_LIMIT_PATTERN = /spend.?limit/i;
 const SUBSCRIPTION_CAP_PATTERN =
 	/\b(?:subscription|plan|membership)\b[^\n]{0,80}\b(?:rate.?limits?|quota|cap)\b|\b(?:rate.?limits?|quota|cap)\b[^\n]{0,80}\b(?:subscription|plan|membership)\b/i;
@@ -247,7 +253,8 @@ export function parseRateLimitReason(errorMessage: string): RateLimitReason {
 		lower.includes("out of credits") ||
 		lower.includes("spending-limit") ||
 		lower.includes("spending limit") ||
-		INSUFFICIENT_BALANCE_PATTERN.test(errorMessage)
+		INSUFFICIENT_BALANCE_PATTERN.test(errorMessage) ||
+		CREDITS_EXHAUSTED_PATTERN.test(errorMessage)
 	) {
 		return "QUOTA_EXHAUSTED";
 	}
@@ -390,6 +397,7 @@ export function matchesUsageLimitText(errorMessage: string): boolean {
 	if (isDashScopeTokenLimitText(errorMessage)) return false;
 	return (
 		USAGE_LIMIT_PATTERN.test(errorMessage) ||
+		CREDITS_EXHAUSTED_PATTERN.test(errorMessage) ||
 		(CN_QUOTA_EXHAUSTED_PATTERN.test(errorMessage) && !CN_TRANSIENT_CAP_PATTERN.test(errorMessage)) ||
 		SPEND_LIMIT_PATTERN.test(errorMessage) ||
 		ACCOUNT_RATE_LIMIT_PATTERN.test(errorMessage) ||

package/src/providers/amazon-bedrock.ts

@@ -10,7 +10,14 @@
 import type { Effort } from "@oh-my-pi/pi-catalog/effort";
 import { mapEffortToAnthropicAdaptiveEffort, requireSupportedEffort } from "@oh-my-pi/pi-catalog/model-thinking";
 import { calculateCost } from "@oh-my-pi/pi-catalog/models";
-import { $flag, fetchWithRetry, logger, parseStreamingJson, parseStreamingJsonThrottled } from "@oh-my-pi/pi-utils";
+import {
+	$flag,
+	fetchWithRetry,
+	logger,
+	parseStreamingJson,
+	parseStreamingJsonThrottled,
+	USER_AGENT,
+} from "@oh-my-pi/pi-utils";
 import { renderDemotedThinking } from "../dialect/demotion";
 import * as AIError from "../error";
 import { resolveAwsBearerToken } from "../registry/aws";
@@ -102,6 +109,13 @@ 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>;
 }
 
 function resolveBearerToken(options: BedrockOptions): string | undefined {
@@ -283,6 +297,7 @@ interface ConverseStreamRequest {
 	toolConfig?: WireToolConfig;
 	guardrailConfig?: WireGuardrailConfig;
 	additionalModelRequestFields?: Record<string, unknown>;
+	requestMetadata?: Record<string, string>;
 	additionalModelResponseFieldPaths?: string[];
 }
 
@@ -319,6 +334,41 @@ interface MetadataEvent {
 	};
 }
 
+const REQUEST_METADATA_PATTERN = /^[a-zA-Z0-9\s:_@$#=/+,\-.]*$/;
+const REQUEST_METADATA_MAX_ENTRIES = 16;
+const REQUEST_METADATA_MAX_LENGTH = 256;
+
+/**
+ * Bedrock rejects the whole invocation on a malformed `requestMetadata` entry.
+ * Attribution tags must never cost a turn, so invalid and excess entries are
+ * dropped with a warning instead of failing the request. Returns `undefined`
+ * for an empty result so the field is omitted from the body entirely.
+ */
+function sanitizeRequestMetadata(raw: unknown): Record<string, string> | undefined {
+	if (!isRecord(raw)) return undefined;
+	const out: Record<string, string> = {};
+	const dropped: string[] = [];
+	let kept = 0;
+	for (const [key, value] of Object.entries(raw)) {
+		if (
+			typeof value !== "string" ||
+			key.length < 1 ||
+			key.length > REQUEST_METADATA_MAX_LENGTH ||
+			!REQUEST_METADATA_PATTERN.test(key) ||
+			value.length > REQUEST_METADATA_MAX_LENGTH ||
+			!REQUEST_METADATA_PATTERN.test(value) ||
+			kept >= REQUEST_METADATA_MAX_ENTRIES
+		) {
+			dropped.push(key);
+			continue;
+		}
+		out[key] = value;
+		kept++;
+	}
+	if (dropped.length > 0) logger.warn("Bedrock requestMetadata entries dropped", { keys: dropped });
+	return kept > 0 ? out : undefined;
+}
+
 export const streamBedrock: StreamFunction<"bedrock-converse-stream"> = (
 	model: Model<"bedrock-converse-stream">,
 	context: Context,
@@ -391,10 +441,17 @@ export const streamBedrock: StreamFunction<"bedrock-converse-stream"> = (
 				toolConfig,
 				guardrailConfig: buildGuardrailConfig(options),
 				additionalModelRequestFields,
+				requestMetadata:
+					model.requestMetadata || options.requestMetadata
+						? { ...model.requestMetadata, ...options.requestMetadata }
+						: undefined,
 				...(prefixMismatchBehavior ? { additionalModelResponseFieldPaths: ["/input_transformations"] } : {}),
 			};
 			const replacementInput = await options?.onPayload?.(commandInput, model);
 			if (replacementInput !== undefined) commandInput = replacementInput as ConverseStreamRequest;
+			// After the hook so extension-injected tags are validated too, and before the
+			// raw dump so the inspector shows exactly what was sent.
+			commandInput = { ...commandInput, requestMetadata: sanitizeRequestMetadata(commandInput.requestMetadata) };
 
 			const host = `bedrock-runtime.${region}.amazonaws.com`;
 			const url = `https://${host}/model/${encodeURIComponent(model.id)}/converse-stream`;
@@ -429,11 +486,21 @@ export const streamBedrock: StreamFunction<"bedrock-converse-stream"> = (
 			// comma-joined wire header, so AWS validates different bytes than were
 			// signed and rejects the request.
 			const callerHeaders: Record<string, string> = {};
-			for (const [name, value] of Object.entries(options?.headers ?? {})) {
-				const field = name.toLowerCase();
-				if (SIGNER_OWNED_HEADERS.has(field) || BEDROCK_RESERVED_HEADERS.has(field)) continue;
-				callerHeaders[field] = value;
+			// `model.headers` first, `options.headers` second: `StreamOptions.headers` is
+			// documented (types.ts:431-435) as merged ON TOP of model-defined headers.
+			// Both pass the same filter, so a config-authored `Host`/`Content-Type`
+			// cannot desync the signature either.
+			for (const source of [model.headers, options?.headers]) {
+				for (const [name, value] of Object.entries(source ?? {})) {
+					const field = name.toLowerCase();
+					if (SIGNER_OWNED_HEADERS.has(field) || BEDROCK_RESERVED_HEADERS.has(field)) continue;
+					callerHeaders[field] = value;
+				}
 			}
+			// SigV4 never signs `user-agent` (UNSIGNABLE in aws-sigv4.ts:42-58), so this
+			// default cannot break the signature. Without it Bun's fetch sends
+			// `Bun/<version>`, and that is what CloudTrail records for every request.
+			callerHeaders["user-agent"] ??= USER_AGENT;
 			const baseHeaders: Record<string, string> = {
 				...callerHeaders,
 				"content-type": "application/json",

package/src/providers/anthropic.ts

@@ -48,7 +48,13 @@ import type {
 	ToolResultMessage,
 	Usage,
 } from "../types";
-import { isRecord, normalizeSystemPrompts, normalizeToolCallId, resolveCacheRetention } from "../utils";
+import {
+	getHeaderCaseInsensitive,
+	isRecord,
+	normalizeSystemPrompts,
+	normalizeToolCallId,
+	resolveCacheRetention,
+} from "../utils";
 import { createAbortSourceTracker } from "../utils/abort";
 import {
 	clearStreamingPartialJson,
@@ -104,6 +110,7 @@ import {
 	resolveGitHubCopilotBaseUrl,
 } from "./github-copilot-headers";
 import { getOpenAIPromptCacheKey } from "./openai-shared";
+import { applyInferenceHeaders } from "./inference-headers";
 import { transformMessages } from "./transform-messages";
 import { NON_VISION_IMAGE_PLACEHOLDER } from "./vision-guard";
 
@@ -234,15 +241,6 @@ function buildClaudeCodeBetas({
 	return betas;
 }
 
-function getHeaderCaseInsensitive(headers: Record<string, string> | undefined, headerName: string): string | undefined {
-	if (!headers) return undefined;
-	const normalizedName = headerName.toLowerCase();
-	for (const [key, value] of Object.entries(headers)) {
-		if (key.toLowerCase() === normalizedName) return value;
-	}
-	return undefined;
-}
-
 function isClaudeCodeClientUserAgent(userAgent: string | undefined): userAgent is string {
 	if (!userAgent) return false;
 	return userAgent.toLowerCase().startsWith("claude-cli");
@@ -1238,7 +1236,7 @@ export type AnthropicClientOptionsArgs = {
 	disableStrictTools?: boolean;
 	fetch?: FetchImpl;
 	maxRetryDelayMs?: number;
-	claudeCodeSessionId?: string;
+	sessionId?: string;
 };
 
 export type AnthropicClientOptionsResult = {
@@ -2177,7 +2175,10 @@ const streamAnthropicOnce = (
 					thinkingDisplay: options?.thinkingDisplay,
 					fetch: options?.fetch,
 					maxRetryDelayMs: options?.maxRetryDelayMs,
-					claudeCodeSessionId: options?.sessionId ?? extractClaudeMetadataSessionId(options?.metadata?.user_id),
+					sessionId:
+						options?.sessionId ??
+						extractClaudeMetadataSessionId(options?.metadata?.user_id) ??
+						options?.promptCacheKey,
 					disableStrictTools,
 				});
 				client = created.client;
@@ -3203,7 +3204,7 @@ export function buildAnthropicClientOptions(args: AnthropicClientOptionsArgs): A
 		thinkingEnabled = false,
 		isOAuth,
 		maxRetryDelayMs,
-		claudeCodeSessionId,
+		sessionId,
 		disableStrictTools: disableStrictToolsOverride,
 	} = args;
 	const compat = model.compat;
@@ -3266,6 +3267,11 @@ export function buildAnthropicClientOptions(args: AnthropicClientOptionsArgs): A
 			dynamicHeaders,
 			headers,
 		);
+		applyInferenceHeaders(defaultHeaders, {
+			provider: model.provider,
+			protocol: "anthropic",
+			sessionId,
+		});
 
 		return {
 			isOAuthToken: false,
@@ -3288,22 +3294,23 @@ export function buildAnthropicClientOptions(args: AnthropicClientOptionsArgs): A
 		betaFeatures.push(interleavedThinkingBeta);
 	}
 
+	const requestModelHeaders = mergeHeaders(
+		model.headers,
+		foundryCustomHeaders,
+		getUmansWebSearchHeader(model, mergeHeaders(model.headers, headers)),
+		headers,
+		dynamicHeaders,
+	);
 	const defaultHeaders = buildAnthropicHeaders({
 		apiKey,
 		baseUrl,
 		isOAuth: oauthToken,
 		extraBetas: betaFeatures,
 		stream,
-		modelHeaders: mergeHeaders(
-			model.headers,
-			foundryCustomHeaders,
-			getUmansWebSearchHeader(model, mergeHeaders(model.headers, headers)),
-			headers,
-			dynamicHeaders,
-		),
+		modelHeaders: requestModelHeaders,
 		isCloudflareAiGateway: model.provider === "cloudflare-ai-gateway",
 		allowAnthropicHeaderOverrides: model.compat.allowAnthropicHeaderOverrides,
-		claudeCodeSessionId,
+		claudeCodeSessionId: sessionId,
 		claudeCodeBetas: oauthToken
 			? buildClaudeCodeBetas({
 					agentRequest: hasTools || thinkingEnabled,
@@ -3313,6 +3320,11 @@ export function buildAnthropicClientOptions(args: AnthropicClientOptionsArgs): A
 				})
 			: [],
 	});
+	applyInferenceHeaders(defaultHeaders, {
+		provider: model.provider,
+		protocol: "anthropic",
+		sessionId,
+	});
 
 	if (model.provider === "cloudflare-ai-gateway") {
 		return {
@@ -3491,6 +3503,64 @@ function applyPromptCaching(params: MessageCreateParamsStreaming, cacheControl?:
 	}
 }
 
+/**
+ * Anchor cache_control on the stable request head — the last (non-deferred)
+ * tool definition and the last system block. The canonical cache order is
+ * tools → system → messages, so a breakpoint on the final system block caches
+ * the entire tools+system prefix, and the extra tool breakpoint keeps the tool
+ * definitions cached even when the system text changes. This guarantees the
+ * large, unchanging head is a cache hit on every turn regardless of how the
+ * message tail churns — the breakpoint placement first-party Anthropic clients
+ * (Claude Code, Pi) use. Without it, the general API-key path anchors only the
+ * moving message tail, so tail churn re-writes the whole head uncached.
+ *
+ * Anthropic allows at most 4 cache breakpoints per request. At most one is
+ * spent on tools and one on system here, leaving two for the message tail in
+ * `applyPromptCaching`. Head caching is skipped entirely when the head is
+ * already anchored — the OAuth Claude Code path caches its own instruction
+ * block at buildAnthropicSystemBlocks, and via the canonical tools → system
+ * order that single system breakpoint already caches every preceding tool. Re-
+ * anchoring there would be redundant, would change the OAuth wire, and could
+ * push a tool-heavy request over the 4-breakpoint budget, so the general
+ * API-key path (nothing cached upstream) is the only one decorated here.
+ *
+ * Runs after the byte-stability plane (planStableAnthropicSystem /
+ * planStableAnthropicTools), which hands back fresh block/tool copies each turn
+ * and keys tool identity off a fingerprint that excludes cache_control — so
+ * decorating here is byte-stable across turns and never forces a re-baseline.
+ */
+function applyHeadCaching(
+	systemBlocks: AnthropicSystemBlock[] | undefined,
+	tools: AnthropicWireTool[] | undefined,
+	cacheControl?: AnthropicCacheControl,
+): void {
+	if (!cacheControl) return;
+
+	// If anything in the head already carries a breakpoint, the head is already
+	// cached (OAuth anchors its identity system block, which — canonical order
+	// tools → system — caches all tools too). Leave it untouched.
+	const headAlreadyCached =
+		(systemBlocks?.some(block => block.cache_control != null) ?? false) ||
+		(tools?.some(tool => tool.cache_control != null) ?? false);
+	if (headAlreadyCached) return;
+
+	if (tools && tools.length > 0) {
+		// Deferred tools are not part of the checked prefix until referenced, so
+		// anchor the last tool that actually sits in the stable prefix.
+		for (let index = tools.length - 1; index >= 0; index--) {
+			const tool = tools[index];
+			if (!tool || tool.defer_loading) continue;
+			tool.cache_control = cloneAnthropicCacheControl(cacheControl);
+			break;
+		}
+	}
+
+	if (systemBlocks && systemBlocks.length > 0) {
+		const lastBlock = systemBlocks[systemBlocks.length - 1];
+		if (lastBlock) lastBlock.cache_control = cloneAnthropicCacheControl(cacheControl);
+	}
+}
+
 function usesAdaptiveThinkingTagOnly(model: Model<"anthropic-messages">): boolean {
 	const thinking = model.thinking;
 	if (thinking?.mode !== "anthropic-adaptive") return false;
@@ -3966,6 +4036,9 @@ function buildParams(
 	if (controlState) syncAnthropicControlState(controlState, wireMessages);
 	systemBlocks = planStableAnthropicSystem(systemBlocks, controlState, model.compat.supportsMidConversationSystem);
 	tools = planStableAnthropicTools(tools, wireMessages, controlState, model.compat.supportsMidConversationToolChanges);
+	// Anchor the stable tools+system head so it stays cached across turns; the
+	// moving message tail is anchored separately in applyPromptCaching below.
+	applyHeadCaching(systemBlocks, tools, cacheControl);
 	const topLevelEffort = planStableAnthropicEffort(
 		outputConfigEffort,
 		wireMessages,