@oh-my-pi/pi-ai 18.1.16 → 18.1.18

package/CHANGELOG.md

@@ -2,6 +2,35 @@
 
 ## [Unreleased]
 
+## [18.1.18] - 2026-09-11
+
+### Added
+
+- Anthropic server-side compaction (`compact-2026-01-12` beta): `anthropicCompaction` on `StreamOptions` sends the `compact_20260112` context-management edit, the streamed `compaction` block is surfaced as an `anthropicCompaction` provider payload, the `compaction` stop reason is a normal stop tagged in `stopDetails` (exempt from the empty-completion retry), and usage sums `usage.iterations` whenever a compaction iteration ran. A user-role compaction summary carrying that payload replays as a leading assistant `compaction` block — folded into the retained assistant turn when one follows — with the beta and a never-firing strategy attached automatically; other providers keep reading the summary text. Everything compaction-related is gated on the model line (`compat.supportsServerCompaction`, rule-owned in the catalog) and on the endpoint the request actually reaches (`supportsAnthropicCompaction`: the official API for the first-party provider, resolved through Foundry / `ANTHROPIC_BASE_URL` reroutes, or an explicit `remoteCompaction.enabled` opt-in), so a rerouted session or an older model line falls back to the text summary instead of sending a block the API rejects. Caller-owned clients are gated on their own endpoint (the client's `baseURL`, or an explicit `remoteCompaction.enabled` opt-in when it exposes none) and receive the compaction beta per request, like the effort and control betas. A block held by its originating assistant message — a caller that appends the compacting response itself — replays at the head of that turn. The block's opaque `encrypted_content` is captured from the stream, kept on the payload as `encryptedContent`, and replayed verbatim. A compacting turn is priced per sampling iteration (like a server-side fallback turn), so a long-context tier applies only to an iteration whose own prompt crosses the threshold, never to the summed totals.
+- Added historical decimation prompt-cache breakpoints every 15 user turns on Anthropic requests, so long conversations retain stable cached prefixes during branching, rewinds, and session resume ([#11665](https://github.com/can1357/oh-my-pi/pull/11665) by [@camjac251](https://github.com/camjac251)).
+
+### Changed
+
+- Defaulted Anthropic OAuth requests to 1h prompt-cache retention where supported, matching Claude Code subscriber behavior and preventing cache expiry during idle intervals ([#11667](https://github.com/can1357/oh-my-pi/pull/11667) by [@camjac251](https://github.com/camjac251)).
+
+### Fixed
+
+- Fixed Codex HTTP response-body transport failures forwarded through Anthropic-compatible proxies being treated as terminal errors; replay-safe turns now use the existing transient recovery without re-executing completed tools.
+- GitHub Copilot Enterprise requests keep the Copilot CLI identity accepted by private Enterprise endpoints, and Business requests denied with HTTP 400 `model_not_supported` now retry once as the Copilot CLI (matching the existing 403 fallback), restoring models that 18.1.17 rejected as unsupported ([#11669](https://github.com/can1357/oh-my-pi/issues/11669)).
+- Fixed provider stream truncations reported as a bare `unexpected EOF` (and other stream-parse diagnostics) classifying as terminal errors, so they now retry like every other transient transport failure ([#11745](https://github.com/can1357/oh-my-pi/issues/11745)).
+- GitHub Copilot streams remember the working `Copilot-Integration-Id` per credential after a denied chat identity retries as the Copilot CLI, so later streams start at the working shape instead of replaying the denial ([#11669](https://github.com/can1357/oh-my-pi/issues/11669)).
+- Fixed Anthropic OAuth requests omitting the tool-array cache breakpoint, so tool definitions are now cached across session rewrites and sibling subagents ([#11660](https://github.com/can1357/oh-my-pi/pull/11660) by [@camjac251](https://github.com/camjac251)).
+- Fixed Amazon Bedrock OpenAI models rejecting image-bearing tool results by sending each image as a sibling user content block ([#11681](https://github.com/can1357/oh-my-pi/issues/11681)).
+
+## [18.1.17] - 2026-09-10
+
+### Fixed
+
+- Fixed transient Python HTTP/2 stream resets and HTTP/1.1 chunked response interruptions being treated as terminal errors when forwarded by a proxy ([#11160](https://github.com/can1357/oh-my-pi/pull/11160) by [@cyriusweng](https://github.com/cyriusweng)).
+- Ollama cache hits now populate cached-token usage: `prompt_eval_cached_count` from the `/api/chat` done chunk maps to `cacheRead`, with `input` reduced to the uncached portion, so status-line `cache_turn`/`cache_hit` segments and cache-prefix audits report real hit rates instead of false misses.
+- Fixed requests that run across a price change being costed at the newer rate; peak/off-peak estimates now use the rate in effect when the request started.
+- Fixed GitHub Copilot Business seats getting HTTP 403 on every model while the same token succeeds with a Chat client identity: chat and model-policy requests now identify as `copilot-chat`, denied requests retry once as the Copilot CLI (`copilot-developer-cli`), and `COPILOT_INTEGRATION_ID` pins the `Copilot-Integration-Id` header up front; model discovery keeps the CLI identity and the 403 message names the identity and the remedies ([#11372](https://github.com/can1357/oh-my-pi/issues/11372)).
+
 ## [18.1.16] - 2026-09-09
 
 ### Fixed

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

@@ -28,6 +28,12 @@ export declare const Flag: {
 };
 export type Flag = (typeof Flag)[keyof typeof Flag];
 export declare const STREAM_READ_ERROR_PATTERN: RegExp;
+/** Python h2/httpx diagnostics forwarded through provider or proxy error events. */
+export declare const PYTHON_HTTP2_STREAM_RESET_PATTERN: RegExp;
+/** Python h11/httpx EOF while reading an HTTP/1.1 chunked response body. */
+export declare const PYTHON_HTTP_INCOMPLETE_CHUNK_PATTERN: RegExp;
+/** reqwest body-frame failures forwarded by the Codex HTTP proxy. */
+export declare const CODEX_HTTP_BODY_READ_ERROR_PATTERN: RegExp;
 export declare const TRANSIENT_TRANSPORT_PATTERN: RegExp;
 /**
  * Local llama.cpp / Ollama deterministic tool-call argument JSON parse failure.

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

@@ -135,7 +135,21 @@ export type FallbackBlockParam = {
         model: string;
     };
 };
-export type ContentBlockParam = TextBlockParam | ImageBlockParam | ToolUseBlockParam | ToolResultBlockParam | ServerToolUseBlockParam | WebSearchToolResultBlockParam | ToolSearchToolResultBlockParam | ToolAdditionBlockParam | ToolRemovalBlockParam | ThinkingBlockParam | RedactedThinkingBlockParam | FallbackBlockParam;
+/** Beta enabling server-side compaction (`compact_20260112` edit, `compaction` blocks). */
+export declare const COMPACTION_BETA = "compact-2026-01-12";
+/**
+ * Server-side compaction summary (compact-2026-01-12). Returned at the start
+ * of the assistant response that crossed the trigger; on replay the API drops
+ * every block that precedes it, so it may open the messages array. The
+ * `encrypted_content` is opaque provider state, round-tripped verbatim.
+ */
+export type CompactionBlockParam = {
+    type: "compaction";
+    content: string;
+    encrypted_content?: string | null;
+    cache_control?: CacheControlEphemeral | null;
+};
+export type ContentBlockParam = TextBlockParam | ImageBlockParam | ToolUseBlockParam | ToolResultBlockParam | ServerToolUseBlockParam | WebSearchToolResultBlockParam | ToolSearchToolResultBlockParam | ToolAdditionBlockParam | ToolRemovalBlockParam | ThinkingBlockParam | RedactedThinkingBlockParam | FallbackBlockParam | CompactionBlockParam;
 /**
  * A single conversation turn.
  *
@@ -229,12 +243,24 @@ export type FallbackParam = {
     output_config?: OutputConfig;
     speed?: "fast";
 };
+/** Server-side compaction edit (compact-2026-01-12). */
+export type CompactionEdit = {
+    type: "compact_20260112";
+    /** `input_tokens` is the only trigger; `value` must be at least 50,000. */
+    trigger?: {
+        type: "input_tokens";
+        value: number;
+    };
+    pause_after_compaction?: boolean;
+    /** Replaces the API's default summarization prompt entirely. */
+    instructions?: string;
+};
 /** Claude Code context-management beta payload. */
 export type ContextManagement = {
     edits: Array<{
         type: "clear_thinking_20251015";
         keep: "all";
-    }>;
+    } | CompactionEdit>;
 };
 export type MessageCreateParams = {
     model: string;
@@ -267,7 +293,7 @@ export type MessageCreateParams = {
 export type MessageCreateParamsStreaming = MessageCreateParams & {
     stream: true;
 };
-export type StopReason = "end_turn" | "max_tokens" | "stop_sequence" | "tool_use" | "pause_turn" | "refusal" | "sensitive" | "model_context_window_exceeded";
+export type StopReason = "end_turn" | "max_tokens" | "stop_sequence" | "tool_use" | "pause_turn" | "refusal" | "sensitive" | "model_context_window_exceeded" | "compaction";
 export type CacheCreation = {
     ephemeral_5m_input_tokens?: number | null;
     ephemeral_1h_input_tokens?: number | null;
@@ -278,12 +304,15 @@ export type ServerToolUsage = {
 };
 /**
  * Per-attempt token accounting inside a multi-run turn
- * (server-side-fallback-2026-06-01). Populated whenever a fallback chain
- * ran, including sticky-served turns with no `fallback` content block.
- * A `fallback_message` entry is the definitive "served by fallback" signal.
+ * (server-side-fallback-2026-06-01, compact-2026-01-12). Populated whenever
+ * a fallback chain ran, including sticky-served turns with no `fallback`
+ * content block, and whenever the compaction beta is active. A
+ * `fallback_message` entry is the definitive "served by fallback" signal; a
+ * `compaction` entry is the summarization sampling the top-level usage
+ * excludes.
  */
 export type UsageIteration = {
-    type?: "message" | "fallback_message" | string;
+    type?: "message" | "fallback_message" | "compaction" | string;
     model?: string | null;
     input_tokens?: number | null;
     output_tokens?: number | null;
@@ -343,6 +372,10 @@ export type ResponseContentBlock = {
     to: {
         model: string;
     };
+} | {
+    type: "compaction";
+    content?: string | null;
+    encrypted_content?: string | null;
 };
 export type ContentBlockDelta = {
     type: "text_delta";
@@ -356,6 +389,10 @@ export type ContentBlockDelta = {
 } | {
     type: "signature_delta";
     signature: string;
+} | {
+    type: "compaction_delta";
+    content?: string | null;
+    encrypted_content?: string | null;
 };
 export type StopDetails = {
     type: string;

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

@@ -165,6 +165,14 @@ export type AnthropicClientOptionsArgs = {
     fetch?: FetchImpl;
     maxRetryDelayMs?: number;
     sessionId?: string;
+    /** Working-identity cache key for this credential+host; undefined off the Copilot path. */
+    copilotCacheKey?: string;
+    /**
+     * Build-time cache provenance for the wrapper: the cached value the
+     * outgoing headers were built from, or `null` when the cache was empty at
+     * build. `undefined` rereads the cache at dispatch.
+     */
+    copilotCacheSnapshot?: string | null;
 };
 export type AnthropicClientOptionsResult = {
     isOAuthToken: boolean;
@@ -204,6 +212,32 @@ export type AnthropicUsageLike = {
  * zero-valued objects clear prior extras from earlier stream usage snapshots.
  */
 export declare function applyAnthropicUsageExtras(usage: Usage, source: AnthropicUsageLike): void;
+/**
+ * Whether this model's requests reach the official Anthropic API, resolved the
+ * way the transport resolves it — including the Foundry and
+ * `ANTHROPIC_BASE_URL` reroutes that leave `compat.officialEndpoint` stale.
+ */
+export declare function resolvesToOfficialAnthropicEndpoint(model: Model<"anthropic-messages">): boolean;
+/**
+ * Whether server-side compaction (`compact-2026-01-12`) may be spoken for
+ * this model to the endpoint a request actually reaches: a model line the
+ * beta supports (`compat.supportsServerCompaction`, rule-owned in the
+ * catalog), on the official API for the first-party provider or on any
+ * endpoint that opted in through `remoteCompaction.enabled`, and never on one
+ * whose deployment contract excludes context management. The same predicate
+ * gates emitting the edit, attaching the beta, and replaying a persisted
+ * block, so a route or model change can never leave a session sending a block
+ * its endpoint rejects.
+ */
+export declare function supportsAnthropicCompaction(model: Model<"anthropic-messages">, effectiveBaseUrl?: string): boolean;
+/**
+ * {@link supportsAnthropicCompaction} for a request on a caller-owned client:
+ * the endpoint is whatever the client targets (an `AnthropicVertex` client
+ * carries an Anthropic model to Vertex), never the model's own routing. SDK
+ * clients expose it as `baseURL`; a client that exposes no endpoint only
+ * compacts through an explicit `remoteCompaction.enabled` opt-in.
+ */
+export declare function supportsAnthropicCompactionOnClient(model: Model<"anthropic-messages">, client: AnthropicMessagesClientLike): boolean;
 /** Detects the preserved-thinking error caused by rewriting a signed block's conversation prefix. */
 export declare function isThinkingPrefixBindingError(message: string): boolean;
 export declare function isInvalidThinkingSignatureError(message: string): boolean;
@@ -250,9 +284,17 @@ export type AnthropicMessageParam = MessageParam;
  * `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.replayCompaction` — replay a user-role compaction summary that
+ * carries an {@link AnthropicCompactionPayload} from this provider as a
+ * native `compaction` block instead of its text. The API drops every block
+ * before the compaction block, so the assistant turn carrying it may open
+ * the conversation; the request must send the compaction beta (the stream
+ * entry point adds it whenever such a payload is present).
  */
 export declare function convertAnthropicMessages(messages: Message[], model: Model<"anthropic-messages">, isOAuthToken: boolean, opts?: {
     serverSideFallbackEnabled?: boolean;
+    replayCompaction?: boolean;
     dropAllThinking?: boolean;
     droppedThinkingBlocks?: ReadonlySet<string>;
 }): AnthropicMessageParam[];

package/dist/types/providers/github-copilot-headers.d.ts

@@ -1,4 +1,4 @@
-import type { Message } from "../types.js";
+import type { FetchImpl, Message } from "../types.js";
 /**
  * Infer whether the current request to Copilot is user-initiated or agent-initiated.
  * Accepts `unknown[]` because providers may pass pre-converted message shapes.
@@ -11,6 +11,70 @@ export type CopilotDynamicHeaders = {
     premiumRequests: CopilotPremiumRequests;
 };
 export declare function resolveGitHubCopilotBaseUrl(baseUrl: string | undefined, apiKey: string | undefined): string | undefined;
+/**
+ * Opt-in `Copilot-Integration-Id` override for chat and model-policy requests.
+ * Reads `COPILOT_INTEGRATION_ID`; unset/invalid keeps the chat-surface default
+ * (`COPILOT_CHAT_INTEGRATION_ID`). Model discovery keeps the CLI identity: it
+ * unlocks enterprise/experimental models and listing models is not
+ * policy-gated the way chat completions are (#11372).
+ */
+export declare function resolveCopilotIntegrationIdOverride(env?: Record<string, string | undefined>): string | undefined;
+/**
+ * Effective identity before the chat-surface default: explicit value, then
+ * request headers, then `COPILOT_INTEGRATION_ID`. Pure given its inputs, so
+ * tests inject literals instead of mutating process state.
+ */
+export declare function resolveCopilotRequestIdentity(headers?: Record<string, string>, explicit?: unknown, env?: Record<string, string | undefined>): string | undefined;
+/**
+ * Stable cache key for a raw Copilot API key envelope on one effective host.
+ * Hashes the bearer with `Bun.hash` (repo-approved hashing API; same
+ * credential-scoped pattern as the GitLab Duo and Codex account keys) so token
+ * bytes never sit in the map as keys; enterprise/business routing inputs and
+ * the normalized effective base URL participate so the same token on two hosts
+ * does not share an entry.
+ */
+export declare function getCopilotIntegrationCacheKey(apiKeyRaw: string | undefined, baseUrl?: string): string | undefined;
+/** Cached working identity for a cache key, if one was learned. */
+export declare function getCachedCopilotIntegrationId(cacheKey: string | undefined): string | undefined;
+/**
+ * Remember the identity that cleared the identity gate for a credential.
+ * Every store refreshes recency, so hot credentials survive eviction.
+ */
+export declare function rememberCopilotWorkingIntegrationId(cacheKey: string | undefined, integrationId: unknown): void;
+/** Clear one cached identity, or the whole cache when no key is given. */
+export declare function clearCopilotIntegrationCache(cacheKey?: string): void;
+/**
+ * Reissue Copilot client-identity denials once with the other surface.
+ *
+ * Chat is the default surface (`COPILOT_CHAT_INTEGRATION_ID`) because Business
+ * organizations that gate premium models per client surface commonly allow
+ * chat while blocking CLI/agentic clients (issue #11372). Other Business and
+ * Enterprise orgs do the opposite and reject the chat identity — as an HTTP 403
+ * or, on `api.business.githubcopilot.com`, an HTTP 400 `model_not_supported`
+ * (issue #11669). Both denials retry once as the CLI. The retry fires only for
+ * requests carrying the chat default and only when the caller resolved no
+ * explicit identity — an explicit choice is never second-guessed. The denied
+ * body is drained before reissuing, and the retry carries the CLI identity so
+ * the guard passes it through: at most two requests, never a loop.
+ *
+ * When `cacheKey` is set, a 2xx retry remembers its identity via
+ * `rememberCopilotWorkingIntegrationId`, so later streams for the same
+ * credential start at the working shape. A cached CLI start that is itself
+ * denied (stale after an org-policy flip) retries once as chat and relearns.
+ * Only a 2xx retry proves its identity — 401s deny every identity equally and
+ * 408/429/5xx are transport-retryable (the transport resends the *original*
+ * headers), so those must never be recorded as working. Any non-2xx retry
+ * clears the entry instead: the next stream rediscovers rather than pinning a
+ * shape that just failed.
+ */
+export declare function wrapFetchForCopilotFallback(base: FetchImpl | undefined, enabled: boolean, integrationId?: unknown, cacheKey?: string, 
+/**
+ * Build-time cache provenance: the exact cached value the outgoing headers
+ * were built from. `undefined` rereads the cache at dispatch (direct
+ * callers); `null` pins "cache was empty at build" so a sibling learning
+ * mid-flight cannot change this request's retry decision.
+ */
+cacheSnapshot?: string | null): FetchImpl;
 export declare function inferCopilotInitiator(messages: unknown[]): CopilotInitiator;
 /** Check whether any message in the conversation contains image content. */
 export declare function hasCopilotVisionInput(messages: Message[]): boolean;
@@ -37,4 +101,10 @@ export declare function buildCopilotDynamicHeaders(params: {
     headers?: Record<string, string>;
     initiatorOverride?: CopilotInitiator;
     planTier?: string;
+    /** Enterprise login domain; Enterprise keeps the CLI identity that its private endpoint accepts. */
+    enterpriseUrl?: string;
+    /** Raw explicit identity; validated here, chat default when absent/invalid. */
+    integrationId?: unknown;
+    /** Learned working identity for this credential; explicit still wins, then this, then the defaults. */
+    cachedIntegrationId?: unknown;
 }): CopilotDynamicHeaders;

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

@@ -42,5 +42,5 @@ export interface OpenAICompletionsOptions extends StreamOptions {
  * assistant output commits the attempt.
  */
 export declare const streamOpenAICompletions: StreamFunction<"openai-completions">;
-export declare function parseChunkUsage(rawUsage: object, model: Model<"openai-completions">, premiumRequests: number | undefined): AssistantMessage["usage"];
+export declare function parseChunkUsage(rawUsage: object, model: Model<"openai-completions">, premiumRequests: number | undefined, timestamp?: number): AssistantMessage["usage"];
 export declare function convertMessages(model: Model<"openai-completions">, context: Context, compat: ResolvedOpenAICompat): ChatCompletionMessageParam[];

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

@@ -65,6 +65,14 @@ export interface OpenAIRequestSetup {
     headers: Record<string, string>;
     query: Record<string, string> | undefined;
     requestHeaders: Record<string, string>;
+    /** Working-identity cache key for this credential+host; undefined off the Copilot path. */
+    copilotCacheKey: string | undefined;
+    /**
+     * Build-time cache provenance for the wrapper: the cached value the
+     * outgoing headers were built from, or `null` when the cache was empty at
+     * build. `undefined` off the Copilot path (wrapper rereads at dispatch).
+     */
+    copilotCacheSnapshot: string | null | undefined;
 }
 export declare function resolveOpenAIRequestSetup(model: OpenAIRequestSetupModel, options: OpenAIRequestSetupOptions): OpenAIRequestSetup;
 export declare function applyOpenAIServiceTier(params: {

package/dist/types/providers/vision-guard.d.ts

@@ -1,4 +1,4 @@
-import type { ImageContent, Model, TextContent } from "../types.js";
+import type { Api, ImageContent, Model, TextContent } from "../types.js";
 export declare const NON_VISION_IMAGE_PLACEHOLDER = "[image omitted: model does not support vision]";
 export declare function partitionVisionContent(content: ReadonlyArray<TextContent | ImageContent>, supportsImages: boolean): {
     textBlocks: TextContent[];
@@ -12,4 +12,18 @@ export declare function joinTextWithImagePlaceholder(text: string, omittedImages
  * misconfigured provider descriptors or user model entries (e.g. text-only
  * DashScope Qwen SKUs, DeepSeek models) whose endpoints reject `image_url`.
  */
-export declare function isOpenAICompletionsVisionSupported(model: Model<"openai-completions">): boolean;
+export declare function isOpenAICompletionsVisionSupported(model: Model<"openai-completions" | "openrouter">): boolean;
+/**
+ * Whether the transport that will carry `model` sends image content on the wire.
+ *
+ * The `pi-native` transport forwards the original context (images included) to
+ * the gateway, which resolves its own model server-side, so the Chat
+ * Completions guard below never runs client-side and the declared input
+ * applies. Otherwise the OpenAI Chat Completions path applies the text-only
+ * guard, as does the OpenRouter chat fallback (`PI_OPENROUTER_RESPONSES=0`,
+ * which dispatches `openrouter` models through `streamOpenAICompletions`);
+ * every other API ships the modalities the model declares. Callers that report
+ * or gate on the wire (for example the `omp models` table) read this
+ * predicate; declared capability reads `model.input`.
+ */
+export declare function sendsImageInputOnWire(model: Model<Api>): boolean;

package/dist/types/registry/oauth/github-copilot.d.ts

@@ -8,6 +8,7 @@ type GitHubCopilotLoginOptions = {
         allowEmpty?: boolean;
     }) => Promise<string>;
     onProgress?: (message: string) => void;
+    copilotIntegrationId?: unknown;
     signal?: AbortSignal;
     pollIntervalFloorMs?: number;
     pollIntervalScaleMs?: number;

package/dist/types/types.d.ts

@@ -195,6 +195,18 @@ export interface CodexCompactionMetadata {
 export interface CodexCompactionRequestContext extends CodexCompactionMetadata {
     operationId: string;
 }
+/** Anthropic `compact_20260112` context-management edit (`compact-2026-01-12` beta). */
+export interface AnthropicCompactionRequest {
+    /**
+     * Prompt input-token count at which the API compacts. The API enforces a
+     * 50,000-token floor and defaults to 150,000 when omitted.
+     */
+    triggerInputTokens?: number;
+    /** Stop after the compaction block instead of continuing the response. */
+    pauseAfterCompaction?: boolean;
+    /** Custom summarization prompt; replaces the API default entirely when set. */
+    instructions?: string;
+}
 /** OpenAI's GPT-5.6+ explicit prompt-cache controls. */
 export interface OpenAIPromptCacheOptions {
     /** `explicit` disables OpenAI's automatic latest-message breakpoint. */
@@ -243,6 +255,15 @@ export interface StreamOptions {
     anthropicPrefixMismatchBehavior?: "drop_block" | "error";
     /** @internal Marks a replay-only Anthropic request that must use non-streaming `max_tokens: 0`. */
     anthropicCacheRefreshRequest?: boolean;
+    /**
+     * Anthropic server-side compaction (`compact-2026-01-12` beta). Sends the
+     * `compact_20260112` context-management edit so the API summarizes the
+     * prompt in-band once its input reaches the trigger; the resulting summary
+     * arrives as an {@link AnthropicCompactionPayload} on the assistant message.
+     * Ignored by every other provider and by Anthropic-compatible endpoints
+     * without context-management support.
+     */
+    anthropicCompaction?: AnthropicCompactionRequest;
     /**
      * Additional headers to include in provider requests.
      * These are merged on top of model-defined headers.
@@ -703,7 +724,32 @@ export interface AnthropicMessagePayload {
         name: string;
     }>;
 }
-export type ProviderPayload = OpenAIResponsesHistoryPayload | AnthropicMessagePayload;
+/**
+ * Anthropic server-side compaction summary (`compact-2026-01-12` beta).
+ *
+ * Produced by the Anthropic provider on the assistant message of a request
+ * that streamed a `compaction` content block, and attached to the user-role
+ * compaction summary message that replaces the compacted history so the
+ * provider can replay the block verbatim: the API drops every block that
+ * precedes it. `content` is the plain-text summary, so every other provider
+ * reads the message text and ignores the payload.
+ */
+export interface AnthropicCompactionPayload {
+    type: "anthropicCompaction";
+    /** Provider that produced the summary; only that provider replays it natively. */
+    provider: string;
+    content: string;
+    /** Opaque provider state the API attached to the block; replayed verbatim when present. */
+    encryptedContent?: string;
+    /**
+     * Harness-appended file metadata (`<files>` section) kept out of the
+     * byte-identical block. Replayed as a user message after the native block:
+     * the converter replaces the summary message with the block and skips its
+     * text, so without this the metadata would be invisible to this provider.
+     */
+    filesText?: string;
+}
+export type ProviderPayload = OpenAIResponsesHistoryPayload | AnthropicMessagePayload | AnthropicCompactionPayload;
 /** Provider-reported rewrite applied to request content before inference. */
 export interface ProviderInputTransformation {
     type: string;

package/dist/types/utils/block-symbols.d.ts

@@ -72,3 +72,44 @@ export type DemotedThinkingCarrier = object & {
 };
 /** True for text blocks synthesized by cross-model thinking demotion. */
 export declare function isDemotedThinking(block: DemotedThinkingCarrier | null | undefined): boolean;
+/**
+ * Marks an Anthropic wire message that was serialized from a source
+ * `role: "user"` message.
+ *
+ * The wire role alone cannot answer this. `convertAnthropicMessages` emits
+ * `role: "user"` for several things that are not a conversational turn:
+ * `developer` messages on models without mid-conversation `system` support,
+ * `tool_result` runs, and the synthetic `Continue.` pads inserted between
+ * adjacent assistants. Prompt-cache decimation counts conversational turns,
+ * so it reads this marker instead of guessing from wire content.
+ *
+ * Symbol-keyed so the marker never persists across the JSONL round-trip and
+ * never reaches the wire.
+ */
+export declare const kConversationalUser: unique symbol;
+/** Carries the conversational-user marker without exposing a string-keyed property. */
+export type ConversationalUserCarrier = object & {
+    [kConversationalUser]?: boolean;
+};
+/** True for wire messages serialized from a source `role: "user"` message. */
+export declare function isConversationalUser(message: ConversationalUserCarrier | null | undefined): boolean;
+/**
+ * Marks a `role: "user"` message that `transformMessages` synthesized rather
+ * than one the user sent.
+ *
+ * The stale-tool-result note is deliberately emitted as `user` so no provider
+ * elevates untrusted tool output to instruction priority, which leaves it
+ * indistinguishable from a real turn by role alone. Prompt-cache decimation
+ * must not count it, or an orphan result appearing or disappearing in a
+ * compacted history shifts every later checkpoint.
+ *
+ * Symbol-keyed so the marker never persists across the JSONL round-trip and
+ * never reaches the wire.
+ */
+export declare const kSyntheticUser: unique symbol;
+/** Carries the synthetic-user marker without exposing a string-keyed property. */
+export type SyntheticUserCarrier = object & {
+    [kSyntheticUser]?: boolean;
+};
+/** True for `user` messages synthesized by message transformation. */
+export declare function isSyntheticUser(message: SyntheticUserCarrier | null | undefined): boolean;

package/package.json

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

package/src/error/finalize.ts

@@ -45,7 +45,8 @@ export interface FinalizeResult {
  */
 export async function finalize(error: unknown, opts: FinalizeOptions = {}): Promise<FinalizeResult> {
 	const aborted = opts.abortTracker ? opts.abortTracker.wasCallerAbort() : opts.signal?.aborted === true;
-	const currentStatus = status(error) ?? opts.capturedErrorResponse?.status;
+	const errorStatus = status(error);
+	const currentStatus = errorStatus ?? opts.capturedErrorResponse?.status;
 
 	let message: string;
 	try {
@@ -55,11 +56,17 @@ export async function finalize(error: unknown, opts: FinalizeOptions = {}): Prom
 		message = error instanceof Error ? error.message : String(error);
 	}
 
+	// A captured status is transport context for the original error. Put it at
+	// the root of the classification cause chain so terminal 4xx policy governs
+	// nested diagnostics before they can contribute transient flags.
+	const classificationError =
+		errorStatus === undefined && currentStatus !== undefined ? { status: currentStatus, cause: error } : error;
+
 	const id = classifyMessage({
 		api: opts.api,
 		provider: opts.provider,
 		model: opts.model,
-		errorId: classify(error, opts.api),
+		errorId: classify(classificationError, opts.api),
 		errorMessage: message,
 		errorStatus: currentStatus,
 	});

package/src/error/flags.ts

@@ -156,6 +156,13 @@ const TIMEOUT_PATTERN = /\b(?:operation\s+)?timed?\s*out\b|\btimeout\b|\bstream
 const TRANSIENT_ENVELOPE_PATTERN = /anthropic stream envelope error:/i;
 const TRANSIENT_ENVELOPE_TRUNCATION_PATTERN = /before message_(?:start|stop)/i;
 export const STREAM_READ_ERROR_PATTERN = /stream[_ -]?read[_ -]?error/i;
+/** Python h2/httpx diagnostics forwarded through provider or proxy error events. */
+export const PYTHON_HTTP2_STREAM_RESET_PATTERN = /<StreamReset stream_id:\d+, error_code:(?:2|7), remote_reset:True>/;
+/** Python h11/httpx EOF while reading an HTTP/1.1 chunked response body. */
+export const PYTHON_HTTP_INCOMPLETE_CHUNK_PATTERN =
+	/peer closed connection without sending complete message body \(incomplete chunked read\)/;
+/** reqwest body-frame failures forwarded by the Codex HTTP proxy. */
+export const CODEX_HTTP_BODY_READ_ERROR_PATTERN = /\btransport error reading codex response body\b/i;
 export const TRANSIENT_TRANSPORT_PATTERN =
 	/\b(?:no[_ -]?capacity|(?:high|peak)[ _-]?demand|(?:at|over|insufficient)[ _-]?capacity|capacity[ _-]?(?:exceeded|exhausted)|peak[ _-]?load)\b|overloaded|provider.?returned.?error|rate.?limit|too many requests|auth-gateway\s+5\d{2}(?=[:\s]|$)|\b(?:429|500|502|503|504)\b|service.?unavailable|server.?error|internal.?error|retry your request|network.?error|connection.?error|connection.?refused|unable.?to.?connect\.\s*is the computer able to access the url\?|other side closed|fetch failed|upstream.?connect|upstream.?request.?failed|reset before headers|socket hang up|timed? out|timeout|terminated|retry delay|stream stall|no error details in response|HTTP2(?:StreamReset|RefusedStream|EnhanceYourCalm)|nghttp2_(?:internal_error|refused_stream)|stream closed with error code nghttp2_(?:internal_error|refused_stream)|malformed.?function.?call/i;
 const AUTH_FAILURE_PATTERN =
@@ -396,6 +403,8 @@ function isTransientErrorText(text: string): boolean {
 	return (
 		isUnexpectedSocketCloseMessage(text) ||
 		isStreamReadErrorText(text) ||
+		PYTHON_HTTP2_STREAM_RESET_PATTERN.test(text) ||
+		PYTHON_HTTP_INCOMPLETE_CHUNK_PATTERN.test(text) ||
 		(TRANSIENT_ENVELOPE_PATTERN.test(text) && TRANSIENT_ENVELOPE_TRUNCATION_PATTERN.test(text)) ||
 		TRANSIENT_TRANSPORT_PATTERN.test(text)
 	);
@@ -432,6 +441,17 @@ function matchesOverflowText(text: string): boolean {
 	return OVERFLOW_PATTERNS.some(p => p.test(text)) || OVERFLOW_NO_BODY_PATTERN.test(text);
 }
 
+/**
+ * A 4xx the provider rejected as a deterministic client error — every 4xx
+ * except 408 (Request Timeout) and 429 (Too Many Requests), the retryable
+ * pair. Mirrors the 4xx policy in {@link isProviderRetryableError}: such a
+ * request replays identically, so a transient signal riding on it (e.g. a
+ * truncation phrase in the body) must not flip it to retryable.
+ */
+function isTerminalClientErrorStatus(status: number | undefined): boolean {
+	return status !== undefined && status >= 400 && status < 500 && status !== 408 && status !== 429;
+}
+
 function classifyText(
 	errorMessage: string | undefined,
 	errorStatus: number | undefined,
@@ -483,6 +503,24 @@ function classifyText(
 		}
 		if (isTimeoutText(errorMessage)) kinds |= Flag.Transient | Flag.Timeout;
 		else if (isTransientErrorText(errorMessage)) kinds |= Flag.Transient;
+		// A stream truncation or forwarded Codex HTTP body-read failure may not
+		// match TRANSIENT_TRANSPORT_PATTERN. Flag it explicitly so AIError.retriable and
+		// the turn-recovery layer treat it as retryable, matching the provider
+		// retry path (isProviderRetryableError). Separate `if` (not chained onto
+		// the else-if) so a timeout whose text also reads as a truncation keeps
+		// Flag.Timeout alongside Flag.Transient. The string arm applies the strict
+		// STREAM_PARSE_DIAGNOSTIC_PATTERN, per the rationale on isTransientStreamParseError.
+		// Skip a truncation phrase that rides on a terminal 4xx (e.g. a malformed
+		// request rejected as "400 unexpected EOF"): that is a deterministic client
+		// error that replays identically, so keep it terminal. classify() carries
+		// the outer terminal status down the cause chain so a wrapped truncation
+		// (ProviderHttpError 400 → cause "unexpected EOF") is caught here too.
+		if (
+			!isTerminalClientErrorStatus(statusClean) &&
+			(isTransientStreamParseError(errorMessage) || CODEX_HTTP_BODY_READ_ERROR_PATTERN.test(errorMessage))
+		) {
+			kinds |= Flag.Transient;
+		}
 		// A concurrency cap (e.g. Vertex "Online prediction concurrent requests
 		// quota exceeded") is transient — shed-and-backoff. The bare wording need
 		// not match TRANSIENT_TRANSPORT_PATTERN, so flag it explicitly to keep
@@ -521,6 +559,11 @@ export function classify(error: unknown, api?: Api): number {
 	const seen = new Set<object>();
 	const causeTokenEvidence = hasCauseTokenContextOverflowEvidence(error);
 	let link: unknown = error;
+	// A terminal 4xx on an outer link governs its own cause diagnostics: a
+	// wrapped truncation is describing why the deterministic request failed,
+	// not an independently retryable transport fault. Carry it down so the
+	// stream-parse guard in classifyText sees it on the status-less cause.
+	let governingTerminalStatus: number | undefined;
 	while (link !== undefined && link !== null) {
 		if (typeof link === "object") {
 			if (seen.has(link)) break;
@@ -595,8 +638,10 @@ export function classify(error: unknown, api?: Api): number {
 			linkMessage = (link as { message: string }).message;
 		}
 
-		const textId = classifyText(linkMessage, status(link), causeTokenEvidence, api);
+		const linkStatus = status(link);
+		const textId = classifyText(linkMessage, linkStatus ?? governingTerminalStatus, causeTokenEvidence, api);
 		kinds |= textId & KIND_MASK;
+		if (isTerminalClientErrorStatus(linkStatus)) governingTerminalStatus = linkStatus;
 
 		link = typeof link === "object" && "cause" in link ? (link as { cause: unknown }).cause : undefined;
 	}

package/src/error/retryable.ts

@@ -1,5 +1,6 @@
 import { isRetryableError, isUnexpectedSocketCloseMessage } from "@oh-my-pi/pi-utils";
 import {
+	CODEX_HTTP_BODY_READ_ERROR_PATTERN,
 	isRetryableStreamEnvelopeError,
 	isTransientStreamParseError,
 	isUsageLimit,
@@ -51,6 +52,7 @@ export function isProviderRetryableError(error: unknown): boolean {
 		isUnexpectedSocketCloseMessage(msg) ||
 		isTransientTransportMessage(msg) ||
 		TRANSIENT_TRANSPORT_PATTERN.test(msg) ||
+		CODEX_HTTP_BODY_READ_ERROR_PATTERN.test(msg) ||
 		PROVIDER_TRANSIENT_EXTRA_PATTERN.test(msg) ||
 		isTransientStreamParseError(error) ||
 		isRetryableStreamEnvelopeError(error)