@oh-my-pi/pi-ai 18.10.4 → 18.11.1

package/CHANGELOG.md

@@ -2,6 +2,44 @@
 
 ## [Unreleased]
 
+## [18.11.1] - 2026-10-15
+
+### Added
+
+- Added image support for native OpenAI Decisions and Workers AI judgments, prompted vision chat, and auth-gateway System One requests; images exceeding a judgment API's documented caps (e.g. Clef's 4 images, 4 MiB each) are rejected locally ([#15471](https://github.com/can1357/oh-my-pi/pull/15471) by [@anatoli-tsinovoy](https://github.com/anatoli-tsinovoy)).
+- `isSurvivingAssistant` in `providers/transform-messages`: whether an assistant turn reaches a replay, malformed tool calls dropped first, so callers outside `transformMessages` pick the same latest turn ([#15791](https://github.com/can1357/oh-my-pi/pull/15791) by [@will-bogusz](https://github.com/will-bogusz))
+
+### Fixed
+
+- Fixed Codex-hosted image generation ignoring the requested `aspect_ratio`/`image_size`, and `3:2`/`2:3` requests sending no size to OpenAI image models ([#15601](https://github.com/can1357/oh-my-pi/pull/15601) by [@chulmin-dev](https://github.com/chulmin-dev))
+- Fixed Claude subagents failing to return structured results when `yield` arguments arrived as invalid JSON ([#15605](https://github.com/can1357/oh-my-pi/pull/15605) by [@farnoy](https://github.com/farnoy))
+- Fixed turns stopping instead of retrying when a gateway reports its upstream WebSocket closed before `response.completed` ([#15628](https://github.com/can1357/oh-my-pi/pull/15628) by [@nqrwhal](https://github.com/nqrwhal)).
+- Fixed Claude on Google Vertex ignoring `cacheRetention: "long"`: prompt caches now get the 1h TTL instead of expiring after 5 minutes, and the `extended-cache-ttl` beta (which Vertex rejects) is never sent there ([#15505](https://github.com/can1357/oh-my-pi/pull/15505) by [@hpost](https://github.com/hpost))
+- Fixed Gemini tool continuations failing on OpenAI-compatible gateways that return `reasoning_signature`, including restored sessions ([#15678](https://github.com/can1357/oh-my-pi/pull/15678) by [@Zzz141592653](https://github.com/Zzz141592653))
+- Fixed Cursor sessions failing every rebuilt request with `PROVIDER_ERROR` after the server re-sent a tool call: the call is recorded once, and histories that already repeat it replay it once with its latest result ([#15749](https://github.com/can1357/oh-my-pi/issues/15749))
+- Fixed Cursor turns cut off mid-stream failing every retry with `PROVIDER_ERROR` until you sent a new message; the retry now starts a fresh Cursor conversation ([#15830](https://github.com/can1357/oh-my-pi/issues/15830))
+- Fixed malformed image-generation inputs being forwarded to providers or reported as credential/upstream errors ([#15765](https://github.com/can1357/oh-my-pi/pull/15765) by [@anatoli-tsinovoy](https://github.com/anatoli-tsinovoy)).
+- Fixed broker-backed auth-gateway processes retaining a cache entry for every distinct client session indefinitely under sustained traffic ([#15841](https://github.com/can1357/oh-my-pi/issues/15841)).
+- Fixed turns ending on a pinned error when a provider reports "temporarily unavailable" or finishes with an `unknown`, `other` or `unspecified` finish reason: these now retry automatically ([#15424](https://github.com/can1357/oh-my-pi/pull/15424) by [@lockwo](https://github.com/lockwo))
+
+## [18.11.0] - 2026-10-14
+
+### Fixed
+
+- Fixed parallel tool calls failing with "Tool call arguments are not valid JSON" on some OpenAI-compatible gateways, such as Gemini ([#15682](https://github.com/can1357/oh-my-pi/pull/15682) by [@Zzz141592653](https://github.com/Zzz141592653))
+- Fixed Anthropic fallback-credit redemption losing its credit on errors that only mention `400` in their text, such as an overload message ([#15702](https://github.com/can1357/oh-my-pi/pull/15702) by [@H4vC](https://github.com/H4vC))
+- Fixed Anthropic fallback-credit redemption sending an extra `fallback-credit-2026-06-01` beta when the refused request used a newer one ([#15702](https://github.com/can1357/oh-my-pi/pull/15702) by [@H4vC](https://github.com/H4vC))
+- Fixed Anthropic fallback-credit redemptions failing when the refused turn included unsigned thinking ([#15702](https://github.com/can1357/oh-my-pi/pull/15702) by [@H4vC](https://github.com/H4vC))
+- Fixed turns ending without automatic retry when a gateway forwards Go's `use of closed network connection` transport error; it now retries like other dropped connections ([#15385](https://github.com/can1357/oh-my-pi/issues/15385))
+- Fixed Codex SSE streams failing with an abort instead of retrying when the first event stalls ([#15542](https://github.com/can1357/oh-my-pi/issues/15542))
+- Fixed Codex (ChatGPT subscription) requests with reasoning disabled, such as judges, titles, commit messages, and thinking `off`, leaving effort to the server default; they now send the lowest supported effort, or `none` where the model accepts it ([#15514](https://github.com/can1357/oh-my-pi/issues/15514))
+- Fixed a Codex account whose token OpenAI rejects (401/403) continuing to show its last quota as healthy; `omp usage` now drops the stale report and `omp auth-gateway check` reports the credential as failing ([#15439](https://github.com/can1357/oh-my-pi/issues/15439))
+- Fixed usage reports being served indefinitely while their provider keeps failing; the last successful report is now shown for at most 24 hours after it was fetched ([#15439](https://github.com/can1357/oh-my-pi/issues/15439))
+- Fixed Responses requests 400ing (DeepSeek: "The `reasoning_text` in the thinking mode must be passed back to the API") after a tool call whose arguments were invalid JSON: the call is now replayed with its parse diagnostic instead of being dropped and leaving a trailing `[Orphan tool result]` note ([#15568](https://github.com/can1357/oh-my-pi/issues/15568))
+- Fixed DeepSeek on OpenAI-compatible gateways leaving doubled-pipe DSML markup (`</｜｜DSML｜｜parameter>`) in assistant text and reasoning ([#15485](https://github.com/can1357/oh-my-pi/issues/15485))
+- Fixed sessions failing every request with `400 … thinking or redacted_thinking blocks in the latest assistant message cannot be modified` after a response fell back to another model mid-turn (e.g. through a gateway that opts into Anthropic server-side fallback); the turn now replays one model's reasoning, and a session already stuck on such a turn recovers by dropping that turn's reasoning and retrying ([#15654](https://github.com/can1357/oh-my-pi/pull/15654) by [@abilliontokens](https://github.com/abilliontokens))
+- Fixed `omp auth-gateway`'s Anthropic `/v1/messages` stream misnumbering content blocks after a redacted reasoning block, which misrouted every later delta in index-addressed clients ([#15654](https://github.com/can1357/oh-my-pi/pull/15654) by [@abilliontokens](https://github.com/abilliontokens))
+
 ## [18.10.4] - 2026-10-13
 
 ### Fixed

package/dist/types/auth/usage-cache.d.ts

@@ -2,7 +2,7 @@ import type { AuthCredentialStore } from "./store.js";
 import type { AuthCredential, OAuthCredential } from "./types.js";
 import type { CredentialPool } from "./pool.js";
 import type { Provider } from "../types.js";
-import type { UsageCredential, UsageProvider } from "../usage.js";
+import type { UsageCredential, UsageProvider, UsageReport } from "../usage.js";
 /** Minimum interval between non-exhausted header snapshots; used by UsageService. */
 export declare const USAGE_HEADER_INGEST_INTERVAL_MS = 60000;
 /**
@@ -56,6 +56,8 @@ export declare class UsageCache {
     failureKey(reportKey: string): string;
     get<T>(key: string): UsageCacheEntry<T> | undefined;
     getStale<T>(key: string): UsageCacheEntry<T> | undefined;
+    /** Last successful report under `key` while inside its retention window; the failure-path fallback. */
+    lastGood(key: string): UsageReport | null;
     set<T>(key: string, entry: UsageCacheEntry<T>): void;
     deletePrefix(prefix: string): boolean;
     markForceRefresh(provider?: Provider): void;

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

@@ -68,10 +68,22 @@ export declare function isCodexSteerRejection(message: {
     api?: Api;
     errorMessage?: string;
 }): boolean;
+/**
+ * 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).
+ */
 export declare const TRANSIENT_TRANSPORT_PATTERN: RegExp;
 export declare const ANTHROPIC_ACCOUNT_POLICY_PATTERN: RegExp;
 /** Whether an error message represents an Anthropic account-scoped permission/policy denial. */
 export declare function isAnthropicAccountPolicyText(text: string, provider?: string, statusArg?: number): boolean;
+/**
+ * Anthropic's rejection of a replayed latest assistant turn whose `thinking` or
+ * `redacted_thinking` blocks no longer verify. Resending the same turn fails the
+ * same way; only a request that changes that turn's reasoning can succeed.
+ */
+export declare function isImmutableLatestThinkingText(text: string): boolean;
 /**
  * Local llama.cpp / Ollama deterministic tool-call argument JSON parse failure.
  * The model emitted invalid JSON in a tool call and the server returned HTTP 500

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

@@ -1,7 +1,8 @@
 import type { FetchImpl, Model, Usage } from "@oh-my-pi/pi-catalog/types";
 import type { ApiKey } from "../auth-retry.js";
 import * as AIError from "../error/index.js";
-import type { GeneratedImage } from "./types.js";
+import type { ImageContent } from "../types.js";
+import type { GeneratedImage, ImageInput } from "./types.js";
 export declare class ImageApiError extends AIError.ProviderHttpError {
     readonly name = "ImageApiError";
 }
@@ -38,6 +39,29 @@ export declare function decodeImageResponse(value: unknown, fetch: FetchImpl, si
  * multi-MB payloads are never fully decoded just to be labelled.
  */
 export declare function sniffBase64ImageMimeType(base64: string): string | undefined;
-export declare function toDataUrl(image: GeneratedImage): string;
+/**
+ * Validate provider-bound image input without changing it. Accepts non-empty standard base64
+ * with canonical trailing bits and optional padding, and case-insensitive image MIME syntax
+ * (RFC 6838 restricted names). Does not sniff the MIME type, decode image pixels, or enforce
+ * provider-specific format support; data-URL transports additionally go through `toDataUrl`.
+ *
+ * @throws {AIError.ValidationError} If the base64 data or image MIME type is invalid.
+ */
+export declare function validateImageInput(image: ImageInput): void;
+/**
+ * Encode validated image input as a base64 data URL.
+ *
+ * @throws {AIError.ValidationError} If the input is invalid or its MIME type cannot survive a data URL.
+ */
+export declare function toDataUrl(image: ImageInput): string;
+/**
+ * Whether a MIME type survives a data URL intact: a raw `#` starts a URL fragment and
+ * data-URL consumers leave a `%23` escape undecoded, so no data-URL transport preserves it.
+ */
+export declare function isDataUrlMimeType(mimeType: string): boolean;
+/** Whether a value is an embedded image with valid base64 data, MIME type, and detail. */
+export declare function isEmbeddedImageContent(image: unknown): image is ImageContent;
+/** Convert one validated embedded image to a lowercase-MIME inline data URL. */
+export declare function embeddedImageDataUrl(image: unknown): string;
 export declare function resolveOpenAIImageSize(aspectRatio?: string, imageSize?: string): string | undefined;
 export {};

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

@@ -1,7 +1,7 @@
 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";
-import type { Model, Usage } from "../types.js";
+import type { ImageContent, Model, Usage } from "../types.js";
 import { type Judge, type JudgeOptions, type JudgmentRequest, type JudgmentResult, type Questions } from "./types.js";
 import type { JudgmentWire } from "./wire.js";
 export declare const TYPESAFE_PROVIDER = "typesafe";
@@ -16,6 +16,14 @@ declare const JUDGMENT_WIRES: {
 export type JudgmentApi = keyof typeof JUDGMENT_WIRES;
 /** Whether a catalog API answers judgments natively. */
 export declare function isJudgmentApi(api: Api): api is JudgmentApi;
+/** Whether both the native protocol and catalog model support image input. */
+export declare function nativeJudgmentSupportsImages(model: Model): boolean;
+/**
+ * Reject `images` that `model`'s native judgment API cannot take — no image support, or a
+ * documented per-dialect cap exceeded — before any credential or upstream work.
+ * @throws {AIError.ValidationError} naming the reason.
+ */
+export declare function checkNativeJudgmentImages(model: Model, images: readonly ImageContent[]): void;
 /** `TYPESAFE_BASE_URL` when set, else the public API root; trailing slashes stripped. */
 export declare function typesafeBaseUrl(): string;
 /** `TYPESAFE_DEFAULT_MODEL` when set, else {@link TYPESAFE_DEFAULT_MODEL}. */
@@ -43,6 +51,11 @@ export interface NativeJudgeOptions extends NativeJudgeConnection {
      * requests are split. Unset: no cap.
      */
     maxQuestions?: number;
+    /**
+     * Whether the catalogued model accepts images. `false` disables image input;
+     * a `true` value cannot enable a wire dialect that does not support images.
+     */
+    supportsImages?: boolean;
 }
 /** Per-call options for {@link NativeJudge.judge}. */
 export interface NativeJudgeCallOptions extends JudgeOptions {
@@ -60,6 +73,8 @@ export declare class JudgmentApiError extends AIError.ProviderHttpError {
 export declare class NativeJudge implements Judge {
     #private;
     readonly label: string;
+    /** True when the selected native wire and model both accept image inputs. */
+    readonly supportsImages?: boolean;
     readonly api: JudgmentApi;
     readonly provider: string;
     /** Wire model id sent with every request. */

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

@@ -1,8 +1,10 @@
-import type { Usage } from "../types.js";
+import type { ImageContent, Usage } from "../types.js";
 import { type Answer, type Judge, type JudgeOptions, type JudgmentRequest, type JudgmentResult, type JudgmentState, type Question, type Questions } from "./types.js";
 export interface TextPrompt {
     system: string;
     user: string;
+    /** Images are kept as distinct content blocks, never rendered into JSON text. */
+    images?: readonly ImageContent[];
     /** Format-correction attempt; chat backends may enforce tool suppression on the wire. */
     retry?: boolean;
 }
@@ -16,6 +18,8 @@ export interface TextBackend {
     readonly api: string;
     readonly provider: string;
     readonly model: string;
+    /** Whether this backend can send image content on the wire. */
+    readonly supportsImages?: boolean;
     /** State guard for agent-tuned chat models; on-device classifier workers may disable it. */
     readonly guardState?: boolean;
     /** Format-correction retries after a completion cannot be parsed. */
@@ -26,10 +30,11 @@ export interface TextBackend {
 export declare function renderJudgmentState(state: JudgmentState): string;
 /**
  * Render a request: the system prompt carries the preamble and question
- * definitions (constant across states, so prompt caches hit); the user message
- * carries XML-field state followed by the answer-format cue. Small models act
- * on a bare request (answer it, emit tool calls) instead of classifying it —
- * explicit tags and the trailing cue keep them on task.
+ * definitions (constant across states, so prompt caches hit); the user text
+ * carries XML-field state followed by the answer-format cue. Images remain
+ * separate content blocks. Small models act on a bare request (answer it,
+ * emit tool calls) instead of classifying it — explicit tags and the trailing
+ * cue keep them on task.
  */
 export declare function renderJudgmentPrompt(request: JudgmentRequest, options?: {
     guardState?: boolean;
@@ -53,6 +58,7 @@ export declare function splitAnswerLines(text: string, ids: readonly string[]):
 export declare function parseAnswer(id: string, question: Question, reply: string): Answer;
 export declare class TextJudge implements Judge {
     #private;
+    readonly supportsImages?: boolean;
     readonly label: string;
     constructor(backend: TextBackend);
     judge<Q extends Questions>(request: JudgmentRequest<Q>, options?: JudgeOptions): Promise<JudgmentResult<Q>>;

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

@@ -11,7 +11,7 @@
  * bridge ({@link TextJudge}) renders the same questions into keyword prompts
  * for an ordinary chat model.
  */
-import type { Usage } from "../types.js";
+import type { ImageContent, Usage } from "../types.js";
 /** JSON-compatible value; readonly containers are accepted so `as const` state passes through. */
 export type JsonValue = string | number | boolean | null | readonly JsonValue[] | {
     readonly [key: string]: JsonValue;
@@ -73,6 +73,8 @@ export type AnswerFor<Q extends Question> = Q extends ChoiceQuestion<infer L> ?
 export interface JudgmentRequest<Q extends Questions = Questions> {
     state: JudgmentState;
     questions: Q;
+    /** Images evaluated alongside the state; never part of the JSON state itself. */
+    images?: readonly ImageContent[];
 }
 export interface JudgmentResult<Q extends Questions = Questions> {
     /** Transport that produced the answers (a judgment api such as `typesafe`, or the chat model's api). */
@@ -89,6 +91,8 @@ export interface JudgeOptions {
 }
 /** Answers typed questions about a state. Implementations are stateless and safe to share. */
 export interface Judge {
+    /** Whether this backend can consume separate image content blocks. */
+    readonly supportsImages?: boolean;
     /** Backend description for logs, e.g. `typesafe/jev-latest`. */
     readonly label: string;
     judge<Q extends Questions>(request: JudgmentRequest<Q>, options?: JudgeOptions): Promise<JudgmentResult<Q>>;

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

@@ -20,6 +20,22 @@ 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;
+}
 /** How one judgment API addresses, encodes, and decodes a request. */
 export interface JudgmentWire {
     /**
@@ -29,6 +45,8 @@ export interface JudgmentWire {
     target(baseUrl: string, model: string, key: string): JudgmentTarget;
     /** Request body for `model`. */
     encode(request: JudgmentRequest, model: string): unknown;
+    /** Image input this dialect accepts; absent means text-only. */
+    images?: JudgmentImageInput;
     /** 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/provider-session-state.d.ts

@@ -18,8 +18,8 @@
  *   siblings are endpoint-scoped and stay: `strictToolsDisabled`
  *   (grammar-too-large 400 for the model's tool schema),
  *   `replayUnsignedThinkingDisabled` / `thinkingReplayDisabled` (the endpoint
- *   is a signing proxy), `prefixDroppedThinkingBlocks` (blocks a prefix-binding
- *   400 made the client strip).
+ *   is a signing proxy), `prefixDroppedThinkingBlocks` (blocks a rejected
+ *   replay made the client strip).
  * - **OpenAI Responses** — the `previous_response_id` chain baselines are
  *   account-scoped: a stored response belongs to the account that created it.
  *   Strict-tools / reasoning-effort fallbacks, replay warmup and the chaining

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

@@ -118,7 +118,8 @@ export interface AnthropicOptions extends StreamOptions {
      * header is auto-attached; the response parser then honors mid-stream
      * `fallback` content blocks and `usage.iterations` for served-model
      * promotion and per-attempt pricing. Opt-in ONLY — leaving this
-     * undefined preserves the pre-fallback behavior on every code path.
+     * undefined sends neither and keeps both off; a `fallback` block in the
+     * response (a gateway opted in) is still persisted as a replay boundary.
      */
     fallbacks?: FallbackParam[];
 }
@@ -132,6 +133,8 @@ export type AnthropicClientOptionsArgs = {
     dynamicHeaders?: Record<string, string>;
     isOAuth?: boolean;
     hasTools?: boolean;
+    /** Whether a tool in ANTHROPIC_BUFFERED_INPUT_TOOLS is present; suppresses the request-wide fine-grained streaming beta. */
+    hasBufferedInputTools?: boolean;
     thinkingEnabled?: boolean;
     thinkingDisplay?: AnthropicThinkingDisplay;
     disableStrictTools?: boolean;
@@ -283,10 +286,11 @@ export type AnthropicMessageParam = MessageParam;
  * Serialize omp {@link Message}s to Anthropic wire messages.
  *
  * `opts.serverSideFallbackEnabled` — when the CURRENT request itself
- * opts into the server-side-fallback beta chain. Only then may a persisted
- * `fallback` content block from a prior turn be replayed on the wire;
- * otherwise the block is dropped to avoid a 400 on non-fallback requests
- * that don't send the beta.
+ * opts into the server-side-fallback beta chain. Only then, and only on the
+ * official endpoint, may a persisted `fallback` content block from a prior
+ * turn be replayed on the wire; otherwise the block is dropped to avoid a 400
+ * on requests that don't send the beta, and its turn keeps one model's
+ * reasoning (see {@link collapseFallbackSegments}).
  *
  * `opts.replayCompaction` — replay a user-role compaction summary that
  * carries an {@link AnthropicCompactionPayload} from this provider as a

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

@@ -218,6 +218,13 @@ export declare function mergeCursorMcpToolCallArgs(streamed: Record<string, unkn
  * call handed to an external executor is only a handoff while the marker is
  * absent, and the consumer that runs it needs a runnable block.
  *
+ * A frame whose `toolCallId` already has a block in `output` is the server
+ * re-dispatching that call (a new `execId`, e.g. a `read` re-sent once a
+ * parallel shell created the file). It adds no block: a second block with the
+ * same id makes every rebuilt history replay the call twice, which Cursor
+ * rejects (issue #15749). The re-run's result supersedes the first one in the
+ * host's result buffer.
+ *
  * Exported for tests to exercise ordering with adjacent text/thinking blocks.
  */
 export declare function synthesizeCursorExecToolCall(output: AssistantMessage, stream: AssistantMessageEventStream, state: BlockState, toolCallId: string, toolName: string, args: Record<string, unknown>, { executed }?: {

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

@@ -6,6 +6,12 @@ export type { CodexAttestationProvider } from "./openai-codex-attestation.js";
 import type { ResponseInput } from "./openai-responses-wire.js";
 export interface OpenAICodexResponsesOptions extends StreamOptions {
     reasoning?: "none" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max";
+    /**
+     * Run with the least reasoning the model allows; takes precedence over
+     * `reasoning`. Sends the `none` tier where the catalog's disable mode is
+     * `none-effort`, else the model's lowest supported effort.
+     */
+    disableReasoning?: boolean;
     reasoningSummary?: "auto" | "concise" | "detailed" | null;
     /** Explicit `reasoning.context` replay scope. Omitted by default so Codex applies its native request policy. */
     reasoningContext?: CodexReasoningContext;

package/dist/types/providers/systemone-server.d.ts

@@ -14,10 +14,11 @@ export interface SystemOneResponseBody {
     };
 }
 /**
- * Validate the routing-relevant parts of a System One request body.
+ * Validate the routing-relevant parts of a System One request body, including
+ * optional embedded base64 images.
  *
- * @throws {AIError.ValidationError} naming the offending field when `model`,
- * `state`, or `questions` is missing or malformed.
+ * @throws {AIError.ValidationError} when required routing fields are missing
+ * or malformed, or a supplied image is malformed.
  */
 export declare function parseRequest(body: unknown): SystemOneParsedRequest;
 /** Re-encode a judgment result in TypeSafe's response shape. */

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

@@ -36,6 +36,14 @@ export declare function isMalformedToolCallName(name: unknown): boolean;
  * off by `length` / `error` / `aborted` that carries no text and no tool call.
  */
 export declare function shouldDropTruncatedThinkingOnlyAssistant(msg: AssistantMessage): boolean;
+/**
+ * Whether `msg` reaches a replay as an assistant turn, so it can be the latest
+ * 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)`.
+ */
+export declare function isSurvivingAssistant(msg: AssistantMessage): boolean;
 /**
  * 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

@@ -9,7 +9,7 @@ import type { ApiKey } from "./auth-retry.js";
 import type { OAuthRequestIdentity } from "./auth/types.js";
 import type { BedrockOptions } from "./providers/amazon-bedrock.js";
 import type { AnthropicOptions } from "./providers/anthropic.js";
-import type { FallbackParam, StopDetails } from "./providers/anthropic-wire.js";
+import type { FallbackParam, MessageCreateParamsStreaming, StopDetails } from "./providers/anthropic-wire.js";
 import type { AzureOpenAIResponsesOptions } from "./providers/azure-openai-responses.js";
 import type { CursorOptions } from "./providers/cursor.js";
 import type { AppleFoundationModelsOptions } from "./providers/apple-foundation-models.js";
@@ -650,11 +650,12 @@ export interface RedactedThinkingContent {
 }
 /**
  * Anthropic server-side-fallback boundary marker persisted on assistant
- * turns whose provider request opted into
- * `AnthropicOptions.fallbacks`. Consumers other than the Anthropic
- * provider MUST ignore it — `transformMessages` strips the block on any
- * cross-provider hop and on non-official Anthropic replays, so downstream
- * converters never see it.
+ * turns whose response switched models mid-stream, whether the request
+ * opted into `AnthropicOptions.fallbacks` or a gateway opted in on its
+ * behalf. Consumers other than the Anthropic provider MUST ignore it —
+ * `transformMessages` strips the block on any non-Anthropic hop, and
+ * `convertAnthropicMessages` only puts it on the wire for an opted-in
+ * request to the official endpoint.
  */
 export interface AnthropicFallbackContent {
     type: "fallback";
@@ -981,6 +982,12 @@ export type AssistantRetryRecovery = {
 export interface ContextSnapshot {
     promptTokens: number;
     nonMessageTokens: number;
+    /**
+     * Estimated tool-schema tokens included in `nonMessageTokens` (0 when the
+     * model defers schemas server-side). Lets a later model whose schema policy
+     * differs rebase the provider anchor instead of inheriting its schemas.
+     */
+    toolSchemaTokens?: number;
     /** Estimated prompt tokens removed by local history rewrites after this provider snapshot was recorded. */
     historyRewriteTokensRemoved?: number;
     /**
@@ -1422,7 +1429,8 @@ export type AssistantMessageEvent = {
 export interface AnthropicFallbackCreditHandle {
     token: string;
     prefillClaim?: boolean | null;
-    params: unknown;
+    /** The refused request's body, replayed with the credit token on the fallback model. */
+    params: MessageCreateParamsStreaming;
     betas?: readonly string[];
     betaHeader?: string;
     expiresAt: number;

package/dist/types/utils/dsml-leak.d.ts

@@ -23,7 +23,9 @@ export declare function isDsmlLeakRecoveryTarget(model: Model): boolean;
  */
 export declare function stripDsmlToolMarkup(text: string): string | undefined;
 /**
- * Remove leaked DSML tool-call markup from `message`'s text blocks in place,
- * dropping blocks left empty. Returns true when anything was removed.
+ * Remove leaked DSML tool-call markup from an assistant message before commit,
+ * including reasoning blocks and turns with valid structured calls. Rewritten
+ * thinking with an opaque signature is discarded; OpenAI-compatible reasoning
+ * field names are replay markers, not signatures, and survive cleanup.
  */
 export declare function removeDsmlToolMarkupLeak(message: AssistantMessage): boolean;

package/dist/types/utils/tool-call-arguments.d.ts

@@ -5,7 +5,8 @@ export declare function parseToolCallArguments(json: string | undefined): ToolCa
  * Native Responses `function_call.arguments` to persist for replay.
  *
  * {@link parseToolCallArguments} repairs some invalid JSON (e.g. `"name": ,`) and the tool runs with the
- * repaired value; replay drops a call whose stored arguments do not parse, orphaning its output (#14155).
+ * repaired value; replay must carry what was executed (#14155), not the {@link invalidToolCallArguments}
+ * diagnostic it substitutes for stored arguments that do not parse (#15568).
  * Returns `raw` when it already parses or the arguments were unrepairable, else the executed arguments.
  */
 export declare function replayableToolCallArguments(raw: string, executed: ToolCall["arguments"]): string;

package/package.json

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

package/src/auth/usage-cache.ts

@@ -3,6 +3,7 @@ import type { AuthCredential, OAuthCredential } from "./types";
 import type { CredentialPool } from "./pool";
 import type { Provider } from "../types";
 import type { UsageCredential, UsageProvider, UsageReport } from "../usage";
+import { isRecord } from "../utils";
 
 const USAGE_CACHE_PREFIX = "usage_cache:";
 const USAGE_FORCE_REFRESH_CACHE_PREFIX = "force-refresh:";
@@ -53,6 +54,17 @@ function withoutRawPayload(value: unknown): unknown {
 	return rest;
 }
 
+/**
+ * End of a cached value's durable retention. A report is retained for 24h past
+ * its last successful fetch, so re-storing it as a failure fallback never
+ * extends that window; other values are retained for 24h from now.
+ */
+function retentionDeadline(value: unknown): number {
+	const fetchedAt = isRecord(value) ? value.fetchedAt : undefined;
+	const start = typeof fetchedAt === "number" && Number.isFinite(fetchedAt) && fetchedAt > 0 ? fetchedAt : Date.now();
+	return start + USAGE_LAST_GOOD_RETENTION_MS;
+}
+
 /** Convert a stored credential for usage providers; used by usage and health services. */
 export function buildUsageCredential(credential: AuthCredential): UsageCredential {
 	if (credential.type === "api_key") {
@@ -203,15 +215,19 @@ export class UsageCache {
 		return parseUsageCacheEntry<T>(raw);
 	}
 
+	/** Last successful report under `key` while inside its retention window; the failure-path fallback. */
+	lastGood(key: string): UsageReport | null {
+		const report = this.getStale<UsageReport | null>(key)?.value;
+		return report && Date.now() < retentionDeadline(report) ? report : null;
+	}
+
 	set<T>(key: string, entry: UsageCacheEntry<T>): void {
 		const value = withoutRawPayload(entry.value);
-		const payload = JSON.stringify({
-			value,
-			expiresAt: entry.expiresAt,
-		});
-		const durableExpiresAt =
-			value === null ? entry.expiresAt : Math.max(entry.expiresAt, Date.now() + USAGE_LAST_GOOD_RETENTION_MS);
-		this.#store.setCache(`${USAGE_CACHE_PREFIX}${key}`, payload, Math.floor(durableExpiresAt / 1000));
+		const deadline = value === null ? undefined : retentionDeadline(value);
+		// Failure cooldowns must not make a last-good report fresh beyond retention.
+		const expiresAt = deadline === undefined ? entry.expiresAt : Math.min(entry.expiresAt, deadline);
+		const payload = JSON.stringify({ value, expiresAt });
+		this.#store.setCache(`${USAGE_CACHE_PREFIX}${key}`, payload, Math.floor((deadline ?? expiresAt) / 1000));
 	}
 
 	deletePrefix(prefix: string): boolean {

package/src/auth/usage.ts

@@ -334,7 +334,7 @@ export class UsageService implements UsageApi {
 
 		const failure = this.#deps.cache.get<null>(failureKey);
 		if (failure && failure.expiresAt > now) {
-			return this.#deps.cache.getStale<UsageReport | null>(cacheKey)?.value ?? null;
+			return this.#deps.cache.lastGood(cacheKey);
 		}
 
 		// Invalidation must not fork an already-running credential probe. Share it;
@@ -378,9 +378,7 @@ export class UsageService implements UsageApi {
 			// so an expired login does not display stale quota indefinitely.
 			const providerImpl = this.providerFor(request.provider);
 			const retainLastGood = !invalidated && providerImpl?.retainLastGoodOnFailure !== false;
-			const lastGood = retainLastGood
-				? (this.#deps.cache.getStale<UsageReport | null>(cacheKey)?.value ?? null)
-				: null;
+			const lastGood = retainLastGood ? this.#deps.cache.lastGood(cacheKey) : null;
 			const failureBackoffMs = providerImpl?.failureBackoffMs ?? USAGE_FAILURE_BACKOFF_MS;
 			const backoffJitter = failureBackoffMs * (Math.random() * 0.5 - 0.25);
 			const coolDown = Date.now() + failureBackoffMs + backoffJitter;