@oh-my-pi/pi-ai 18.2.0 → 18.2.1

package/CHANGELOG.md

@@ -2,6 +2,41 @@
 
 ## [Unreleased]
 
+## [18.2.1] - 2026-09-15
+
+### Added
+
+- Added support for Cerebras Qwen 3.8-27b with improved reasoning effort control
+- Added optional host browser-session callbacks for Perplexity SSO login, keeping browser automation out of pi-ai and preserving email and authenticator-code login.
+
+### Fixed
+
+- Fixed the auth-gateway sending a model's own reasoning back to Anthropic as demoted plain text, which tripped the `reasoning_extraction` classifier on Fable, leaked reasoning into visible answers on Opus, Sonnet and Haiku, and broke the prompt cache prefix on every tool-calling turn. Replayed assistant turns now carry the model id the request resolves to and a `stopReason` derived from the turn's own tool calls, so same-model thinking blocks keep their signatures and replay natively ([#12115](https://github.com/can1357/oh-my-pi/pull/12115) by [@Zhu-Aemon](https://github.com/Zhu-Aemon)).
+- Fixed custom OpenAI-compatible Responses streams crashing on omitted delta payloads or reasoning-summary fields, and recovered text delivered only in completed snapshots ([#11863](https://github.com/can1357/oh-my-pi/pull/11863) by [@moodiness](https://github.com/moodiness)).
+- Fixed streaming CPU blowup on long Responses turns: per-delta content-index lookups are now O(1) instead of re-scanning the accumulated content blocks, eliminating the quadratic work that could freeze the TUI for tens of seconds to minutes while a subagent streams ([#10605](https://github.com/can1357/oh-my-pi/issues/10605)).
+- Fixed sessions permanently wedged by `400 Invalid signature in thinking block` after a failover proxy swapped upstream models mid-conversation (e.g. Claude -> GLM -> Claude): when the unsigned-demotion retry fails identically, the anthropic-messages transport now retries once with replayed thinking dropped and pins that mode for the session, so the conversation continues without starting a new session ([#12006](https://github.com/can1357/oh-my-pi/pull/12006) by [@Damin-Lee](https://github.com/Damin-Lee)).
+- Fixed OpenAI Codex backend rejecting requests with HTTP 400 (`string_above_max_length`) when replaying tool call IDs exceeding 64 characters or containing composite delimiters (`|`, `\n`) by sanitizing and deterministically clamping call IDs on the wire ([#11342](https://github.com/can1357/oh-my-pi/pull/11342)).
+- Fixed OpenRouter multi-turn tool-call sessions failing with `400 Referenced reasoning item ... was not found or has expired` on Meta Muse Spark models by suppressing reasoning reconstruction when history is filtered and synthetic replay is disallowed, while preserving Anthropic and DeepSeek replay ([#10966](https://github.com/can1357/oh-my-pi/issues/10966)).
+- The auth gateway now keeps provider session state per session, so a model reached through it stops re-learning the same rejection every turn. Sticky fallbacks such as strict-tools and fast mode previously did nothing on the `pi-native` transport used by containerized and robomp deployments, because the state cannot cross the wire and the gateway kept none of its own ([#12058](https://github.com/can1357/oh-my-pi/pull/12058) by [@camjac251](https://github.com/camjac251)).
+- Fixed full OpenAI Responses request-body timeout recovery so the exact HTTP 408 is surfaced for a changed-request recovery instead of repeated unchanged transport retries when eligible tool-result history can be safely elided ([#11878](https://github.com/can1357/oh-my-pi/pull/11878) by [@hellofrommorgan](https://github.com/hellofrommorgan)).
+- Fixed Codex sessions producing unrelated visible output on later turns after a progress-only response. ([#11466](https://github.com/can1357/oh-my-pi/issues/11466))
+- Fixed OpenRouter reasoning models (e.g. Meta Muse Spark) rejecting every turn with `400 Provider returned error` after the session history contains a tool-call turn from another provider, by no longer sending a fabricated reasoning item id ([#11791](https://github.com/can1357/oh-my-pi/pull/11791) by [@brndnmtthws](https://github.com/brndnmtthws)).
+- Fixed statusless stream-drop diagnostics (stream disconnected/closed before `response.completed`, upstream stream interrupted or ended before its terminal chunk, socket disconnected before the secure TLS handshake) classifying as terminal errors, so they now retry like their status-tagged twins instead of settling the turn ([#11805](https://github.com/can1357/oh-my-pi/issues/11805)).
+- OpenAI-compatible endpoints that report `ReasoningEffort` in CamelCase now trigger effort-downgrade retries instead of terminating turns with HTTP 400 ([#11804](https://github.com/can1357/oh-my-pi/issues/11804)).
+- Fixed openai-responses replay wedging a repaired orphan tool-result note between another call's `function_call` and `function_call_output`, which broke round pairing on strict validators (e.g. DeepSeek) with `400 No tool output found for tool call …`: orphan-output/call repair now runs before the interleaved-message hoist, so any injected note is relocated out of the tool-call batch ([#11473](https://github.com/can1357/oh-my-pi/issues/11473)).
+- A stale Anthropic tier block (`tier:fable`, `tier:mythos`) is now cleared once a live usage report shows headroom on both the tier row and the shared windows, instead of idling a usable account until the reported reset. Healing requires a live report, and a credential held by an unscoped block spends no usage request on a probe that cannot lift it ([#11334](https://github.com/can1357/oh-my-pi/pull/11334) by [@AshishKumar4](https://github.com/AshishKumar4)).
+- A running session now picks up credentials another process committed: adding an account in a second terminal is visible to credential selection and rotation without restarting the session, and a session's pinned account is re-resolved by row id so a row another process deleted cannot hand its slot to a sibling ([#11329](https://github.com/can1357/oh-my-pi/pull/11329) by [@AshishKumar4](https://github.com/AshishKumar4)).
+- Fixed rate-limit/overload failures that arrive *inside* an HTTP 200 body (Azure, LiteLLM-style aggregators, and reverse proxies that already committed to the stream) not advancing `retry.fallbackChains`: a `{"error":{…}}`/`{"code":429}` chunk or a plain-text throttle frame (`429 Too Many Requests`, an nginx page) is now classified as a retryable 429/5xx through the same path an HTTP-status 429 takes, so a busy provider backs off and fails over instead of ending the session. Only bodies the provider actually reported are used: no status is inferred from error wording, and an unreadable body can no longer consume a credential.
+- Fixed tool schema normalization and cycle detection for frozen, sealed, and nonextensible schemas.
+- Reduced memory retained by `complete()` and `completeSimple()` while streaming responses.
+- Antigravity quota summaries now identify Claude/GPT routing copies as one shared upstream pool while preserving model-specific quota selection ([#11268](https://github.com/can1357/oh-my-pi/issues/11268)).
+- Fixed the auth-gateway rejecting `content: null` on `/v1/responses` and `/v1/chat/completions` message items with a 400; Codex and other OpenAI clients that emit null content on empty turns now work, matching OpenAI's tolerance ([#10956](https://github.com/can1357/oh-my-pi/issues/10956)).
+- Fixed Azure GPT-6 Astra Chat Completions requests with function tools sending a non-`none` reasoning effort, which Azure rejects with HTTP 400 ([#11052](https://github.com/can1357/oh-my-pi/issues/11052)).
+- Fixed Z.AI and Zhipu usage-limit credential blocks and oneshot completion retries (titles, summaries, classifiers) resolving eight hours late when provider responses omit the reset timestamp timezone ([#11014](https://github.com/can1357/oh-my-pi/issues/11014)).
+- Fixed provider requests failing with `ENOENT` when another process removes a stale shared concurrency lock during acquisition.
+- Fixed Devin-hosted Gemini models rejecting turns that include nullable tool parameters by normalizing tool schemas to Gemini's supported JSON Schema dialect ([#8647](https://github.com/can1357/oh-my-pi/issues/8647), [#10233](https://github.com/can1357/oh-my-pi/pull/10233) by [@will-bogusz](https://github.com/will-bogusz)).
+- Fixed Devin gateway failures leaking raw proxy HTML into turn errors; HTTP status and retry metadata remain available for recovery ([#10233](https://github.com/can1357/oh-my-pi/pull/10233) by [@will-bogusz](https://github.com/will-bogusz)).
+
 ## [18.2.0] - 2026-09-15
 
 ### Added

package/dist/types/auth-broker/remote-store.d.ts

@@ -51,6 +51,23 @@ export declare class RemoteAuthCredentialStore implements AuthCredentialStore {
     get snapshot(): SnapshotResponse;
     /** Re-hydrate the in-memory snapshot from the broker. */
     refreshSnapshot(): Promise<SnapshotResponse>;
+    /**
+     * Stateful probe for broker-side credential changes, mirroring
+     * {@link SqliteAuthCredentialStore.pollExternalChanges} so long-lived broker
+     * clients (notably `auth-gateway serve`) pick up logins/logouts made by
+     * another process without a restart.
+     *
+     * Compares a local content revision, not the broker's numeric generation:
+     * generation is an in-memory counter that resets when the broker process
+     * restarts, so a reconnecting stream can deliver a different credential set
+     * under a repeated (or lower) generation. {@link #refreshCredentialRevision}
+     * bumps the revision whenever the applied credential material actually
+     * changes, catching those cases too. Records foreground activity first: a
+     * low-traffic client's background sync parks after `#backgroundIdleMs`, and
+     * without this wakeup it would never fetch the new snapshot to report in the
+     * first place.
+     */
+    pollExternalChanges(): boolean;
     listAuthCredentials(provider?: string): StoredAuthCredential[];
     /** Broker-backed disabled tombstones; empty against brokers predating the endpoint. */
     listDisabledCredentials(provider?: string, signal?: AbortSignal): Promise<DisabledCredentialSummary[]>;

package/dist/types/auth-gateway/index.d.ts

@@ -1,3 +1,4 @@
 export * from "./http.js";
+export * from "./session-state.js";
 export * from "./server.js";
 export * from "./types.js";

package/dist/types/auth-gateway/session-state.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Server-owned provider session state for the auth-gateway.
+ *
+ * `SimpleStreamOptions.providerSessionState` is how a provider keeps what it
+ * learned about an endpoint across turns of one conversation: Anthropic's
+ * sticky `strictToolsDisabled` / `fastModeDisabled` /
+ * `replayUnsignedThinkingDisabled` flags and dropped-thinking-prefix set,
+ * OpenAI's strict-tools and reasoning-effort fallbacks, Codex's WebSocket and
+ * turn-state sessions. An in-process omp session owns that `Map` for its whole
+ * lifetime, so a grammar-too-large 400 or a fast-mode rejection costs one
+ * wasted round-trip per session rather than one per turn.
+ *
+ * The map is deliberately non-serializable — `Set`/`Map` fields, live sockets,
+ * a `close()` method — so `pi-native-client` strips it from the wire and
+ * `pi-native-server` never accepts it. Gateway clients therefore cannot bring
+ * their own, and without a server-side owner every containerized / robomp turn
+ * re-learns every lesson from a fresh upstream rejection.
+ *
+ * A plain `Map<sessionId, …>` in a long-lived server process is a leak: nothing
+ * ever reclaims an entry, and the entries own timers and sockets. This store is
+ * an LRU with a hard entry ceiling that calls `close()` on everything it drops
+ * and on everything it still holds at shutdown.
+ */
+import type { Api, Model, ProviderSessionState } from "../types.js";
+/**
+ * Retained logical sessions. Each entry is a handful of small provider records
+ * plus, for Codex, a WebSocket session — cheap to keep, but not free, so the
+ * ceiling is what turns "one entry per session id forever" into a bounded cost.
+ * Eviction is least-recently-used, so the ceiling only ever drops sessions that
+ * have been quiet longer than the 256 most recent ones.
+ */
+export declare const AUTH_GATEWAY_MAX_SESSION_STATES = 256;
+/**
+ * Bounded per-session provider state, owned by one gateway server instance.
+ *
+ * Two gateways in the same process get separate stores, so neither can hand a
+ * request another gateway's learned state or close it out from under one.
+ */
+export declare class AuthGatewaySessionStateStore {
+    #private;
+    constructor(max?: number);
+    /** Retained logical sessions. */
+    get size(): number;
+    /**
+     * The provider-session map for one logical session on one model, created on
+     * first use and returned by reference so provider mutations persist into the
+     * next request.
+     *
+     * Keyed by session + provider + model id. The session is the identity that
+     * matters — it is the same identity used for credential stickiness and
+     * prefix-cache keying — but a client is free to reuse one session id across
+     * models, and the coarsest provider entries do not separate models
+     * themselves (`openai-responses` keys its strict-tools / history-replay
+     * record by provider alone, Antigravity by a single constant), so the model
+     * belongs in the key here. Endpoint is deliberately absent: every provider
+     * whose learning is endpoint-specific already sub-keys it internally
+     * (`anthropic-messages:${baseUrl}\0${modelId}`,
+     * `openai-completions:${provider}:${baseUrl}:${modelId}`), and repeating it
+     * would only fragment the map. NUL separates the components so none of them
+     * can forge the boundary.
+     */
+    acquire(sessionId: string, model: Model<Api>): Map<string, ProviderSessionState>;
+    /** Close and drop every retained state. Called when the gateway shuts down. */
+    close(): void;
+}

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

@@ -502,6 +502,11 @@ export { isDefinitiveOAuthFailure } from "./error/auth-classify.js";
  * the usage report reveals. Callers that wait the account out (instead of
  * rotating) must sleep until this, not the error-text hint alone.
  *
+ * `requestedBlockedUntilMs` (epoch ms) is this mark call's initial deadline,
+ * before usage-report correction and longest-wins merging. Callers use it to
+ * distinguish the call's replaceable heuristic from a longer merged block
+ * that credential selection will continue enforcing.
+ *
  * `priorBlockedUntilMs` (epoch ms) is the live block deadline the map already
  * stored for this credential before this call. The merged `blockedUntilMs`
  * masks a pre-existing block shorter than this call's own heuristic
@@ -527,6 +532,8 @@ export interface UsageLimitMarkResult {
     switched: boolean;
     retryAtMs?: number;
     blockedUntilMs?: number;
+    /** This mark call's initial deadline, before report correction and merging. */
+    requestedBlockedUntilMs?: number;
     priorBlockedUntilMs?: number;
     priorBlockedUntilTimed?: boolean;
     reportResetAtMs?: number;
@@ -1116,6 +1123,15 @@ export declare class AuthStorage {
     pinSessionOAuthAccount(provider: string, sessionId: string, credentialId: number, options?: {
         lastUsedAtMs?: number;
     }): boolean;
+    /**
+     * Copy every stored credential affinity from one live session to another.
+     *
+     * The target receives its own sticky entries, so request resolution, usage
+     * blocking, credential rotation, metadata, and persisted pins all continue
+     * through the target session id without retaining a live dependency on the
+     * source session.
+     */
+    inheritSessionCredentials(sourceSessionId: string, targetSessionId: string): number;
     /**
      * Resolve every stored OAuth credential for `provider` independently.
      *

package/dist/types/error/body-error.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Build the classified error for an in-band failure frame, or `undefined` when
+ * the frame is not a retryable in-band failure (in which case the caller keeps
+ * its existing handling and message).
+ *
+ * @param frame decoded SSE `data:` payload, or the `{ error, response }` subset of one
+ */
+export declare function createInBandProviderError(frame: unknown): Error | undefined;
+/**
+ * Build the classified error for a non-JSON SSE frame: gateways and reverse
+ * proxies that answer `data: 429 Too Many Requests` or an HTML throttle page
+ * instead of an OpenAI envelope. `undefined` when the text is not recognisable
+ * as a throttle, so genuinely malformed payloads keep failing loudly.
+ */
+export declare function createInBandProviderErrorFromText(text: string): Error | undefined;

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

@@ -34,6 +34,15 @@ export declare const PYTHON_HTTP2_STREAM_RESET_PATTERN: RegExp;
 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;
+/** Exact HTTP request-body-read timeout diagnostic. */
+export declare function isRequestBodyReadTimeout(status: number | undefined, message: string | undefined): boolean;
+/** Exact pre-output Responses 408 that needs a changed-request recovery path. */
+export declare function isResponsesRequestBodyReadTimeout(message: {
+    api?: Api;
+    errorStatus?: number;
+    errorMessage?: string;
+    requestBodyReadTimeoutFullReplay?: boolean;
+}): boolean;
 export declare const TRANSIENT_TRANSPORT_PATTERN: RegExp;
 /**
  * Local llama.cpp / Ollama deterministic tool-call argument JSON parse failure.
@@ -131,6 +140,13 @@ export declare function stringify(id: number | undefined): string;
  * low-signal to trust once detached from a live transport `Error`, which keeps the broad pattern.
  */
 export declare function isTransientStreamParseError(error: unknown): boolean;
+/**
+ * Transport stream-drop diagnostic (see {@link STREAM_DROP_PATTERN}). Unlike
+ * {@link isTransientStreamParseError}, one pattern serves both the live `Error`
+ * and the persisted-string forms: the phrasings are high-signal enough to trust
+ * detached from a transport `Error`.
+ */
+export declare function isTransientStreamDropError(error: unknown): boolean;
 /** Any malformed stream-envelope error (prefix-tagged or out-of-order events). */
 export declare function isStreamEnvelopeError(error: unknown): boolean;
 /** Stream-envelope errors safe to retry against the provider (event ordering only). */

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

@@ -2,6 +2,7 @@ export * from "./abort.js";
 export * from "./auth.js";
 export * from "./auth-classify.js";
 export * from "./aws.js";
+export * from "./body-error.js";
 export * from "./classes.js";
 export * from "./finalize.js";
 export * from "./flags.js";

package/dist/types/oneshot-retry.d.ts

@@ -63,6 +63,12 @@ export interface OneshotRetryOptions {
      * Thrown errors need no wiring — headers are recovered from the error itself.
      */
     getResponseHeaders?: () => HeadersLike;
+    /**
+     * Provider id of the model being retried. Selects the catalog-declared
+     * timezone for a timezone-naive absolute reset stamp (Z.AI/Zhipu report
+     * Beijing time), so an over-cap wait is not misread as UTC and discarded.
+     */
+    provider?: string;
     /** Observability hook. Fires immediately before sleeping. */
     onRetry?: (info: OneshotRetryInfo) => void;
 }

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

@@ -74,6 +74,33 @@ export interface RequestBody {
  * explicit option; normal inference defaults to the full Responses contract.
  */
 export declare function resolveCodexResponsesLite(requested: boolean | undefined): boolean;
+/**
+ * Repair both halves of unpaired tool exchanges so the Responses input grammar
+ * stays valid — the API rejects either orphan with a 400:
+ *
+ * - `function_call_output` / `custom_tool_call_output` with no matching call →
+ *   folded into an assistant message (`400 No tool call found for … output`).
+ *   Regression of #472 / #1351.
+ * - `function_call` / `custom_tool_call` with no matching `*_output` → a
+ *   placeholder output is synthesized immediately after the call
+ *   (`400 No tool output found for function call …`). Hit when the user
+ *   branches/navigates the session tree to a node that ends on a tool call (the
+ *   tool-result child is dropped from the reconstructed history) or when a turn
+ *   is aborted/crashes after the call streamed but before its result persisted.
+ */
+/**
+ * Sanitize an OpenAI Responses/Codex tool call ID to <= 64 characters and valid charset.
+ * Composite IDs with '|' or '\n' have their secondary/item part stripped.
+ * Hashing is anchored on the canonical base part so assistant and result composites
+ * with different item halves stay identical. Short lossy changes include a hash suffix
+ * to preserve collision resistance across distinct IDs.
+ */
+export declare function sanitizeCodexCallId(rawCallId: string): string;
+/**
+ * In-place mutates the `call_id` property on every input item in the array to conform
+ * to the OpenAI Responses/Codex 64-character limit and valid charset constraints.
+ */
+export declare function sanitizeInputCallIds(input: InputItem[]): void;
 /**
  * Structural view of a Responses-style body mutated by the Lite rewrite.
  * Loose (`unknown`) property types let the turn transformer (`RequestBody`)

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

@@ -6,7 +6,7 @@ import { kStreamingLastParseLen, kStreamingPartialJson } from "../utils/block-sy
 import type { AssistantMessageEventStream } from "../utils/event-stream.js";
 import type { CapturedHttpErrorResponse } from "../utils/http-inspector.js";
 import type { ChatCompletionCreateParamsStreaming } from "./openai-chat-wire.js";
-import type { InputItem } from "./openai-codex/request-transformer.js";
+import { type InputItem } from "./openai-codex/request-transformer.js";
 import type { ResponseComputerToolCall, ResponseContentPartAddedEvent, ResponseCreateParamsStreaming, ResponseInput, ResponseInputContent, ResponseInputItem, ResponseOutputItem, ResponseOutputMessage, ResponseReasoningItem, ResponseStatus, ResponseStreamEvent } from "./openai-responses-wire.js";
 /**
  * Keyless-provider sentinel. Custom providers configured with `auth: none`
@@ -222,6 +222,21 @@ export interface OpenAIExtraBodyOptions {
 export declare function applyOpenAIExtraBody<P extends object>(params: P & {
     venice_parameters?: Record<string, unknown>;
 }, extraBody: Record<string, unknown> | undefined, options?: OpenAIExtraBodyOptions): void;
+/**
+ * Normalize `content: null` to `[]` in place across a list of inbound wire
+ * message items.
+ *
+ * Codex (and other OpenAI clients) emit `content: null` on empty message items
+ * during multi-turn/tool turns; OpenAI tolerates it. Normalizing before the
+ * auth-gateway's request schema validation lets the item take the same path as
+ * an explicit empty content array — for both validation and any native
+ * history-replay clone — instead of 400ing. Shared by the `/v1/responses`
+ * (`input[]`) and `/v1/chat/completions` (`messages[]`) routes.
+ *
+ * `isEligible` lets a route skip items whose content is not array-typed, e.g.
+ * the chat `function` role whose content is `string | null`. See issue #10956.
+ */
+export declare function coerceNullMessageContentInPlace(items: unknown, isEligible?: (item: Record<string, unknown>) => boolean): void;
 /**
  * Chat Completions streaming request body shaped by the OpenAI-family providers.
  * (binary `thinking`, Qwen `enable_thinking`/`chat_template_kwargs`, Venice
@@ -273,7 +288,7 @@ export interface ChatCompletionsReasoningOptions {
     thinkingBudgets?: Partial<Record<Effort, number>>;
 }
 export type OpenAICompatEndpoint = "chat-completions" | "responses";
-export type OpenAIReasoningDisableReason = "caller" | "forced-tool-choice" | "tool-choice" | "not-requested";
+export type OpenAIReasoningDisableReason = "caller" | "forced-tool-choice" | "tool-choice" | "tools" | "not-requested";
 export type OpenAICompatPolicyCompat = ResolvedOpenAISharedCompat & Partial<ResolvedOpenAICompat> & Partial<ResolvedOpenAIResponsesCompat>;
 export interface ResolveOpenAICompatPolicyOptions {
     endpoint: OpenAICompatEndpoint;
@@ -281,6 +296,7 @@ export interface ResolveOpenAICompatPolicyOptions {
     reasoning?: string;
     disableReasoning?: boolean;
     toolChoice?: unknown;
+    hasTools?: boolean;
     strictResponsesPairing?: boolean;
     includeEncryptedReasoning?: boolean;
     filterReasoningHistory?: boolean;
@@ -351,6 +367,7 @@ export declare function resolveOpenAICompatPolicy<TApi extends Api>(model: Model
 export declare function applyChatCompletionsCompatPolicy(params: OpenAICompletionsParams, policy: OpenAICompatPolicy): void;
 export declare function applyChatCompletionsReasoningParams(params: OpenAICompletionsParams, model: Model<"openai-completions">, compat: ResolvedOpenAICompat, options: (ChatCompletionsReasoningOptions & {
     toolChoice?: unknown;
+    hasTools?: boolean;
 }) | undefined): void;
 export declare function disableChatCompletionsReasoningForDialect(params: OpenAICompletionsParams, compat: ResolvedOpenAICompat): void;
 /**
@@ -550,7 +567,7 @@ type ResponsesToolCallBlock = ToolCall & {
     [kStreamingPartialJson]: string;
     [kStreamingLastParseLen]?: number;
 };
-export declare function appendReasoningSummaryPart(item: ResponseReasoningItem, part: ResponseReasoningItem["summary"][number]): void;
+export declare function appendReasoningSummaryPart(item: ResponseReasoningItem, part: ResponseReasoningItem["summary"][number] | undefined): void;
 /**
  * Response-global accumulator for the sequential-cutoff summary contract.
  *

package/dist/types/registry/oauth/perplexity.d.ts

@@ -1,9 +1,3 @@
 import type { OAuthController, OAuthCredentials } from "./types.js";
-/**
- * Login to Perplexity.
- *
- * Tries auto-extraction from the desktop app, then runs HTTP email OTP login.
- *
- * No browser/manual token paste fallback is used.
- */
+/** Prefer legacy app borrowing, then offer browser SSO when the host supports it. */
 export declare function loginPerplexity(ctrl: OAuthController): Promise<OAuthCredentials>;

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

@@ -63,12 +63,20 @@ export interface OAuthProviderInfo {
      */
     storeCredentialsAs?: string;
 }
+/** Sign-in URL and accepted cookies for an isolated, host-owned browser. */
+export type OAuthBrowserSessionRequest = {
+    url: string;
+    /** Cookie names in preference order; return the first non-empty matching value. */
+    cookieNames: readonly string[];
+};
 export interface OAuthController {
     onAuth?(info: OAuthAuthInfo): void;
     onProgress?(message: string): void;
     /** Request pasted callback input; stop any visible prompt when `signal` aborts. */
     onManualCodeInput?(signal?: AbortSignal): Promise<string>;
     onPrompt?(prompt: OAuthPrompt): Promise<string>;
+    /** Complete browser login and return one matching cookie value privately. Reject on cancellation or failure. */
+    onBrowserSession?(request: OAuthBrowserSessionRequest, signal?: AbortSignal): Promise<string>;
     signal?: AbortSignal;
     fetch?: FetchImpl;
 }

package/dist/types/stream.d.ts

@@ -17,6 +17,8 @@ export declare const __providerInFlightForTesting: {
     setHeartbeatWriter(writer: ((writeProviderInFlightInfo: () => Promise<void>) => Promise<void>) | undefined): void;
     setLeaseRemover(remover: ((leasePath: string) => Promise<void>) | undefined): void;
     setWaitObserver(observer: ((provider: string) => void) | undefined): void;
+    setLockCreatedObserver(observer: ((lockDir: string) => Promise<void>) | undefined): void;
+    setLockIdentifiedObserver(observer: ((lockDir: string) => Promise<void>) | undefined): void;
     providerDir(provider: string): string;
     lockDir(provider: string): string;
     captureStaleLockRelease(provider: string): Promise<(() => Promise<void>) | null>;

package/dist/types/types.d.ts

@@ -853,6 +853,8 @@ export interface AssistantMessage {
     errorMessage?: string;
     /** Stable recovery-classification text when errorMessage includes display-only diagnostics. */
     errorClassificationMessage?: string;
+    /** True only when an exact request-body-read timeout failed on a full Responses replay, not a previous-response delta. */
+    requestBodyReadTimeoutFullReplay?: boolean;
     /** Per-tool abort messages used when an aborted assistant turn needs different placeholder results per tool call. */
     toolCallAbortMessages?: Record<string, string>;
     /** HTTP status surfaced by the provider when the request failed. Populated by every provider's catch block alongside `errorMessage` so consumers (auth retry, telemetry, UI) can branch without regex-scraping the message. */
@@ -973,7 +975,7 @@ export interface CursorTodoSnapshot {
  * provider persists this value verbatim. When no handler is registered at all,
  * the provider falls back to its own summary-only result.
  */
-export type CursorTodoSyncHandler = (snapshot: CursorTodoSnapshot | null, toolCallId: string, error: string | null) => ToolResultMessage;
+export type CursorTodoSyncHandler = (snapshot: CursorTodoSnapshot | null, toolCallId: string, error: string | null, origin?: "read" | "update") => ToolResultMessage;
 export interface CursorShellStreamCallbacks {
     onStdout(data: string): void;
     onStderr(data: string): void;

package/dist/types/usage.d.ts

@@ -43,6 +43,8 @@ export interface UsageScope {
     tier?: string;
     windowId?: string;
     shared?: boolean;
+    /** Stable identity shared by routing-specific copies of one upstream quota. */
+    sharedGroup?: string;
 }
 /** Normalized limit entry for a single window or quota bucket. */
 export interface UsageLimit {
@@ -241,6 +243,7 @@ export declare const usageScopeSchema: import("@oh-my-pi/omptype").FluentType<{
     projectId?: string | undefined;
     provider: string;
     shared?: boolean | undefined;
+    sharedGroup?: string | undefined;
     tier?: string | undefined;
     windowId?: string | undefined;
 }, {
@@ -250,6 +253,7 @@ export declare const usageScopeSchema: import("@oh-my-pi/omptype").FluentType<{
     projectId?: string | undefined;
     provider: string;
     shared?: boolean | undefined;
+    sharedGroup?: string | undefined;
     tier?: string | undefined;
     windowId?: string | undefined;
 }>;
@@ -272,6 +276,7 @@ export declare const usageLimitSchema: import("@oh-my-pi/omptype").FluentType<{
         projectId?: string | undefined;
         provider: string;
         shared?: boolean | undefined;
+        sharedGroup?: string | undefined;
         tier?: string | undefined;
         windowId?: string | undefined;
     };
@@ -302,6 +307,7 @@ export declare const usageLimitSchema: import("@oh-my-pi/omptype").FluentType<{
         projectId?: string | undefined;
         provider: string;
         shared?: boolean | undefined;
+        sharedGroup?: string | undefined;
         tier?: string | undefined;
         windowId?: string | undefined;
     };
@@ -359,6 +365,7 @@ export declare const usageReportSchema: import("@oh-my-pi/omptype").FluentType<{
             projectId?: string | undefined;
             provider: string;
             shared?: boolean | undefined;
+            sharedGroup?: string | undefined;
             tier?: string | undefined;
             windowId?: string | undefined;
         };
@@ -404,6 +411,7 @@ export declare const usageReportSchema: import("@oh-my-pi/omptype").FluentType<{
             projectId?: string | undefined;
             provider: string;
             shared?: boolean | undefined;
+            sharedGroup?: string | undefined;
             tier?: string | undefined;
             windowId?: string | undefined;
         };

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

@@ -113,3 +113,39 @@ export type SyntheticUserCarrier = object & {
 };
 /** True for `user` messages synthesized by message transformation. */
 export declare function isSyntheticUser(message: SyntheticUserCarrier | null | undefined): boolean;
+/**
+ * Marks a message synthesized by a per-call context transform rather than
+ * loaded from persisted conversation history.
+ *
+ * Prompt-cache boundaries must skip these messages: their content is rebuilt
+ * for each request and cannot anchor a prefix reused by the next turn.
+ * Symbol-keyed so the marker never persists or reaches the provider wire.
+ */
+export declare const kPerCallContextMessage: unique symbol;
+/** Carries per-call context provenance without exposing a string-keyed property. */
+export type PerCallContextMessageCarrier = object & {
+    [kPerCallContextMessage]?: true;
+};
+/** Marks a message as synthesized for the current provider call. */
+export declare function markPerCallContextMessage(message: PerCallContextMessageCarrier): void;
+/** Copies per-call context provenance to a converted or projected message. */
+export declare function copyPerCallContextMessage(target: PerCallContextMessageCarrier, source: PerCallContextMessageCarrier): void;
+/** True when a message was synthesized for the current provider call. */
+export declare function isPerCallContextMessage(message: PerCallContextMessageCarrier | null | undefined): boolean;
+/**
+ * Original history position carried by a context message clone.
+ *
+ * Object-spread transforms retain this symbol, allowing the extension runner
+ * to distinguish byte-identical historical copies from inserted messages.
+ */
+export declare const kContextHistoryIndex: unique symbol;
+/** Carries a context message's original history position. */
+export type ContextHistoryIndexCarrier = object & {
+    [kContextHistoryIndex]?: number;
+};
+/** Reads a context message's original history position. */
+export declare function getContextHistoryIndex(message: ContextHistoryIndexCarrier | null | undefined): number | undefined;
+/** Records a context message's original history position. */
+export declare function setContextHistoryIndex(message: ContextHistoryIndexCarrier, index: number): void;
+/** Removes context-history tracking before provider conversion. */
+export declare function clearContextHistoryIndex(message: ContextHistoryIndexCarrier): void;

package/dist/types/utils/openai-http.d.ts

@@ -26,6 +26,8 @@ export interface OpenAIStreamRequestInit {
     body: unknown;
     signal: AbortSignal;
     fetch?: FetchImpl;
+    /** Optional caller-specific gate composed with shared transport retry exclusions. */
+    shouldRetryResponse?: (response: Response, bodyText: string) => boolean | Promise<boolean>;
     /** Raw wire-frame observer (`onSseEvent` debug pipeline). */
     onSseEvent?: SseEventObserver;
 }

package/dist/types/utils/retry-after.d.ts

@@ -1,4 +1,6 @@
 export type HeadersLike = Headers | Record<string, string | undefined> | undefined | null;
+/** Extracts retry timing using the provider's catalog-declared timestamp timezone. */
+export declare function extractProviderRetryHint(provider: string | undefined, message: string | undefined): number | undefined;
 export declare function formatErrorMessageWithRetryAfter(error: unknown, headers?: HeadersLike): string;
 export declare function getRetryAfterMsFromHeaders(headers: HeadersLike): number | undefined;
 export declare function getHeadersFromError(error: unknown): HeadersLike;

package/dist/types/utils/schema/wire.d.ts

@@ -41,10 +41,9 @@ export declare function arkToWireSchema(schema: Type): Record<string, unknown>;
 export declare function toolWireSchema(tool: Tool): Record<string, unknown>;
 /**
  * Return a deep clone of `schema` with every `description` annotation removed.
- * The result is memoized on the input via a non-enumerable symbol (`stamp`) so
- * repeated provider requests reuse the same stripped object; the input is never
- * mutated, so the stamped `toolWireSchema` cache stays intact for
- * system-prompt/UI rendering.
+ * The result is memoized against the input (`stamp`) so repeated provider
+ * requests reuse the same stripped object; the input is never mutated, so the
+ * memoized `toolWireSchema` result stays intact for system-prompt/UI rendering.
  */
 export declare function stripSchemaDescriptions(schema: Record<string, unknown>): Record<string, unknown>;
 /**
@@ -53,6 +52,6 @@ export declare function stripSchemaDescriptions(schema: Record<string, unknown>)
  * Used when the full tool catalog is rendered into the system prompt instead, so
  * the descriptions ride the wire once (in the prompt) rather than duplicated on
  * every tool definition. Parameters are resolved to wire JSON Schema and cloned,
- * leaving the original tool objects and the stamped schema cache untouched.
+ * leaving the original tool objects and the memoized schema cache untouched.
  */
 export declare function stripToolDescriptions(tools: readonly Tool[]): Tool[];

package/dist/types/utils.d.ts

@@ -48,6 +48,15 @@ export declare function stripUnpairedOpenAIResponsesComputerReasoningIdsForRepla
  * Returns `undefined` for hidden-empty turns that only contain reasoning and an
  * empty assistant message, allowing callers to rebuild visible transcript
  * history instead of replaying stale native state.
+ *
+ * When the turn does carry replayable output, whitespace-only assistant
+ * messages are dropped rather than replayed. gpt-5.6 Codex ends a turn whose
+ * text all landed in the `commentary` phase with an empty `final_answer`
+ * message; replaying that item verbatim seeds the next turn with an empty slot
+ * the model then fills - `""` → `"\n\n"` → stray words → non-Latin residue -
+ * and each contaminated item is replayed in turn, so the drift compounds until
+ * the visible answer collapses. Codex CLI replays the empty item too
+ * (openai/codex#32389); this is the layer where omp can refuse to.
  */
 export declare function sanitizeOpenAIResponsesAssistantHistoryItemsForReplay(items: Array<Record<string, unknown>>, options?: OpenAIResponsesReplaySanitizeOptions): ResponseInput | undefined;
 /**

package/package.json

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