@oh-my-pi/pi-ai 18.11.3 → 18.12.0

package/CHANGELOG.md

@@ -2,6 +2,36 @@
 
 ## [Unreleased]
 
+## [18.12.0] - 2026-10-17
+
+### Breaking Changes
+
+- `PI_CODEX_ZSTD` is replaced by `PI_REQUEST_COMPRESSION`; set `PI_REQUEST_COMPRESSION=0` to send Codex (and every other) request body uncompressed ([#16086](https://github.com/can1357/oh-my-pi/pull/16086) by [@H4vC](https://github.com/H4vC))
+
+### Added
+
+- Added `ThinkingContent.narration`, set on Anthropic and Bedrock thinking blocks whose signature marks them as between-tool narration, and `presentNarrationAsAnswer(message)` to show those blocks as reply text while replay keeps them as signed thinking
+- Added `keys.peek(provider, { includeExpired: true })` to name the stored account behind an expired OAuth token for reads that never send it, such as keying an offline model-cache lookup ([#16061](https://github.com/can1357/oh-my-pi/pull/16061) by [@gchai](https://github.com/gchai))
+- Added `prewarmModelConnection(model)` (`providers/connection-prewarm`), which opens the model's API connection ahead of a request using the same transport and TLS settings so the request reuses it instead of paying the connection handshake ([#16086](https://github.com/can1357/oh-my-pi/pull/16086) by [@H4vC](https://github.com/H4vC))
+
+### Changed
+
+- Anthropic requests to the official API now gzip the request body, so long conversations reach the model sooner on slow uplinks; set `PI_REQUEST_COMPRESSION=0` to disable it ([#16044](https://github.com/can1357/oh-my-pi/pull/16044) by [@H4vC](https://github.com/H4vC))
+- GitHub Copilot requests (chat completions, Responses, and Claude messages) now send zstd-compressed bodies, cutting upload size by roughly 60–75% on long conversations; set `PI_REQUEST_COMPRESSION=0` to disable it ([#16086](https://github.com/can1357/oh-my-pi/pull/16086) by [@H4vC](https://github.com/H4vC))
+- A rejected request-body encoding now only disables compression for that host, and only after the uncompressed resend succeeds, so a genuine 400 no longer turns compression off ([#16086](https://github.com/can1357/oh-my-pi/pull/16086) by [@H4vC](https://github.com/H4vC))
+- Connection warm-up now covers every catalog provider, not only the official Anthropic API: it re-warms the origin a model's requests actually reach (Copilot plan hosts, `MOONSHOT_BASE_URL`, regional hosts), throttled per host; custom providers, built-in provider ids routed to a gateway, local hosts, and Anthropic gateways are never probed ([#16086](https://github.com/can1357/oh-my-pi/pull/16086) by [@H4vC](https://github.com/H4vC))
+
+### Fixed
+
+- Fixed Ollama and Ollama Cloud streaming errors being silently accepted as successful responses ([#16039](https://github.com/can1357/oh-my-pi/pull/16039) by [@mottopanikeiku](https://github.com/mottopanikeiku))
+- Fixed the hermes in-band scanner exposing a truncated tool name for streaming tool calls: `toolStart` now waits for the complete JSON name, so a stream that splits or stops mid-name never reports a partial tool name ([#16064](https://github.com/can1357/oh-my-pi/pull/16064) by [@adi-IL](https://github.com/adi-IL))
+- Fixed `keys.peek()` rotating through stored accounts on each call; it now returns the first account whose token has not expired, every time, so model discovery keeps reading one account's cached catalog ([#16061](https://github.com/can1357/oh-my-pi/pull/16061) by [@gchai](https://github.com/gchai))
+- Fixed local JSON Schema references with URI-percent-encoded, JSON Pointer-escaped, or empty definition names resolving incorrectly during dereferencing, strict conversion, and value validation ([#15926](https://github.com/can1357/oh-my-pi/pull/15926) by [@jchanghong023](https://github.com/jchanghong023)).
+- Fixed network failures showing a generic "Connection error."; offline, connection-refused, and TLS-verification failures now name the host and the cause ([#16036](https://github.com/can1357/oh-my-pi/pull/16036) by [@jorgoose](https://github.com/jorgoose))
+- Fixed Jev image limits rejecting inputs for unrelated native judges and redundant TypeSafe image judgments when only detail changes ([#16002](https://github.com/can1357/oh-my-pi/pull/16002) by [@anatoli-tsinovoy](https://github.com/anatoli-tsinovoy)).
+- Fixed SIGTERM interrupting an in-flight OAuth token rotation before its replacement refresh token was saved ([#15845](https://github.com/can1357/oh-my-pi/issues/15845)).
+- Fixed sessions getting stuck on HTTP 400 after replaying tool names unsupported by the target provider, including invented `proc://*` calls and Google tool names sent to Bedrock ([#15839](https://github.com/can1357/oh-my-pi/issues/15839))
+
 ## [18.11.3] - 2026-10-16
 
 ### Fixed
@@ -2327,45 +2357,4 @@
 - Removed the `setNextRequestDebugPath`, `clearNextRequestDebugPath`, and `getNextRequestDebugPath` utility functions for request debugging, as request/response recording now relies exclusively on the `PI_REQ_DEBUG` environment variable.
 - Removed Wafer Pass (`wafer-pass`) login support; Wafer Serverless remains available as `wafer-serverless`.
 
-## [16.1.8] - 2026-06-20
-
-### Changed
-
-- Changed OpenAI Responses and Codex Responses custom grammar tool requests to leave `parallel_tool_calls` unset instead of forcing serial tool calls; Codex `responsesLite` still disables parallel tool calls when tools are present.
-
-### Fixed
-
-- Fixed Bedrock `/btw` and other no-tool ephemeral turns failing after prior tool calls by sending the required sentinel `toolConfig` whenever replayed history contains `toolUse`/`toolResult` blocks. ([#3124](https://github.com/can1357/oh-my-pi/issues/3124))
-- Fixed Anthropic Messages pre-content TLS `bad record MAC` server transport errors surfacing before the provider retry loop exhausts its budget. ([#3134](https://github.com/can1357/oh-my-pi/issues/3134))
-- Fixed API-key login flows replacing existing stored keys for the same provider, so providers such as NVIDIA NIM can keep multiple active keys available for session-level rotation. ([#2923](https://github.com/can1357/oh-my-pi/issues/2923))
-- Fixed `openai-codex-responses` forwarding sampling controls (`temperature`, `top_p`, `top_k`, `min_p`, `presence_penalty`, `repetition_penalty`) into the Codex request body — the ChatGPT-subscription Codex backend rejects each of them with a 400 `{"detail":"Unsupported parameter: temperature"}`, so any caller setting non-default `StreamOptions` saw every turn fail. The provider now drops the full sampling set (matching codex-rs), and the auth-gateway's defensive strip on both `buildStreamOptions` and the pi-native path was widened from `{temperature, topP}` to the same set plus `stopSequences`/`frequencyPenalty`. ([#3117](https://github.com/can1357/oh-my-pi/issues/3117))
-- Fixed Anthropic Messages retry classification for transient TLS/server-error failures such as `tls: bad record MAC (type=server_error)`. These pre-content transport blips are now retried inside the provider loop before the session sees an error banner.
-
-## [16.1.4] - 2026-06-19
-
-### Added
-
-- Added bounded auto-retry for empty assistant completions specifically to the OpenAI Responses provider
-- Added bounded auto-retry for empty assistant completions across the OpenAI Chat Completions, OpenAI Responses, and Anthropic Messages providers. A benign terminal stop that streamed no content and billed no output tokens — the signature of a flaky OpenAI-/Anthropic-compatible gateway that intermittently 200s with an empty body — is now retried up to twice with exponential backoff (honoring `providerRetryWait`) before being surfaced, instead of silently stalling the agent loop. Retries fire only before any content streams, so live streaming (including thinking) is never delayed, retried, or duplicated.
-
-### Fixed
-
-- Fixed the Antigravity (`google-antigravity`) request builder dropping `labels.model_enum` when the wire profile does not declare one. Required for Claude 4.6 ids whose `AntigravityModelWireProfile` carries only `maxOutputTokens` (no captured `model_enum`); the label is now emitted only when the catalog defines it. ([#3067](https://github.com/can1357/oh-my-pi/issues/3067))
-
-## [16.1.3] - 2026-06-19
-
-### Added
-
-- Added regression test pinning that `openai-completions` emits a `thinking` block for `reasoning_content` deltas even when `delta.content` is explicitly JSON `null` (the DeepSeek-format dual-key pattern used by custom GLM/Qwen reasoning providers). See [#2996](https://github.com/can1357/oh-my-pi/issues/2996).
-
-### Changed
-
-- Improved the thinking loop guard to treat assistant text loops as retryable errors
-- Refined text normalization logic to reduce false positives in the thinking loop detector
-
-### Fixed
-
-- Fixed Ollama chat requests sending image payloads to text-only models. Image blocks are now omitted and replaced with the standard non-vision placeholder for models without vision support, while vision-capable Ollama models continue to receive images. ([#3009](https://github.com/can1357/oh-my-pi/pull/3009) by [@serverinspector](https://github.com/serverinspector))
-- Fixed `SqliteAuthCredentialStore.close()` leaking one-off prepared statements created by inline `this.#db.prepare()` calls in `#authCredentialsTableExists`, `#readAuthSchemaVersion`, `#inferAuthSchemaVersion`, `#migrateAuthSchemaV0ToV1`, `#backfillCredentialIdentityKeys`, and `updateAuthCredential`. Each statement is now wrapped in `try/finally` with `stmt.finalize()`, and the `close()` method finalizes `#insertUsageCostStmt` and `#listUsageCostsStmt` which were previously missed. This caused EBUSY on Windows when tests tried to delete temp dirs containing open SQLite handles.
-
-Older entries are archived in [packages/ai/CHANGELOG.md@0595d346917d](https://github.com/can1357/oh-my-pi/blob/0595d346917d152ea2b710332817de599f749626/packages/ai/CHANGELOG.md).
+Older entries are archived in [packages/ai/CHANGELOG.md@50ec66f75d57](https://github.com/can1357/oh-my-pi/blob/50ec66f75d57ad55838a9fe4da5e66f29af4d73c/packages/ai/CHANGELOG.md).

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

@@ -2,7 +2,7 @@ import { type ApiKeyResolver, type ResolvedApiKey } from "../auth-retry.js";
 import type { SessionAffinity } from "./affinity.js";
 import type { CredentialPool } from "./pool.js";
 import type { CredentialSelector } from "./select.js";
-import type { AuthApiKeyOptions, AuthCredential, AuthSource, AuthSourceOptions, KeysApi, LimitsApi } from "./types.js";
+import type { AuthApiKeyOptions, AuthPeekOptions, AuthCredential, AuthSource, AuthSourceOptions, KeysApi, LimitsApi } from "./types.js";
 /** Runtime (--api-key) and config (models.yml) key overrides plus the config-value resolver. */
 export declare class KeyOverrides {
     #private;
@@ -114,9 +114,11 @@ export declare class KeyCascade implements KeysApi {
      * Used for model discovery where we only need to know if credentials exist
      * and get a best-effort token. GitHub Copilot's peek must preserve
      * enterprise routing metadata because discovery needs a structured
-     * credential to reach the correct host.
+     * credential to reach the correct host. With several stored accounts every
+     * peek returns the same one, so credential-scoped discovery caches stay on
+     * one namespace.
      */
-    peek(provider: string): Promise<string | undefined>;
+    peek(provider: string, options?: AuthPeekOptions): Promise<string | undefined>;
     /**
      * Resolve a bearer together with the stored row that supplied it, for a request.
      * Same precedence as {@link KeyCascade.get}, but rejects with

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

@@ -55,7 +55,11 @@ export declare class CredentialSelector {
     /**
      * Selects a credential of the specified type for a provider.
      * Returns both the credential and its index in the original array (for updates/removal).
-     * Uses deterministic hashing for session stickiness and skips blocked credentials when possible.
+     * With `sessionId` the scan starts at the session's hashed index; without one it starts at the
+     * first stored credential and never advances round-robin. Model discovery peeks through this,
+     * and credential-scoped catalogs (e.g. GitHub Copilot) key their cache rows on the credential
+     * picked, so a rotating pick would read another account's cache namespace on every pass.
+     * Blocked credentials are skipped when possible.
      */
     selectByType<T extends AuthCredential["type"]>(provider: string, type: T, sessionId?: string, filter?: (credential: AuthCredential) => boolean): {
         credential: Extract<AuthCredential, {

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

@@ -631,6 +631,15 @@ export interface AuthSourceOptions {
      */
     env?: "dedicated" | "aliases" | "none";
 }
+/** Options for {@link KeysApi.peek}. */
+export interface AuthPeekOptions {
+    /**
+     * Fall back to an expired OAuth access token when no stored account holds an
+     * unexpired one. Only for reads that never send the token, e.g. keying an
+     * offline model-cache lookup on the account it names.
+     */
+    includeExpired?: boolean;
+}
 /** Where a provider's auth comes from ({@link CredentialOrigin}) plus whether any leg holds a concrete key. */
 export interface AuthSource extends CredentialOrigin {
     /** False when the only auth is an ambient AUTHENTICATED_SENTINEL source (AWS profile, ADC). */
@@ -850,9 +859,10 @@ export interface KeysApi {
      * Peek at API key for a provider without refreshing OAuth tokens.
      * Used for model discovery where we only need to know if credentials exist
      * and get a best-effort token. For GitHub Copilot we preserve enterprise
-     * routing metadata so discovery can hit the correct host.
+     * routing metadata so discovery can hit the correct host. Repeated peeks
+     * return the same stored credential; they never rotate accounts.
      */
-    peek(provider: string): Promise<string | undefined>;
+    peek(provider: string, options?: AuthPeekOptions): Promise<string | undefined>;
     /** Resolve the first active auth source by precedence without refreshing credentials. */
     source(provider: string, options?: AuthSourceOptions): AuthSource | undefined;
     /**

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

@@ -21,3 +21,9 @@ export declare function partialSuffixOverlap(text: string, tag: string): number;
 export declare function partialSuffixOverlapAny(text: string, tags: readonly string[]): number;
 export declare function normalizeKimiFunctionName(rawId: string): string;
 export declare function asRecord(value: unknown): Record<string, unknown>;
+/**
+ * Extract a COMPLETE tool name from a partial in-band JSON body.
+ * Returns undefined until the name string is fully closed, so streaming
+ * scanners never start a tool call under a truncated name.
+ */
+export declare function parseCompleteToolName(body: string): string | undefined;

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

@@ -47,7 +47,7 @@ export declare class AnthropicApiError extends ProviderHttpError {
 }
 /** Network-level failure (DNS, TLS, socket reset) after retries were exhausted. */
 export declare class AnthropicConnectionError extends Error {
-    constructor(cause: unknown);
+    constructor(cause: unknown, requestUrl?: string);
 }
 /** No response headers arrived within the configured request timeout. */
 export declare class AnthropicConnectionTimeoutError extends Error {

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

@@ -72,7 +72,10 @@ export declare function isCodexSteerRejection(message: {
  * Transport-failure wording that marks an error transient. Covers
  * diagnostics forwarded verbatim by gateways/proxies in other runtimes, e.g.
  * undici's "other side closed" and Go's `net.ErrClosed` ("use of closed
- * network connection", #15385).
+ * network connection", #15385). Also covers OMP's own network-failure
+ * sentences from `networkFailureMessage` (offline / unreachable / refused /
+ * TLS), which must stay at least as retryable as the bare `Connection error.`
+ * text they replaced.
  */
 export declare const TRANSIENT_TRANSPORT_PATTERN: RegExp;
 export declare const ANTHROPIC_ACCOUNT_POLICY_PATTERN: RegExp;

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

@@ -8,6 +8,7 @@ export * from "./finalize.js";
 export * from "./flags.js";
 export * from "./format.js";
 export * from "./gateway.js";
+export * from "./network-cause.js";
 export * from "./oauth.js";
 export * from "./provider.js";
 export * from "./rate-limit.js";

package/dist/types/error/network-cause.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Local transport diagnosis for a rejected `fetch`.
+ *
+ * Bun and Node describe the same outage with different shapes — Bun throws a
+ * `TypeError` carrying `code: "ETIMEOUT" | "FailedToOpenSocket" |
+ * "ConnectionRefused"`, undici nests an `ENOTFOUND`/`ECONNREFUSED` errno under
+ * `TypeError: fetch failed` (sometimes through an `AggregateError`), and
+ * `fetchWithRetry` may already have flattened the chain into a message-only
+ * `Error`. Both the code and the text are inspected so every one of those
+ * shapes lands in the right bucket.
+ */
+/** Transport-level failure families that get their own user-visible wording. */
+export type NetworkFailureKind = "offline" | "unreachable" | "refused" | "tls";
+/** What {@link classifyNetworkCause} reports about a rejected `fetch`: the failure family plus the bits its sentence needs. */
+export interface NetworkFailure {
+    kind: NetworkFailureKind;
+    /** Runtime error code when the chain exposed one (`ETIMEOUT`, `FailedToOpenSocket`, …). */
+    code: string | undefined;
+    /** Short parenthetical detail for the user-visible message. */
+    detail: string | undefined;
+    /** Host named by the error text, when it named one. */
+    host: string | undefined;
+}
+/**
+ * Walk an error's `cause`/`errors` graph (bounded depth, cycle-safe) and report
+ * the outermost link that describes a local transport failure. Returns
+ * `undefined` for anything else, including HTTP-level provider errors.
+ */
+export declare function classifyNetworkCause(err: unknown): NetworkFailure | undefined;
+/**
+ * User-visible sentence for a network failure, or `undefined` when the error is
+ * not one. `requestUrl` wins over any host parsed out of the error text.
+ */
+export declare function networkFailureMessage(err: unknown, requestUrl?: string): string | undefined;
+/**
+ * Re-describe a rejected `fetch` with {@link networkFailureMessage}, keeping the
+ * original error as `cause`. Anything that is not a local transport failure is
+ * returned untouched, so provider/HTTP errors keep their identity.
+ */
+export declare function networkFailureError(err: unknown, requestUrl?: string): unknown;

package/dist/types/index.d.ts

@@ -64,6 +64,7 @@ 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/narration.js";
 export * from "./utils/schema/index.js";
 export * from "./utils/thinking-loop.js";
 export * from "./utils/tool-call-loop-guard.js";

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

@@ -1,3 +1,25 @@
+/**
+ * Native judgment client: the {@link Judge} backend for catalog models whose
+ * API answers typed questions directly ({@link isJudgmentApi}).
+ *
+ * Each judgment API is one wire dialect: TypeSafe's System One route
+ * (`POST /v1/systemone`), OpenRouter Decisions (`POST /api/alpha/decisions`,
+ * same body), Cloudflare Workers AI (`POST /ai/run/{model}`, same body plus
+ * top-level data URL images; `systemone.ts`), and OpenAI Decisions
+ * (`POST /v1/decisions`, translated both ways; `openai-decisions.ts`).
+ * Credentials flow through {@link withAuth}, so a stored key rotates on
+ * 401/403 exactly like chat providers; transient 429/5xx responses retry with
+ * bounded, `retry-after`-aware backoff. Endpoints that cap the questions per
+ * request (the catalog's `judgment-questions-max`, e.g. OpenJEV at 16) get
+ * oversized requests split into chunks under `maxQuestions`, at most
+ * {@link CHUNK_PARALLEL} in flight at once.
+ *
+ * Environment (mirrors the official TypeSafe SDK, for judges built without an
+ * explicit model): `TYPESAFE_API_KEY` is resolved by the auth registry
+ * (`rules/auth/typesafe.kdl`), `TYPESAFE_BASE_URL` overrides the API root,
+ * `TYPESAFE_DEFAULT_MODEL` the model.
+ */
+import { type JudgmentImageInput } from "@oh-my-pi/pi-catalog/compat/judgment-images";
 import type { Api, FetchImpl } from "@oh-my-pi/pi-catalog/types";
 import { type ApiKey } from "../auth-retry.js";
 import * as AIError from "../error/index.js";
@@ -21,12 +43,12 @@ export declare function isJudgmentApi(api: Api): api is JudgmentApi;
 export declare function nativeJudgmentSupportsImages(model: Model): boolean;
 /**
  * Whether `model`'s native judgment API takes these exact images: image support plus every documented
- * per-dialect bound. A judge chain skips a candidate that would refuse them instead of failing on it.
+ * transport and catalog bound. A judge chain skips a candidate that would refuse them instead of failing on it.
  */
 export declare function nativeJudgmentAcceptsImages(model: Model, images: readonly ImageContent[]): boolean;
 /**
  * Reject images that `model`'s native judgment API cannot take — no image support, an unsupported or
- * unreferenced asset, or a documented per-dialect cap exceeded — before any credential or upstream work.
+ * unreferenced asset, or a transport or catalog bound exceeded — before any credential or upstream work.
  * @throws {AIError.ValidationError} naming the reason.
  */
 export declare function checkNativeJudgmentImages(model: Model, request: JudgmentRequest, imageAssets?: JudgmentImageAssets): void;
@@ -62,6 +84,8 @@ export interface NativeJudgeOptions extends NativeJudgeConnection {
      * dialects that require explicit opt-in but cannot enable a wire without image support.
      */
     supportsImages?: boolean;
+    /** Catalog-selected image bounds, applied in addition to the wire's transport constraints. */
+    imageInput?: JudgmentImageInput;
 }
 /** Per-call options for {@link NativeJudge.judge}. */
 export interface NativeJudgeCallOptions extends JudgeOptions {
@@ -90,6 +114,8 @@ export declare class NativeJudge implements Judge {
     readonly baseUrl: string;
     constructor(options: NativeJudgeOptions);
     judge<Q extends Questions>(request: JudgmentRequest<Q>, options?: NativeJudgeCallOptions): Promise<JudgmentResult<Q>>;
+    /** Effective image detail for cache identity after applying this wire's forwarding behavior. */
+    effectiveImageDetail(detail: ImageContent["detail"]): ImageContent["detail"];
 }
 /**
  * The {@link NativeJudge} for a catalog judge model: its API's dialect, wire id

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

@@ -4,6 +4,7 @@
  * judgment module; `native.ts` maps every judgment API to its dialect.
  */
 import type { ImageContent, Usage } from "../types.js";
+import type { JudgmentImageInput } from "@oh-my-pi/pi-catalog/compat/judgment-images";
 import type { JudgmentRequest } from "./types.js";
 /** Where one attempt posts and which bearer token it sends. */
 export interface JudgmentTarget {
@@ -20,36 +21,6 @@ export interface DecodedJudgment {
     refused: readonly string[];
     usage: Usage;
 }
-/**
- * Image input one judgment dialect accepts. Every cap is optional; {@link NativeJudge}
- * rejects a request exceeding one locally instead of spending an upstream call on it.
- */
-export interface JudgmentImageInput {
-    /** Accepted lowercase MIME types; unset accepts any image type. */
-    mimeTypes?: readonly string[];
-    /** Images per request. */
-    maxCount?: number;
-    /** Decoded bytes per image. */
-    maxBytes?: number;
-    /** Decoded bytes across all images. */
-    maxTotalBytes?: number;
-    /** Pixels per image, when the image header reports dimensions. */
-    maxPixels?: number;
-    /** Minimum pixels per image, when the image header reports dimensions. */
-    minPixels?: number;
-    /** Inclusive bounds on each side, when the image header reports dimensions. */
-    minSide?: number;
-    maxSide?: number;
-}
-/** Shared TypeSafe Jev/OpenRouter image limits (https://docs.typesafe.ai/images#limits); out-of-range images are rejected upstream, never resized. */
-export declare const JEV_IMAGE_INPUT: {
-    readonly mimeTypes: readonly ["image/png", "image/jpeg"];
-    readonly maxBytes: number;
-    readonly minPixels: 78400;
-    readonly maxPixels: 2458624;
-    readonly minSide: 280;
-    readonly maxSide: 1568;
-};
 /** Image assets kept separately from judgment state for asset-aware native wires. */
 export type JudgmentImageAssets = Readonly<Record<string, ImageContent>>;
 /** How one judgment API addresses, encodes, and decodes a request. */
@@ -69,6 +40,8 @@ export interface JudgmentWire {
     supportsImageAssets?: boolean;
     /** Whether image support must be enabled explicitly for direct NativeJudge construction. */
     imagesRequireOptIn?: boolean;
+    /** Whether this wire drops per-image detail metadata. */
+    ignoresImageDetail?: boolean;
     /** The response's answers and usage; `undefined` when the payload is not this API's response shape. */
     decode(payload: unknown): DecodedJudgment | undefined;
 }

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

@@ -1,14 +1,17 @@
 /**
- * Recovers the serving model id Anthropic embeds in thinking-block signatures.
+ * Reads the cleartext header Anthropic embeds in thinking-block signatures.
  *
  * A signature is a base64 protobuf: outer `{1: version, 2: envelope}`, envelope
  * `{1: header, 2..5: nonce/ciphertext/tag}`, header
- * `{1: schema, 5: hash, 6: model, 8: "thinking", 11: org uuid, 15: profile, 21: unix ts}`.
+ * `{1: schema, 5: hash, 6: model, 8: kind, 11: org uuid, 15: profile, 21: unix ts}`.
  * Field 6 names the model that actually produced the block — a concrete
  * snapshot (`claude-haiku-4-5-20251001`) or an internal codename
  * (`numbat-v6-…`) — which lets a caller notice a gateway serving something other
  * than the requested model. The v4 outer format (`CAQS…`) ships a header
  * without field 6; the decoder then yields nothing.
+ * Field 8 names the block kind: `thinking` for reasoning, `narration` for the
+ * user-facing prose the API converts into a thinking block when the model
+ * writes it between tool calls (connector-text summarization).
  */
 /**
  * Model id embedded in an Anthropic thinking signature, or undefined when the
@@ -16,6 +19,13 @@
  * nothing resembling a model id.
  */
 export declare function servedModelFromAnthropicSignature(signature: string): string | undefined;
+/**
+ * Whether an Anthropic thinking signature marks its block as narration: prose
+ * the model addressed to the user between tool calls, which the API returns as
+ * a thinking block. Only an exact `narration` kind matches; any other or
+ * unreadable header stays reasoning.
+ */
+export declare function isAnthropicNarrationSignature(signature: string): boolean;
 /**
  * Model id from an OpenRouter reasoning item — a `reasoning_details` entry on
  * chat completions or a Responses `reasoning` output item — which forwards the

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

@@ -1,5 +1,5 @@
 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 { AnthropicCompactionRequest, AnthropicOutputEffort, Api, 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";
@@ -243,6 +243,17 @@ type SystemBlockOptions = {
 export declare function buildAnthropicSystemBlocks(systemPrompt: readonly string[] | undefined, options?: SystemBlockOptions): AnthropicSystemBlock[] | undefined;
 export declare function normalizeExtraBetas(betas?: string[] | string): string[];
 export declare function buildAnthropicClientOptions(args: AnthropicClientOptionsArgs): AnthropicClientOptionsResult;
+/**
+ * Warm-up target for a first-party `anthropic` model: the effective official
+ * API URL plus the TLS options real requests use (sockets pool per TLS
+ * configuration, so a warm-up made with other options is never reused).
+ * `undefined` when requests resolve elsewhere — `ANTHROPIC_BASE_URL` or
+ * Foundry gateways never receive unsolicited probes.
+ */
+export declare function resolveAnthropicPrewarmTarget(model: Model<Api>): {
+    url: string;
+    init: RequestInit;
+} | undefined;
 /**
  * True when enabled thinking on `model` is budget thinking
  * (`thinking.type: "enabled"` with `budget_tokens`) rather than adaptive.

package/dist/types/providers/connection-prewarm.d.ts

@@ -0,0 +1,15 @@
+import type { Api, FetchImpl, Model } from "../types.js";
+/**
+ * Opens, or keeps alive, a pooled connection to {@link model}'s API host so
+ * the next turn skips DNS + TCP + TLS. Sends a credential-less `HEAD` (nothing
+ * is billed; hosts answer 401/404/405) through the same transport — proxy,
+ * extra CA, Cowork profile, TLS options — as real requests, because sockets
+ * pool per transport configuration and a warm-up made any other way (e.g.
+ * `fetch.preconnect`, which also throws on Windows) is never reused.
+ * Throttled per origin; best effort, never throws.
+ */
+export declare function prewarmModelConnection(model: Model<Api>, options?: {
+    fetch?: FetchImpl;
+}): Promise<void>;
+/** Test hook: forgets every warm-up so the next call is not throttled. */
+export declare function resetConnectionPrewarmForTesting(): void;

package/dist/types/providers/transform-messages.d.ts

@@ -29,12 +29,14 @@ export declare function isResponsesFamilyApi(api: Api | undefined): boolean;
 export declare function responsesCallComponent(id: string): string;
 export declare function appendDuplicateSuffix(originalId: string, suffix: string, maxLength: number): string;
 /**
- * Whether a tool-call name cannot belong to any declared tool: missing, empty,
- * longer than OpenAI's 128-character replay limit, or containing whitespace or
- * control characters (tool schemas never allow them; their presence means the
- * name slot carries invocation text).
+ * Whether a tool-call name cannot be replayed to the target: missing, empty,
+ * longer than its declaration limit, or containing a character outside its
+ * declaration charset. Models emit such names when the name slot carries
+ * invocation text (whitespace, NULs) or an invented internal URL (`proc://*`).
+ *
+ * Without a target, use the OpenAI Responses native-history constraints.
  */
-export declare function isMalformedToolCallName(name: unknown): boolean;
+export declare function isMalformedToolCallName(name: unknown, allowedName?: RegExp, maxLength?: number): boolean;
 /**
  * Whether {@link transformMessages} drops `msg` from every replay: a turn cut
  * off by `length` / `error` / `aborted` that carries no text and no tool call.
@@ -45,9 +47,11 @@ export declare function shouldDropTruncatedThinkingOnlyAssistant(msg: AssistantM
  * surviving one: {@link sanitizeMalformedToolCalls} drops its malformed tool
  * calls, then {@link shouldDropTruncatedThinkingOnlyAssistant} a truncated
  * turn left with no text and no tool call. On an already sanitized list this
- * is `!shouldDropTruncatedThinkingOnlyAssistant(msg)`.
+ * is `!shouldDropTruncatedThinkingOnlyAssistant(msg)`. Pass the target `model`
+ * to apply its tool-name limits; without one, any provider-declarable name survives.
  */
-export declare function isSurvivingAssistant(msg: AssistantMessage): boolean;
+export declare function isSurvivingAssistant(msg: AssistantMessage, model?: Model): boolean;
+export declare function isAnthropicMessagesModel(model: Model): model is Model<"anthropic-messages">;
 /**
  * Normalize tool call ID for cross-provider compatibility.
  * OpenAI Responses API generates IDs that are 450+ chars with special characters like `|`.

package/dist/types/types.d.ts

@@ -648,6 +648,13 @@ export interface ThinkingContent {
      * replay natively on another host.
      */
     summary?: boolean;
+    /**
+     * `true`: the block is narration — prose the model addressed to the user
+     * between tool calls, which the provider returned as a signed thinking block
+     * (Anthropic connector-text summarization). It stays a thinking block for
+     * replay; user-facing surfaces present it as answer text.
+     */
+    narration?: boolean;
 }
 export interface RedactedThinkingContent {
     type: "redactedThinking";

package/dist/types/utils/narration.d.ts

@@ -0,0 +1,9 @@
+import type { AssistantMessage } from "../types.js";
+/**
+ * The message as a user-facing surface should present it: every narration
+ * thinking block (see `ThinkingContent.narration`) becomes a text block, so it
+ * renders as part of the answer instead of folding into reasoning. Returns the
+ * input unchanged when it holds no narration. Display-only: replay must keep
+ * the original thinking blocks and their signatures.
+ */
+export declare function presentNarrationAsAnswer(message: AssistantMessage): AssistantMessage;

package/dist/types/utils/request-body.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Bytes of a request body as the server reads them: the `gzip`/`zstd`
+ * `Content-Encoding` applied by request compression is undone, any other
+ * encoding is returned untouched.
+ */
+export declare function decodeRequestBodyBytes(bytes: Uint8Array, contentEncoding: string | null): Uint8Array;
+/**
+ * Text of a string or byte request body after undoing its content encoding;
+ * `undefined` when the request has no such body (none, stream, form data).
+ */
+export declare function requestBodyText(init: RequestInit | undefined): string | undefined;

package/dist/types/utils/request-compression.d.ts

@@ -0,0 +1,18 @@
+import type { FetchImpl, Model } from "../types.js";
+/**
+ * Compresses request bodies from {@link model} to its provider's own endpoint
+ * when its catalog rules declare encodings the endpoint decodes
+ * (`request-encodings` / `endpoint-hosts` KDL axes). Long sessions resend
+ * multi-MB transcripts every turn, so upload time dominates time-to-first-token
+ * on ordinary uplinks.
+ *
+ * Install it beneath any body rewriter or signer (e.g. the cch attestation
+ * patch): those must see the uncompressed bytes. Other hosts, small bodies,
+ * bodies that already carry `Content-Encoding`, and `PI_REQUEST_COMPRESSION=0`
+ * pass through untouched. A possible rejection is resent uncompressed once;
+ * only when that resend succeeds is the encoding latched off for the host, so
+ * a genuine 400 never disables compression.
+ */
+export declare function wrapFetchForRequestCompression(base: FetchImpl, model: Model): FetchImpl;
+/** Test hook: clears every per-host rejection latch. */
+export declare function resetRequestCompressionForTesting(): void;

package/dist/types/utils/transport-fetch.d.ts

@@ -12,6 +12,14 @@ import type { Api, FetchImpl, Model } from "../types.js";
  * layer (three PI_REQ_DEBUG dumps for one request).
  */
 export declare function transportFetch(model: Model<Api>, fetchImpl: FetchImpl | undefined): FetchImpl;
+/**
+ * Origin of the last inference request {@link model} actually sent, after
+ * every dispatch-time rewrite (credential endpoints, env overrides, regional
+ * hosts); `undefined` before its first request.
+ */
+export declare function lastDispatchOrigin(model: Model<Api>): string | undefined;
+/** Test hook: forgets every recorded dispatch origin. */
+export declare function resetDispatchOriginsForTesting(): void;
 /** Options-bag form of {@link transportFetch}; returns `options` untouched when its fetch is already built. */
 export declare function withTransportFetch<T extends {
     fetch?: FetchImpl;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@oh-my-pi/pi-ai",
-	"version": "18.11.3",
+	"version": "18.12.0",
 	"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.11.3",
-		"@oh-my-pi/pi-catalog": "18.11.3",
-		"@oh-my-pi/pi-natives": "18.11.3",
-		"@oh-my-pi/pi-utils": "18.11.3",
-		"@oh-my-pi/pi-wire": "18.11.3"
+		"@oh-my-pi/omptype": "18.12.0",
+		"@oh-my-pi/pi-catalog": "18.12.0",
+		"@oh-my-pi/pi-natives": "18.12.0",
+		"@oh-my-pi/pi-utils": "18.12.0",
+		"@oh-my-pi/pi-wire": "18.12.0"
 	},
 	"devDependencies": {
 		"@types/bun": "^1.3.14"