@oh-my-pi/pi-ai 18.8.9 → 18.9.1

package/CHANGELOG.md

@@ -2,6 +2,52 @@
 
 ## [Unreleased]
 
+## [18.9.1] - 2026-10-11
+
+### Added
+
+- Added `compat.supportsThinkingBindingControls` for Bedrock Converse: setting it to `false` stops prefix-bound Claude requests from sending `thinking.block_binding`, the `thinking-binding-controls-2026-08-01` beta and the `/input_transformations` response path, for gateways or regions that reject them ([#15316](https://github.com/can1357/oh-my-pi/pull/15316) by [@harshaygadekar](https://github.com/harshaygadekar))
+
+### Fixed
+
+- Fixed Bedrock Claude Fable 5.1 requests with thinking off and a forced tool choice sending the forced choice next to adaptive thinking; the choice now falls back to `auto` ([#15316](https://github.com/can1357/oh-my-pi/pull/15316) by [@harshaygadekar](https://github.com/harshaygadekar))
+
+## [18.9.0] - 2026-10-11
+
+### Breaking Changes
+
+- Removed the `retainTextSignature` option from `consumeGoogleStream` and `streamGoogleGenAI`; Google routes now consistently preserve text reply signatures.
+- Custom `SessionsApi` implementations must implement `permits(provider, sessionId, credentialId)`.
+
+### Added
+
+- Exported `matchesReplacementCredential` and `isSameOAuthAccount` to help identify credential replacement and account ownership.
+- Added `AuthStorage.sessions.permits(provider, sessionId, credentialId)` for checking whether a stored account may serve a session restricted to an account pool.
+- Added `judgeQuestions()` for loading judge questions from JSON with inferred choice labels and answer types, plus `renderQuestion()` for templated instructions.
+
+### Changed
+
+- Devin chat turns now use the native Devin CLI sampling settings by default, while continuing to honor explicitly configured temperature, top-p, and stop sequences.
+- Added `parentSessionId` and `minimizeEffort` stream options. Branched side requests can reuse a conversation's prompt cache, and supported models can run them at their lowest effort without losing cache reuse.
+- Improved cross-host continuation for supported models so confirmed prior reasoning is preserved as reasoning context rather than exposed as `<think>` text in replies.
+
+### Fixed
+
+- Fixed Anthropic subscription quota not appearing in `/usage` when an OAuth token is supplied through `ANTHROPIC_API_KEY`.
+- Fixed custom OpenAI-compatible Responses streams truncating reasoning and incorrectly invoking custom tools with empty input.
+- Fixed Codex WebSocket prewarming so optional service tiers and model routing are handled consistently with normal requests.
+- Fixed OAuth sign-in result pages breaking or rendering injected markup when provider errors or callback values contain special characters.
+- Fixed Anthropic requests failing when tools are added to a conversation or when resumed sessions no longer include earlier tools.
+- Fixed Anthropic requests rejecting tall or oversized historical screenshots by resizing or re-encoding images to the host's limits.
+- Improved compatibility with Anthropic-compatible endpoints that reject prompt-cache options by retrying without unsupported caching features and reporting the disabled capability.
+- LiteLLM proxy logs now group requests by omp conversation instead of displaying a separate session for each request.
+- Fixed Gemini-family integrations echoing prior thinking as visible fenced `thinking` blocks; thinking is now restored as model reasoning across Google, Vertex, Antigravity, Gemini CLI, and Factory Droid routes.
+- Fixed Gemini-family integrations losing text reply signatures needed for subsequent requests across Google, Vertex, Antigravity, Gemini CLI, and Factory Droid routes.
+- Fixed Cursor integrations losing previously recorded reasoning, including signed and redacted reasoning, when continuing or resuming a conversation.
+- Fixed invalid `auth.accountPolicies` entries referring to unavailable accounts from preventing startup, account selection, or login; such entries are now skipped with a warning.
+- Fixed Factory Droid Claude turns with thinking disabled from replaying unsupported earlier thinking blocks, and aligned high-effort Sonnet 5.5 thinking behavior with the native client.
+- Fixed side requests for GPT-6 Responses and Codex models from losing prompt-cache context or applying unsupported reasoning-effort configuration changes.
+
 ## [18.8.9] - 2026-10-10
 
 ### Changed
@@ -2264,108 +2310,4 @@
 - Fixed OpenCode Go usage reporting to synthesize `/usage` limits from OMP-observed request costs for the 5h, weekly, and monthly provider caps. ([#2942](https://github.com/can1357/oh-my-pi/issues/2942))
 - Fixed MiniMax Anthropic-compatible requests to serialize adaptive thinking without an invalid Anthropic `output_config.effort` tier ([#2928](https://github.com/can1357/oh-my-pi/issues/2928)).
 
-## [16.0.6] - 2026-06-18
-
-### Added
-
-- Added support for ArkType schemas as tool parameters alongside existing Zod schemas
-- Added `getOpenRouterHeaders` utility to export standard OpenRouter integration headers
-
-### Changed
-
-- Expanded thinking loop detection guard to also cover DeepSeek models (family, provider, or id matches).
-- Extended loop guard to monitor assistant response prose (via `text_delta` events) in addition to thinking logs, customizable via request options.
-- Modified loop guard error reporting to emit a non-retryable partial content block containing the accumulated streamed text if a loop is detected after response prose has started streaming, preventing unsafe agent session rollbacks.
-- Migrated internal wire-schema validation (auth-broker, Anthropic Messages request, OpenAI Chat/Responses requests, and /v1/usage shapes) from Zod to ArkType
-- Replaced the dedicated `xai-responses` provider with a unified `openai-responses` path that handles xAI-specific reasoning effort stripping dynamically
-- Updated OpenAI Responses stream handling to throw a clearer error message when a stream closes without a terminal response event
-- Consolidated shared OpenAI-compatible routing and strict-tool fallback helpers across Chat Completions and Responses providers.
-- Consolidated the OpenAI-family provider stack: merged `openai-responses-shared` into `openai-shared` and removed the now-dead `openai-responses-shared` re-export shim; folded the three duplicated `service_tier` request blocks and the per-provider wire model-id transform into shared `applyOpenAIServiceTier`/`applyWireModelIdTransform` helpers; moved residual provider-name wire-quirk checks (DeepSeek special-token strip, cumulative reasoning deltas, Ollama empty-length context error, OpenAI tool-call-id cap, Fireworks thinking drop, OpenRouter/OpenAI Responses request fields) into resolved compat fields; shared the Responses stream per-block accumulation helpers plus the terminal pending-tool-call finalization (`finalizePendingResponsesToolCalls`) and toolUse/pause stop-reason promotion (`promoteResponsesToolUseStopReason`) between `processResponsesStream` and the Codex stream handler; and removed the redundant `getOpenAIResponsesCacheSessionId` alias in favor of `getOpenAIResponsesPromptCacheKey`.
-- Centralized OpenAI-family request-param policy into shared `resolveOpenAIOutputTokenParam` (output-token field selection, OpenRouter default-cap omission, `alwaysSendMaxTokens` defaulting, model/provider clamp), `applyOpenAIGatewayRouting` (OpenRouter `provider` + Vercel AI Gateway `providerOptions`), and `applyOpenAIExtraBody` (extra-body merge + Fireworks thinking drop) helpers used by both Chat Completions and Responses `buildParams`, and moved the Chat Completions reasoning/thinking dialect dispatch (`applyChatCompletionsReasoningParams` + `disableChatCompletionsReasoningForDialect`) plus the `OpenAICompletionsParams` request type into `openai-shared` alongside `applyResponsesReasoningParams`. As a consistency consequence, direct `streamOpenAIResponses` calls (bypassing `streamSimple`) now emit `max_output_tokens` for `alwaysSendMaxTokens` (Kimi-family) models even without a caller cap — matching Chat Completions and the value `streamSimple` already supplied.
-- Centralized OpenAI-family reasoning compat resolution behind a shared `resolveOpenAICompatPolicy` consumed by both Chat Completions and Responses request builders. Shared policy now drives tool-choice reasoning suppression, dialect-specific disable encoding, reasoning-history replay filters, encrypted-reasoning inclusion, Mistral/OpenAI tool-call-id modes, stream healing/DeepSeek token stripping, and xAI/OpenRouter cache-affinity wiring instead of endpoint-local provider/model checks.
-
-### Fixed
-
-- Fixed OpenAI Responses cost accounting to apply standard service-tier pricing multipliers (flex 0.5×, priority 2×) to the calculated cost based on the served (or requested) service tier for provider `"openai"` models.
-- Fixed OpenAI Chat Completions to consume the dedicated `requiresReasoningContentForAllAssistantTurns` compatibility flag, preventing unnecessary reasoning replay on non-tool-call turns for OpenRouter DeepSeek and OpenCode models.
-- Fixed the Kimi Code and Synthetic dual-surface shim (`streamOpenAIAnthropicShim`) to correctly forward caller-supplied `toolChoice`, `serviceTier`, and `disableReasoning` options.
-- Fixed the OpenAI Responses tool-choice compatibility helper to drop `tool_choice` when `supportsToolChoice` is false, and downgrade forced choices to `"auto"` when `supportsForcedToolChoice` is false.
-- Fixed Azure Responses to avoid emitting `tool_choice: "none"` when `context.tools` is empty.
-- Fixed Kimi via OpenRouter forced-tool requests to omit the OpenRouter `reasoning` object instead of sending `reasoning: { enabled: false }`, preserving the generic OpenRouter explicit-disable behavior while avoiding Kimi's forced-tool reasoning conflict.
-- Fixed Google Gemini CLI credential parsing schema to gracefully handle empty or unexpected non-string shapes without throwing unhandled exceptions
-- Fixed Google Gemini CLI credential parsing to correctly prioritize `projectId` over `project_id` even when empty, and drop non-string values gracefully
-- Fixed OpenRouter Responses requests to omit default max token fields unless an explicit caller cap is provided, preventing upstream filtering issues
-- Fixed Chat Completions reasoning suppression (`disableReasoningOnToolChoice` / `disableReasoningOnForcedToolChoice`) to turn thinking off symmetrically across every dialect via a shared `disableChatCompletionsReasoningForDialect` helper. Previously the conflict path only deleted `reasoning_effort`/`reasoning` (and set Z.AI `thinking: { type: "disabled" }` on the forced branch alone), leaving Qwen `enable_thinking`, Qwen chat-template `chat_template_kwargs.enable_thinking`, and OpenRouter nested `reasoning` enabled — so those hosts could keep thinking on under forced/required tool choice and re-trip the incompatibility the policy guards against. OpenRouter is now set to `{ reasoning: { enabled: false } }` (not deleted, which OpenRouter treats as default-on).
-- Fixed OpenRouter Responses requests to send `session_id` from `sessionId` in the request body for sticky provider routing and observability grouping.
-- Fixed OpenRouter Responses request shaping to preserve provider routing, variant suffixes, caller header overrides, and strict-tool fallback behavior while omitting only unsafe default max-token caps.
-- Fixed OpenAI Responses stateful chaining so a non-ZDR stale `previous_response_id` retry keeps `store: true`: the full-context retry stays chainable on the next turn and the consecutive stale-failure circuit breaker trips after the configured limit instead of alternating cold turns. Zero Data Retention rejections still disable chaining on the first strike.
-- Fixed Anthropic Messages tool schema normalization demoting root `anyOf`/`allOf` and all `oneOf` constraints into descriptions instead of forwarding provider-rejected keywords in MCP tool `input_schema`.
-- Fixed Ollama Cloud GLM-5.2 reasoning efforts to map `xhigh` to native think `"max"` ([#2911](https://github.com/can1357/oh-my-pi/pull/2911) by [@serverinspector](https://github.com/serverinspector))
-- Fixed OpenRouter Responses requests tagging the streamed assistant message with a hardcoded `openai-responses` API instead of the runtime `model.api`, which silently disabled native-history replay (`buildResponsesInput`) and cross-model tool-call item-id stripping on subsequent OpenRouter turns. The message now carries `model.api` (matching the Chat Completions path).
-- Fixed OpenAI-family streaming leaking a pre-retry `errorMessage` onto a successful turn: the OpenRouter Anthropic compiled-grammar strict-tool fallback set `errorMessage` before retrying with strict tools disabled and never cleared it on success, and the Chat Completions success path could carry an `errorMessage` from an internally-retried attempt — both made a successful turn read as errored in agent state and telemetry. The Responses fallback no longer assigns `errorMessage`, and the Completions success path clears it before emitting the terminal `done` event.
-- Fixed Codex stream-error `.code` resolution to use the same nested-first precedence (`error.code` → `error.type` → top-level `code`) as `isRetryableCodexFailureEvent` and the formatted message. Previously the error factory resolved top-level-first, so a failure event carrying both a top-level and a differing nested error code surfaced a `.code` that could disagree with its own `retryable` flag and message text.
-
-## [16.0.5] - 2026-06-17
-
-### Added
-
-- Added `antigravityEndpointMode` stream option with `auto`, `production`, and `sandbox` values to control Antigravity endpoint routing
-- Added `seedApiKeyResolver` for reusing a pre-resolved request key while preserving resolver-driven auth retry and credential rotation
-- Added optional `contextSnapshot` property to `AssistantMessage` with token usage metadata via new `ContextSnapshot` interface (`promptTokens`, `nonMessageTokens`, and optional `lastMessageTimestamp`)
-- Added `LITELLM_BASE_URL` guidance to the LiteLLM login prompt so non-default proxy endpoints are discoverable. ([#2726](https://github.com/can1357/oh-my-pi/issues/2726))
-- Added a Gemini thinking-loop guard that watches streamed `thinking` deltas for degenerate reasoning loops — verbatim tail repetition and near-duplicate paragraph cycling — and terminates the stream with a retryable, empty-content `error` message (worded as a transient stream stall) so the turn is discarded and re-sampled instead of committing a runaway transcript. Gated to Gemini models across every transport (OpenRouter, direct Google, Vertex) and disarmed once visible answer text or a tool call starts; disable with `PI_NO_THINKING_LOOP_GUARD=1`.
-
-### Changed
-
-- Changed the Antigravity (`google-antigravity`) request builder to mirror the captured `antigravity/hub` client: gemini-3.x send `thinkingConfig.thinkingBudget` per tier, a fixed per-model `maxOutputTokens`, a default `functionCallingConfig.mode: "VALIDATED"` tool mode (auto/unset tool choice only), a `role: "user"` system instruction, a structured `requestId` (`agent/<id>/<ts>/<trajectoryId>/<step>`), and `labels` (`model_enum`, `trajectory_id`, `last_step_index`, `last_execution_id`, `used_claude*`) tracked across the conversation via provider session state.
-
-### Fixed
-
-- Fixed Gemini usage-tier mapping so `gemini-3.5-flash` is treated as `Flash` and `gemini-3.1-pro` plus `gemini-pro-agent` are treated as `Pro` in usage accounting
-- Fixed Antigravity stream state handling so a request’s `last_execution_id` is committed only after a successful completion and cleared between retry attempts
-- Fixed `streamSimple()` Gemini streams to run through the thinking-loop guard for custom API and pi-native transports, so degenerate `thinking` loops now abort with the same retryable empty-content error path as other Gemini stream paths
-- Fixed Antigravity model streaming and usage fetch paths to retry on transient `429`/`5xx` errors by failing over to the alternate endpoint before surfacing an error
-- Fixed Antigravity endpoint tracking to prefer a previously successful endpoint in `auto` mode for subsequent requests
-- Fixed Antigravity and Gemini CLI model requests failing with an opaque error when Google requires account verification. Cloud Code Assist `403 VALIDATION_REQUIRED` responses now surface the `validation_url` and the signed-in account email when available, so users see an actionable account-verification message instead of the raw API error body.
-- Fixed MiniMax M3 in-band tool calls by adding a MiniMax dialect that parses `<minimax:tool_call>` wrappers instead of falling back to generic XML. ([#2759](https://github.com/can1357/oh-my-pi/issues/2759))
-- Fixed GitHub Copilot OAuth for Business seats by storing the login-discovered API endpoint and routing model enablement plus chat requests to that endpoint. ([#2876](https://github.com/can1357/oh-my-pi/issues/2876))
-
-## [16.0.4] - 2026-06-17
-
-### Fixed
-
-- Fixed tool argument coercion to parse double-encoded JSON strings, including quoted values like `"300"`, when schema expects a number
-- Fixed object-array coercion to parse JSON object and array strings into proper array arguments instead of wrapping raw strings
-- Fixed handling of malformed JSON container strings for array schema fields so validation now surfaces a top-level `expected array, received string` error rather than nested element errors
-- Fixed ChatGPT/Codex browser login missing connector OAuth scopes and rendering object-shaped token endpoint errors as `[object Object]`. ([#2825](https://github.com/can1357/oh-my-pi/issues/2825))
-- Fixed Zhipu/BigModel GLM-5.2 chat-completions requests so internal `xhigh` effort serializes as provider-native `reasoning_effort: "max"` and tool calls opt into `tool_stream`. ([#2833](https://github.com/can1357/oh-my-pi/issues/2833))
-- Fixed Google Gemini CLI and Antigravity tool calls with `toolChoice: "auto"` serializing an explicit `toolConfig` AUTO mode, which can cause Gemini-3 models to leak raw planning JSON instead of executing tools. ([#2830](https://github.com/can1357/oh-my-pi/issues/2830))
-
-## [16.0.3] - 2026-06-16
-
-### Added
-
-- Exported `renderDelimitedThinking` from the `@oh-my-pi/pi-ai/dialect` barrel so consumers can reuse the dialect's `<thinking>` envelope unwrap-and-rewrap logic (the only `./dialect/rendering` primitive re-exported; the rest stay dialect-internal).
-
-### Fixed
-
-- Fixed OpenAI Responses/Codex tool schema normalization stripping provider-rejected regex lookaround patterns from MCP tool parameter schemas. ([#2784](https://github.com/can1357/oh-my-pi/issues/2784))
-- Fixed OpenAI Responses parallel tool-call routing so late keyed argument deltas for a closed call are dropped instead of being appended to another open call.
-
-## [16.0.2] - 2026-06-16
-
-### Added
-
-- Added `UMANS_WEBSEARCH_PROVIDER=native|exa` support for routing Umans gateway-owned web search requests.
-
-### Fixed
-
-- A single MCP tool whose input schema can't be emitted as a valid strict tool schema for the active provider no longer fails the whole turn with HTTP 400. `convertTools` (openai-responses) now validates each tool's emitted parameter schema for `enum`/`const`-vs-`type` contradictions that pass structural JSON-Schema validation but the provider rejects — e.g. a non-null `enum` on a `type: "null"` node, or an `enum` on an `array` node — and quarantines just the offending tool with a `logger.warn` naming the tool and schema path, keeping every other tool usable. Adds `findStrictToolSchemaViolation` to `@oh-my-pi/pi-ai/utils/schema` ([#2652](https://github.com/can1357/oh-my-pi/issues/2652))
-- Fixed OpenAI Responses-compatible streams from Ollama/local hosts dropping arguments for parallel tool calls whose deltas use `fc_<call_id>` item ids, which left earlier `ast_grep` calls with `{}` and failed validation. ([#2715](https://github.com/can1357/oh-my-pi/issues/2715))
-- Fixed dialect transcript rendering so literal thinking envelopes are unwrapped before adding the dialect's own thinking tags, preventing nested `<thinking>` output in advisor raw dumps ([#2700](https://github.com/can1357/oh-my-pi/issues/2700)).
-- Fixed Anthropic-compatible Umans requests escaping client tool names and forwarding gateway web search headers so Kimi answers normally instead of returning raw gateway search results.
-- Fixed Google Gemini tool calls with `toolChoice: "auto"` serializing an explicit `toolConfig` AUTO mode, which can cause Gemini-3 models to leak raw planning JSON instead of executing tools. ([#2776](https://github.com/can1357/oh-my-pi/issues/2776))
-- Fixed OpenAI-compatible Ollama completions that return empty `finish_reason:length` after filling `num_ctx` so they surface an actionable context-window error instead of an empty length stop. ([#2774](https://github.com/can1357/oh-my-pi/issues/2774))
-- Fixed Codex browser login issuing credentials for the `opencode` OAuth originator while OMP requests identify as `pi`, which could make the first authenticated Codex request return 401 ([#2696](https://github.com/can1357/oh-my-pi/issues/2696)).
-
-Older entries are archived in [packages/ai/CHANGELOG.md@0dd6aff5f282](https://github.com/can1357/oh-my-pi/blob/0dd6aff5f2821aec1e5b54c6a458e323667a949b/packages/ai/CHANGELOG.md).
+Older entries are archived in [packages/ai/CHANGELOG.md@592e894eb29e](https://github.com/can1357/oh-my-pi/blob/592e894eb29ed3db2ee2dae71ec7d72ac13c64c8/packages/ai/CHANGELOG.md).

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

@@ -37,6 +37,7 @@ export declare class SessionAffinity implements SessionsApi {
      * session, otherwise only an OAuth credential whose identity key is allowed.
      */
     allows(provider: string, sessionId: string | undefined, credential: AuthCredential): boolean;
+    permits(provider: string, sessionId: string, credentialId: number): boolean;
     /** Drop every pin for a provider, both in memory and in the persisted cache. */
     clearProvider(provider: string): void;
     /** Drop only this in-memory session pin after OAuth selection falls through. */

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

@@ -14,6 +14,7 @@ export declare class AccountPolicies {
      */
     replace(policies: AuthAccountPolicies, defaultReservePct: number | undefined, storedCredentials?: ReadonlyMap<string, readonly AuthCredential[]>): void;
     validateUsageCapability(provider: string, canFetchUsage: boolean): void;
+    /** Throw on ambiguous selectors for `provider`; a selector whose account is absent is inert and warns once. */
     validateFor(provider: string, credentials: readonly AuthCredential[]): void;
     /**
      * Return the configured account policy matching an OAuth identity.

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

@@ -1,7 +1,6 @@
 import type { OAuthCredentials } from "../registry/oauth/types.js";
 import type { Provider } from "../types.js";
 import { type CredentialPool } from "./pool.js";
-import type { AccountPolicies } from "./policy.js";
 import { type AuthCredentialStore } from "./store.js";
 import { type AuthCredentialSnapshotEntry, type AuthStorageOptions, type OAuthCredential, type OAuthRefreshByIdOptions, type OAuthRefreshReason, type StoredOAuthRefreshOptions, type StoredOAuthRefreshResult } from "./types.js";
 /**
@@ -30,7 +29,6 @@ export declare function mergeRefreshedCredential<T extends OAuthCredential>(curr
 export interface OAuthRefresherDeps {
     store: AuthCredentialStore;
     pool: CredentialPool;
-    policies: AccountPolicies;
     override?: AuthStorageOptions["refreshOAuthCredential"];
     overrideMints?: AuthStorageOptions["refreshOAuthCredentialMints"];
 }

package/dist/types/auth/sqlite-credential-store.d.ts

@@ -7,7 +7,7 @@
 import type { Database } from "bun:sqlite";
 import { isSqliteBusyError, isSqliteCorruptionError } from "@oh-my-pi/pi-utils";
 import type { AuthCredentialStore, CredentialRefreshLeaseFence } from "./store.js";
-import type { AuthCredential, DisabledCredentialSummary, StoredAuthCredential, StoredCredentialBlock } from "./types.js";
+import type { AuthCredential, DisabledCredentialSummary, OAuthCredential, StoredAuthCredential, StoredCredentialBlock } from "./types.js";
 import type { OAuthCredentials } from "../registry/oauth/types.js";
 import type { ClientUsageReport, ClientUsageSummary, UsageHistoryEntry, UsageHistoryQuery } from "../usage.js";
 export declare const USAGE_REPORT_TTL_MS: number;
@@ -25,6 +25,19 @@ export declare function serializeCredential(provider: string, credential: AuthCr
  * an OAuth credential without any account, email, project, or org identity.
  */
 export declare function resolveCredentialIdentityKey(provider: string, credential: AuthCredential): string | null;
+/**
+ * Whether upserting `incoming` replaces the active row holding `existing` (stored
+ * under `existingIdentityKey`) instead of inserting a new row beside it.
+ */
+export declare function matchesReplacementCredential(provider: string, existing: AuthCredential | null, existingIdentityKey: string | null, incoming: AuthCredential): boolean;
+/**
+ * Whether two OAuth credentials belong to the same account of the same organization,
+ * whichever identity key each is stored under. The email decides when both carry one;
+ * otherwise a matching account id does, unless it is the organization's own id (a
+ * ChatGPT workspace id shared by every member). Project ids are shared between users
+ * (every consumer Antigravity login has the same one) and never count.
+ */
+export declare function isSameOAuthAccount(a: OAuthCredential, b: OAuthCredential): boolean;
 /**
  * Default SQLite-backed implementation of {@link AuthCredentialStore}.
  *

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

@@ -1092,6 +1092,12 @@ export interface SessionsApi {
      * so a stale owner never lifts the restriction a newer owner relies on.
      */
     unrestrict(provider: string, sessionId: string, lease: SessionRestrictionLease): void;
+    /**
+     * Whether stored credential `credentialId` may serve `sessionId`: always for
+     * an unrestricted session, otherwise only an OAuth account its
+     * {@link restrict} list names.
+     */
+    permits(provider: string, sessionId: string, credentialId: number): boolean;
     /**
      * Release a session's sticky credential so its next {@link getApiKey} call
      * re-runs native pool ranking. This never blocks or penalizes the released

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

@@ -1,6 +1,6 @@
 import type { AuthCredentialStore } from "./auth/store.js";
 import type { AuthAccountPolicies, AuthApiKeyOptions, AuthStorageOptions, BlocksApi, CredentialsApi, HealthApi, KeysApi, LimitsApi, OAuthApi, ResetsApi, SessionsApi, UsageApi } from "./auth/types.js";
-export { isSqliteBusyError, isSqliteCorruptionError, resolveCredentialIdentityKey, SqliteAuthCredentialStore, } from "./auth/sqlite-credential-store.js";
+export { isSameOAuthAccount, isSqliteBusyError, isSqliteCorruptionError, matchesReplacementCredential, resolveCredentialIdentityKey, SqliteAuthCredentialStore, } from "./auth/sqlite-credential-store.js";
 export * from "./auth/store.js";
 export * from "./auth/types.js";
 /**
@@ -35,8 +35,9 @@ export declare class AuthStorage {
     /**
      * Apply new account routing policy (live `auth.accountPolicies` /
      * `retry.usageReservePct` change). Throws a configuration error, leaving the
-     * active policy untouched, when the policy is malformed or does not match the
-     * stored OAuth accounts.
+     * active policy untouched, when a policy is malformed, a selector matches
+     * several stored OAuth accounts, or two policies claim the same account; a
+     * policy naming an absent account stays inactive and logs a warning.
      */
     setAccountPolicies(config: {
         accountPolicies: AuthAccountPolicies;

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

@@ -23,6 +23,16 @@ export declare const Flag: {
     readonly FastModeUnsupported: 536870912;
     /** OAuth refresh failed definitively — the stored grant is dead, re-login required. */
     readonly OAuthExpiry: 1073741824;
+    /**
+     * An Anthropic-compatible endpoint rejected the `cache_control` field with a
+     * 400, so prompt-cache breakpoints must be dropped for it.
+     *
+     * Every bit from {@link Flag.Class} up is already taken, so this claims a low
+     * bit instead. Those belong to the raw-status lane — an unclassified id is an
+     * HTTP status (100-599, see `statusFromId`) — and 0x800 is 2048, above every
+     * status value, so no raw status id can set it.
+     */
+    readonly CacheControlUnsupported: 2048;
     /** HTTP 413 byte/media rejection — token compaction cannot shrink bytes or media budgets (#9235). */
     readonly PayloadRejected: 2147483648;
 };
@@ -113,6 +123,19 @@ export declare function isGrammarError(error: unknown): boolean;
  * Accessor for {@link Flag.FastModeUnsupported}.
  */
 export declare function isFastModeUnsupported(error: unknown): boolean;
+/**
+ * An Anthropic-compatible endpoint returned a 400 rejecting something about
+ * `cache_control`. Whether it refused the field or one nested option is not
+ * decidable here (see {@link CACHE_CONTROL_FIELD_PATTERN}); the caller's retry
+ * ladder settles it by replaying.
+ * Accessor for {@link Flag.CacheControlUnsupported}.
+ *
+ * Unlike the high-bit accessors this also requires a classified id. The flag
+ * sits in the raw-status lane (see {@link Flag.CacheControlUnsupported}), and
+ * while no HTTP status reaches 0x800, `is` is a bare bit test — the extra gate
+ * keeps a stray non-HTTP status out of the retry path.
+ */
+export declare function isCacheControlUnsupported(error: unknown): boolean;
 /**
  * Cline's gateway gates some roster entries (certain free-tier models) to its
  * own product surfaces with a 403. The API key is valid — the restriction is

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

@@ -1,4 +1,5 @@
 export * from "./chat.js";
+export * from "./question-file.js";
 export * from "./text.js";
 export * from "./types.js";
 export * from "./typesafe.js";

package/dist/types/judgment/question-file.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Judge questions authored as JSON files: `instructions` plus optional
+ * `criteria`, keyed by question id. A JSON import widens every string, so a
+ * question's kind follows from the shape of its `criteria` rather than a
+ * `type` field — the same rule at compile time ({@link QuestionFor}) and at
+ * load ({@link judgeQuestions}):
+ * - a list of levels, lowest first → {@link ScoreQuestion}
+ * - absent, or only `true`/`false` rubrics → {@link NoulQuestion}
+ * - any other labels → {@link ChoiceQuestion} over them; `{}` when the caller
+ *   supplies every label (table rows, labels shared with another question)
+ *
+ * Instructions may be Handlebars templates; {@link renderQuestion} fills them.
+ *
+ * @example
+ * ```ts ignore
+ * import graph from "./auto-graph.json" with { type: "json" };
+ * const QUESTIONS = judgeQuestions(graph);
+ * QUESTIONS.shading; // ChoiceQuestion<"shared" | "series" | "row">
+ * renderQuestion(QUESTIONS.order, { column: "latency" });
+ * ```
+ */
+import { prompt } from "@oh-my-pi/pi-utils";
+import type { ChoiceQuestion, NoulQuestion, Question, ScoreQuestion } from "./types.js";
+/** One question as a JSON question file writes it; {@link QuestionFor} gives its kind. */
+export interface QuestionSpec {
+    instructions: string;
+    criteria?: string[] | {
+        readonly [label: string]: string | null;
+    };
+}
+/** A JSON question file: {@link QuestionSpec}s keyed by question id. */
+export interface QuestionFile {
+    readonly [id: string]: QuestionSpec;
+}
+/** The question a {@link QuestionSpec} declares, with choice labels taken from its criteria keys. */
+export type QuestionFor<S extends QuestionSpec> = S extends {
+    criteria: string[];
+} ? ScoreQuestion : S extends {
+    criteria: infer C extends object;
+} ? [keyof C] extends [never] ? ChoiceQuestion : [keyof C] extends ["true" | "false"] ? NoulQuestion : ChoiceQuestion<Extract<keyof C, string>> : NoulQuestion;
+/** Every question a {@link QuestionFile} declares, keyed as in the file. */
+export type QuestionsFor<F extends QuestionFile> = {
+    [K in keyof F]: QuestionFor<F[K]>;
+};
+/**
+ * The typed questions of a JSON question file; answers to them come back typed
+ * through {@link JudgmentResult}.
+ * @throws when a score question lists fewer than two levels.
+ */
+export declare function judgeQuestions<F extends QuestionFile>(file: F): QuestionsFor<F>;
+/** `question` with its instructions rendered as a Handlebars template over `context`. */
+export declare function renderQuestion<Q extends Question>(question: Q, context: prompt.TemplateContext): Q;

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

@@ -94,6 +94,13 @@ export interface AnthropicMessagesClientLike {
             create(params: MessageCreateParams, options?: AnthropicRequestOptions): unknown;
         };
     };
+    /**
+     * Endpoint the client targets, when it exposes one. SDK-style clients
+     * (`Anthropic`, `AnthropicVertex`) and {@link AnthropicMessagesClient}
+     * publish it; a client that exposes none keeps its transport opaque, and the
+     * provider must not assume the model's own routing on its behalf.
+     */
+    baseURL?: string;
 }
 export declare class AnthropicMessagesClient implements AnthropicMessagesClientLike {
     #private;
@@ -101,12 +108,15 @@ export declare class AnthropicMessagesClient implements AnthropicMessagesClientL
     readonly beta: {
         readonly messages: AnthropicMessages;
     };
+    /** Endpoint shared with the HTTP transport. */
+    get baseURL(): string;
     constructor(options: AnthropicClientOptions);
     request(path: string, params: MessageCreateParams, options?: AnthropicRequestOptions): AnthropicApiRequest;
 }
 /** Shared Anthropic HTTP transport for Messages and resource APIs. */
 export declare class AnthropicHttpClient {
     #private;
+    readonly baseURL: string;
     constructor(options: AnthropicClientOptions);
     request(method: "GET" | "POST", path: string, params?: unknown, options?: AnthropicRequestOptions): Promise<Response>;
 }

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

@@ -1,6 +1,8 @@
 import type { Api, Model, ProviderSessionState } from "../types.js";
 /** Root key for Anthropic's per-session provider state. */
 export declare const ANTHROPIC_PROVIDER_SESSION_STATE_KEY = "anthropic-messages";
+/** Caller-map anchor for session-scoped opaque injected clients. */
+export declare const ANTHROPIC_OPAQUE_CLIENT_ANCHOR_KEY = "anthropic-opaque-clients";
 /** Normalize an Anthropic base URL to its origin path without `/v1`. */
 export declare function normalizeAnthropicBaseUrl(baseUrl?: string): string | undefined;
 /** Resolve the endpoint for a first-party Anthropic model without loading its provider implementation. */

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

@@ -135,6 +135,13 @@ export type AnthropicClientOptionsArgs = {
     thinkingEnabled?: boolean;
     thinkingDisplay?: AnthropicThinkingDisplay;
     disableStrictTools?: boolean;
+    /**
+     * Withhold the prompt-cache betas (see `buildClaudeCodeBetas`). Set when the
+     * request carries no breakpoint at all, and also when it carries breakpoints
+     * stripped of `ttl`/`scope`: both betas govern those options, so a body
+     * without them must advertise neither.
+     */
+    dropPromptCacheBetas?: boolean;
     fetch?: FetchImpl;
     maxRetryDelayMs?: number;
     sessionId?: string;
@@ -218,8 +225,17 @@ type SystemBlockOptions = {
     extraInstructions?: string[];
     /** Text of the first conversational wire user turn, used as the billing fingerprint seed. */
     firstUserMessageText?: string;
-    /** Cache lifetime shared by the OAuth system breakpoint and later message breakpoints. */
+    /**
+     * Cache lifetime shared by the OAuth system breakpoint and later message
+     * breakpoints. Omitted → the identity block keeps its default `ephemeral`
+     * breakpoint; see `dropCacheControl` to emit none at all.
+     */
     cacheControl?: AnthropicCacheControl;
+    /**
+     * Emit no `cache_control` on any block: the endpoint rejected the field.
+     * Distinct from an undefined `cacheControl`, which only means "default".
+     */
+    dropCacheControl?: boolean;
 };
 export declare function buildAnthropicSystemBlocks(systemPrompt: readonly string[] | undefined, options?: SystemBlockOptions): AnthropicSystemBlock[] | undefined;
 export declare function normalizeExtraBetas(betas?: string[] | string): string[];

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

@@ -145,6 +145,22 @@ export declare function pushBlockEndEvent(block: TextContent | ThinkingContent,
  * before invoking — this helper does not mutate `output.content`.
  */
 export declare function pushToolCallEvents(toolCall: ToolCall, contentIndex: number, output: AssistantMessage, stream: AssistantMessageEventStream): void;
+/** How {@link GoogleTextBlocks} keeps thought text: healed of leaked fence delimiters (#8719), or as received. */
+export type GoogleThoughtText = "healed" | "verbatim";
+/**
+ * Folds streamed generateContent text and thought parts into text and thinking
+ * blocks, opening a new block whenever the part kind changes. A part's
+ * `thoughtSignature` stays on the block it belongs to; the empty text part
+ * Gemini sends after a reply's last chunk signs the open block.
+ */
+export declare class GoogleTextBlocks {
+    #private;
+    constructor(output: AssistantMessage, stream: AssistantMessageEventStream, thoughtText: GoogleThoughtText);
+    /** Folds one response part; parts without text are ignored. */
+    push(part: Part): void;
+    /** Ends the open block, releasing thinking text the fence stripper held back. */
+    close(): void;
+}
 /**
  * Append a new text- or thinking-block to `output.content` and push the matching
  * `text_start` / `thinking_start` event. `onBeforeStartEvent` lets the SSE consumer
@@ -170,7 +186,7 @@ export declare function googleStreamChunkError(error: NonNullable<GenerateConten
  * pushing `start`/`done`/`error` events, and the surrounding try/catch that translates
  * thrown errors into `output.stopReason`/`errorMessage`.
  *
- * This helper handles: the chunk loop, currentBlock flush transitions, usage metadata
+ * This helper handles: the chunk loop, text/thinking blocks ({@link GoogleTextBlocks}), usage metadata
  * decoding (`calculateCost` included), tool-call id collision avoidance, finish-reason
  * mapping, and the abort/stop-reason post-checks that re-throw to bubble into the
  * caller's catch.
@@ -183,8 +199,6 @@ export declare function consumeGoogleStream<T extends GoogleApiType>(args: {
     options: {
         signal?: AbortSignal;
     } | undefined;
-    /** Vertex preserves `textSignature` on streamed text deltas; google-generative-ai does not. */
-    retainTextSignature?: boolean;
     onFirstToken?: () => void;
 }): Promise<void>;
 /**
@@ -217,7 +231,6 @@ export declare function streamGoogleGenAI<T extends "google-generative-ai" | "go
     model: Model<T>;
     options: GoogleSharedStreamOptions | undefined;
     api: T;
-    retainTextSignature?: boolean;
     prepare: () => GoogleGenAIRequestPlan | Promise<GoogleGenAIRequestPlan>;
 }): AssistantMessageEventStream;
 /**

package/dist/types/providers/inference-headers.d.ts

@@ -7,6 +7,12 @@ export interface InferenceHeaderOptions {
 }
 /** Set a header unless the map already contains that field under any casing. */
 export declare function setHeaderIfAbsent(headers: Record<string, string>, name: string, value: string): void;
+/**
+ * Label a request with the conversation id under the model's resolved
+ * `compat.sessionHeader` (KDL `session-header`). A header the caller or config
+ * already set wins; without a conversation id nothing is sent.
+ */
+export declare function applySessionHeader(headers: Record<string, string> | Headers, compat: object | undefined, sessionId: string | undefined): void;
 /**
  * Project omp's identity and authoritative conversation id onto the headers
  * understood by the active inference protocol and host.

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

@@ -78,6 +78,8 @@ export interface RequestBody {
  * explicit option; normal inference defaults to the full Responses contract.
  */
 export declare function resolveCodexResponsesLite(requested: boolean | undefined): boolean;
+/** Wire tier of the model's lowest effort, which a `minimizeEffort` request runs at. */
+export declare function lowestCodexWireEffort(model: Model<"openai-codex-responses">): ReasoningConfig["effort"] | undefined;
 /**
  * Repair both halves of unpaired tool exchanges so the Responses input grammar
  * stays valid — the API rejects either orphan with a 400:

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

@@ -148,7 +148,7 @@ export declare function buildTransformedCodexRequestBody(model: Model<"openai-co
  */
 export declare function openCodexCompactionEventStream(model: Model<"openai-codex-responses">, body: OpenAICodexCompactionBody, options: OpenAICodexCompactionStreamOptions): Promise<AsyncGenerator<Record<string, unknown>>>;
 export declare const streamOpenAICodexResponses: StreamFunction<"openai-codex-responses">;
-export declare function prewarmOpenAICodexResponses(model: Model<"openai-codex-responses">, options?: Pick<OpenAICodexResponsesOptions, "apiKey" | "headers" | "sessionId" | "signal" | "preferWebsockets" | "providerSessionState" | "responsesLite">): Promise<void>;
+export declare function prewarmOpenAICodexResponses(model: Model<"openai-codex-responses">, options?: Pick<OpenAICodexResponsesOptions, "apiKey" | "headers" | "sessionId" | "signal" | "preferWebsockets" | "providerSessionState" | "responsesLite" | "serviceTier">): Promise<void>;
 export interface OpenAICodexTransportDetails {
     websocketPreferred: boolean;
     lastTransport?: CodexTransport;

package/dist/types/providers/openai-configuration-update.d.ts

@@ -1,6 +1,6 @@
 /**
  * Mid-conversation reasoning effort via `configuration_update` input items
- * (GPT-6 Astra; `model.compat.supportsConfigurationUpdate`).
+ * (GPT-6 family; `model.compat.supportsConfigurationUpdate`).
  *
  * The request-level `reasoning.effort` is pinned to the value of the session's
  * first request so the cached prompt prefix survives an effort change. Each
@@ -12,10 +12,12 @@
  * planning.
  *
  * Used by both the platform Responses provider and the Codex provider; the
- * state lives in each provider's session state, keyed per conversation.
+ * state lives in each provider's session state, keyed per conversation. A side
+ * request plans against a copy of its parent conversation's state (see
+ * {@link resolveOpenAIEffortControlState}), so it sends the parent's prefix.
  *
- * Wire constraints (verified against the Codex backend): only `gpt-6-astra`
- * accepts the item type, consecutive updates are rejected, and
+ * Wire constraints (OpenAI reasoning guide): the GPT-6 family supports the item
+ * in standard (not `pro`) reasoning mode, adjacent updates are rejected, and
  * `/responses/compact` rejects histories containing them — compaction
  * requests are built outside this planner and never carry the items.
  */
@@ -42,10 +44,12 @@ export interface OpenAIEffortControlState<TEffort extends string = string> {
 }
 export declare function createOpenAIEffortControlState<TEffort extends string>(sessionId: string): OpenAIEffortControlState<TEffort>;
 /**
- * Fetch (or create) the control state for one conversation from a provider's
- * bounded per-session map, refreshing its LRU slot.
+ * Control state a Responses or Codex request plans against. A side request
+ * (`parentSessionId`) gets a throwaway copy of its parent's state, fresh when
+ * the parent has none: it replays the parent's updates, and its own effort
+ * change never reaches the parent. Other requests get their session's state.
  */
-export declare function getOpenAIEffortControlState<TEffort extends string>(states: Map<string, OpenAIEffortControlState<TEffort>>, key: string, sessionId: string): OpenAIEffortControlState<TEffort>;
+export declare function resolveOpenAIEffortControlState<TEffort extends string>(states: Map<string, OpenAIEffortControlState<TEffort>>, keyOf: (sessionId: string) => string, sessionId: string, parentSessionId: string | undefined): OpenAIEffortControlState<TEffort>;
 /** Release one conversation's effort state from the Responses and Codex `releaseSession` implementations. */
 export declare function releaseOpenAIEffortControlSession<TEffort extends string>(states: Map<string, OpenAIEffortControlState<TEffort>>, sessionId: string): void;
 interface AnchorableItem {
@@ -60,8 +64,10 @@ interface AnchorableItem {
  *
  * `input` is the freshly built transcript for this request, without any
  * `configuration_update` items. `requested` is the wire effort the caller
- * would otherwise send at the request level. Returns the effort to send at the
- * request level (`requested` on the first request, the baseline afterwards).
+ * would otherwise send at the request level. `minimized` replaces it once a
+ * baseline exists, where the change rides an update and keeps the cached
+ * prefix; a request that sets the baseline runs at `requested`. Returns the
+ * effort to send at the request level (the baseline).
  */
-export declare function planStableOpenAIEffort<TItem extends AnchorableItem, TEffort extends string>(state: OpenAIEffortControlState<TEffort>, input: Array<TItem | ConfigurationUpdateItem>, requested: TEffort): TEffort;
+export declare function planStableOpenAIEffort<TItem extends AnchorableItem, TEffort extends string>(state: OpenAIEffortControlState<TEffort>, input: Array<TItem | ConfigurationUpdateItem>, requested: TEffort, minimized?: TEffort): TEffort;
 export {};

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

@@ -3452,7 +3452,7 @@ export declare namespace ResponseInputItem {
     }
     /**
      * Changes reasoning effort for subsequent responses without touching the
-     * request-level `reasoning.effort` (GPT-6 Astra). Must not be adjacent to
+     * request-level `reasoning.effort` (GPT-6 family). Must not be adjacent to
      * another `configuration_update`.
      */
     interface ConfigurationUpdate {