@oh-my-pi/pi-ai 18.4.3 → 18.4.5

package/CHANGELOG.md

@@ -2,6 +2,41 @@
 
 ## [Unreleased]
 
+## [18.4.5] - 2026-09-30
+
+### Added
+
+- Added Factory Droid OAuth, HTTP streaming across Anthropic, OpenAI and Gemini protocols, and pool-aware usage reporting ([#8577](https://github.com/can1357/oh-my-pi/pull/8577) by [@will-bogusz](https://github.com/will-bogusz), continued in [#13276](https://github.com/can1357/oh-my-pi/pull/13276) by [@DusKing1](https://github.com/DusKing1)).
+- `AuthStorage.keys.setConfig(provider, value, { fallback: true })` registers a key that is used only when no stored OAuth or `/login` credential exists, instead of overriding them; `removeConfig`/`clearConfig` also clear these fallbacks ([#13815](https://github.com/can1357/oh-my-pi/pull/13815) by [@H4vC](https://github.com/H4vC))
+- Cursor turns now fall back to Cursor's HTTP/1 streaming transport when HTTP/2 is unavailable, surface Cursor's structured service errors, and resume from the last safe server checkpoint after a dropped stream ([#11613](https://github.com/can1357/oh-my-pi/pull/11613) by [@will-bogusz](https://github.com/will-bogusz)).
+
+### Fixed
+
+- Auth gateway checks for configured bearer tokens in URLs or forwarded/logged headers only after authentication; unauthorized requests use socket peers and redact unknown paths. Authenticated requests with misplaced tokens are rejected before provider dispatch ([#13827](https://github.com/can1357/oh-my-pi/pull/13827) by [@shawnkoh](https://github.com/shawnkoh)).
+- Codex sessions no longer keep spending an account's credits after its plan limit is reached while another logged-in account still has plan usage left; new and ongoing sessions switch to that account, and credits are used only when no account has plan usage left ([#13889](https://github.com/can1357/oh-my-pi/issues/13889)).
+- Runtime usage providers (`usage.setProvider`, extension `registerProvider({ usage })`) now key cached reports by their own `cacheVersion`, so reports written by processes without the override are no longer served to it ([#13814](https://github.com/can1357/oh-my-pi/issues/13814)).
+- xAI OAuth accounts with active weekly credits no longer switch away solely because an uncertain monthly counter exceeds its limit ([#13806](https://github.com/can1357/oh-my-pi/issues/13806)).
+- Cursor retries after a rejected conversation now keep the tool calls and results already completed in the turn, instead of re-sending the last message and redoing that work ([#11613](https://github.com/can1357/oh-my-pi/pull/11613) by [@will-bogusz](https://github.com/will-bogusz)).
+
+## [18.4.4] - 2026-09-29
+
+### Added
+
+- Added the `ultrafast` service tier. It is sent to the OpenAI API as-is, and to Codex only for models that list it in their discovered service tiers; other providers never receive it. On Codex websockets, switching into or out of `ultrafast` starts a new response chain instead of reusing `previous_response_id`, matching the Codex CLI. Ultrafast turns are costed at standard rates because no Ultrafast price is published yet ([#13782](https://github.com/can1357/oh-my-pi/pull/13782) by [@H4vC](https://github.com/H4vC)).
+
+### Changed
+
+- Changed to fall back to adaptive thinking when between_tools is used with xhigh effort
+- xAI requests (`xai`, `xai-oauth` chat and image generation) honor `XAI_BASE_URL` again when the model uses the bundled `https://api.x.ai/v1` endpoint; a custom `baseUrl` from models.yml still wins, and `xai-oauth` OAuth access tokens always stay on the bundled endpoint.
+
+### Fixed
+
+- Fixed Claude on Amazon Bedrock's Anthropic Messages routes (`/anthropic` on bedrock-runtime and bedrock-mantle): runtime requests no longer fail with a request-metadata 400, and both routes use Anthropic's on-demand compaction ([#13311](https://github.com/can1357/oh-my-pi/pull/13311) by [@mustafaabidali](https://github.com/mustafaabidali)).
+- `/usage` no longer shows an always-empty `gpt-4 requests` row for Cursor accounts on usage-based plans; the Cursor Models and Other Models meters remain ([#13726](https://github.com/can1357/oh-my-pi/pull/13726) by [@will-bogusz](https://github.com/will-bogusz)).
+- Cursor turns routed through an HTTP proxy now finish instead of hanging after the response completes ([#13724](https://github.com/can1357/oh-my-pi/pull/13724) by [@will-bogusz](https://github.com/will-bogusz)).
+- Fixed Codex requests sending `priority` (and `scale`) to models whose discovered service tiers list other tiers but not that one, matching the Codex CLI; an empty or missing list is treated as not reported, so `priority` is still sent and `/fast` keeps working on accounts whose `/models` lists no tiers (`flex` is always allowed) ([#13782](https://github.com/can1357/oh-my-pi/pull/13782) by [@H4vC](https://github.com/H4vC)).
+- Fixed Codex priority cost: a turn the backend reports as served at `default` is no longer billed at the priority multiplier ([#13782](https://github.com/can1357/oh-my-pi/pull/13782) by [@H4vC](https://github.com/H4vC)).
+
 ## [18.4.3] - 2026-09-28
 
 ### Added
@@ -2275,45 +2310,4 @@
 
 - Added the optional `ToolResultMessage.useless` flag: tools can declare a finished result contextually useless (zero matches, elapsed wait) so compaction passes may elide it once consumed. Never serialized to provider wire formats and never set together with `isError`.
 
-## [15.12.0] - 2026-06-12
-
-### Fixed
-
-- Fixed Anthropic requests bypassing lone-surrogate sanitization after payload hooks or Anthropic-origin tool-call replay: the model itself can emit unpaired surrogate escapes in its own tool-argument JSON (streamed out fine, then rejected with `400 The request body is not valid JSON` on every subsequent request, bricking the session). The final Anthropic payload is now deep-sanitized with `toWellFormed()` immediately before SDK serialization; the pass is identity-preserving, so well-formed arguments stay byte-identical and prompt-cache prefixes are unaffected.
-
-## [15.11.8] - 2026-06-12
-
-### Breaking Changes
-
-- Removed the Codex SSE stateful transport path, so SSE turns no longer send `previous_response_id` with delta input and now always send the full transcript
-
-### Changed
-
-- Scoped `x-codex-turn-state` handling to within-turn continuations so only tool-loop follow-ups include the turn-state header and new user turns start without it
-
-### Removed
-
-- Removed the `statefulResponses` option from `OpenAICodexResponsesOptions`, and SSE stateful mode is no longer controlled by the `PI_CODEX_STATEFUL`-style flag
-
-### Fixed
-
-- Fixed the platform OpenAI Responses and Codex websocket stale-chain classifiers missing the "Unsupported parameter: previous_response_id" rejection phrasing (FastAPI-style `detail` body with no `error.code`), so a chained turn now falls back to a full-transcript replay instead of surfacing the 400
-- Fixed the HTTP-400 raw-request dump for Codex SSE to record the body actually sent on the wire instead of the pre-transport request body, which made chained-request failures look like the rejected parameter was never sent
-
-## [15.11.7] - 2026-06-12
-
-### Added
-
-- Added `requestModelId` and `thinking.suppress` options to `google-gemini-cli` so collapsed effort-tier variants serialize their per-effort upstream wire id, and thinking-off requests on models with `thinking.suppressWhenOff` send an explicit `thinkingConfig` (`includeThoughts: false` with `thinkingLevel: "MINIMAL"` or `thinkingBudget: 0`) — Cloud Code Assist re-applies the per-id baked server default when the config is omitted, silently thinking and billing the tokens
-- Added mandatory-reasoning clamping: models baked with `thinking.requiresEffort` floor omitted or disabled reasoning to the lowest supported effort in every api mapping, and `disableReasoning` no longer emits OpenRouter `reasoning: { enabled: false }` for them — fixes `omp bench` and utility requests 400ing with "Reasoning is mandatory for this endpoint and cannot be disabled" on OpenRouter Gemini 3.x
-
-### Changed
-
-- Changed `google-gemini-cli` request mapping to route per-request wire ids via `resolveWireModelId`: the session effort picks the backing variant id (collapsed `gemini-3.5-flash` at high → `gemini-3.5-flash-low`; claude pairs route off → bare id, efforts → `-thinking`) while `AssistantMessage.model` and usage attribution stay on the logical id. A thinking budget clamped to zero now falls through to the thinking-off path (off routing plus suppression) instead of only disabling thinking
-- Changed `openai-completions` and `anthropic-messages` to serialize per-request wire ids via `resolveWireModelId`, so collapsed `X`/`X-thinking` pairs on aggregators and custom providers switch to the thinking SKU when reasoning is enabled (previously only `google-gemini-cli` routed effort-tier variants)
-
-### Fixed
-
-- Fixed `google-gemini-cli` ignoring `Model.requestModelId` when serializing the request model id
-
-Older entries are archived in [packages/ai/CHANGELOG.md@689a3418cb45](https://github.com/can1357/oh-my-pi/blob/689a3418cb45d54a459cde2e1abf3f66f50e47a4/packages/ai/CHANGELOG.md).
+Older entries are archived in [packages\ai\CHANGELOG.md@cd762117522c](https://github.com/can1357/oh-my-pi/blob/cd762117522cc4122cd45b8d2d14de5f7be5133b/packages\ai\CHANGELOG.md).

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

@@ -2,7 +2,7 @@ import { type ApiKeyResolver, type ResolvedApiKey } from "../auth-retry.js";
 import type { SessionAffinity } from "./affinity.js";
 import type { CredentialPool } from "./pool.js";
 import type { CredentialSelector } from "./select.js";
-import type { AuthApiKeyOptions, AuthCredential, AuthSource, AuthSourceOptions, KeysApi, LimitsApi } from "./types.js";
+import type { AuthApiKeyOptions, AuthCredential, AuthSource, AuthSourceOptions, KeysApi, LimitsApi, OAuthRequestIdentity } from "./types.js";
 /** Runtime (--api-key) and config (models.yml) key overrides plus the config-value resolver. */
 export declare class KeyOverrides {
     #private;
@@ -10,6 +10,8 @@ export declare class KeyOverrides {
     has(provider: string): boolean;
     runtimeKey(provider: string): string | undefined;
     configKey(provider: string): string | undefined;
+    /** Config value consulted only after stored OAuth/login credentials. */
+    fallbackKey(provider: string): string | undefined;
     /** Resolve a config value (env var name, "!command", literal) to the secret. */
     resolve(config: string): Promise<string | undefined>;
     /**
@@ -30,10 +32,17 @@ export declare class KeyOverrides {
      *
      * Lower priority than {@link KeyOverrides.setRuntime} so a CLI `--api-key`
      * still wins for the duration of a single invocation.
+     *
+     * `fallback: true` instead ranks the value below stored OAuth and `/login`
+     * credentials (at the env-var tier). Providers that own a `/login` flow use
+     * this so their default key reference (e.g. an unset env-var name, which
+     * resolves to its literal text) cannot shadow the key the user logged in with.
      */
-    setConfig(provider: string, apiKeyConfig: string): void;
+    setConfig(provider: string, apiKeyConfig: string, options?: {
+        fallback?: boolean;
+    }): void;
     /**
-     * Remove a single config-sourced API key override.
+     * Remove a single config-sourced API key (override or fallback).
      */
     removeConfig(provider: string): void;
     /**
@@ -85,7 +94,7 @@ export declare class KeyCascade implements KeysApi {
     /**
      * Classify where a provider's auth comes from, following the same precedence
      * as {@link KeyCascade.get}: runtime override → config override →
-     * stored OAuth → login-stored api_key → env var → stored api_key.
+     * stored OAuth → login-stored api_key → config fallback → env var → stored api_key.
      * Returns undefined when no auth is configured.
      *
      * Compact, structured counterpart to {@link KeyCascade.describe}; `env`
@@ -107,7 +116,7 @@ export declare class KeyCascade implements KeysApi {
      * Priority (first match wins): runtime override, config override, OAuth,
      * login API key, environment variable, then another stored API key.
      */
-    get(provider: string, sessionId?: string, options?: AuthApiKeyOptions, onCredentialId?: (id: number) => void): Promise<string | undefined>;
+    get(provider: string, sessionId?: string, options?: AuthApiKeyOptions, onCredentialId?: (id: number, identity?: OAuthRequestIdentity) => void): Promise<string | undefined>;
     /**
      * Build an {@link ApiKeyResolver} backed by this storage, implementing the
      * central a/b/c auth-retry policy:
@@ -140,7 +149,9 @@ export declare class KeyCascade implements KeysApi {
     describe(provider: string, sessionId?: string): string | undefined;
     setRuntime(provider: string, apiKey: string): void;
     removeRuntime(provider: string): void;
-    setConfig(provider: string, apiKeyConfig: string): void;
+    setConfig(provider: string, apiKeyConfig: string, options?: {
+        fallback?: boolean;
+    }): void;
     removeConfig(provider: string): void;
     clearConfig(): void;
     setResolver(resolver: (config: string) => Promise<string | undefined>): void;

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

@@ -18,6 +18,11 @@ export type UsageCandidate<T extends AuthCredential> = {
     inReserve?: boolean;
     /** True only when reserve ranking had a usable remaining-fraction measurement. */
     reserveMeasured?: boolean;
+    /**
+     * Present after ranking: the account's renewable allowance for this request is
+     * spent, so if it still serves it draws on paid overage such as Codex credits.
+     */
+    allowanceSpent?: boolean;
 };
 /** OAuth credential eligible for usage ranking. */
 export type OAuthCandidate = UsageCandidate<OAuthCredential>;
@@ -35,6 +40,7 @@ export type UsageRankedCandidate<T extends AuthCredential> = UsageCandidate<T> &
     reserveMeasured?: boolean;
     accountPriority: number;
     hasPriorityBoost: boolean;
+    allowanceSpent: boolean;
     usageMeasured: boolean;
     planPriority: number;
     secondaryUsed: number;
@@ -49,5 +55,5 @@ export type RankedOAuthCandidate = UsageRankedCandidate<OAuthCredential>;
 export type RankedApiKeyCandidate = UsageRankedCandidate<ApiKeyCredential>;
 /** Rank accounts by model-plan eligibility when a plan gate applies. */
 export declare function planPriority(gate: PlanGate | undefined, report: UsageReport | null): number;
-/** Sort ranked candidates by blocks, plan, reserve, boost, hot window, usage and drain. */
+/** Sort ranked candidates by blocks, plan, spent allowance, reserve, boost, hot window, usage and drain. */
 export declare function orderUsageRankedCandidates<T extends AuthCredential>(candidates: UsageRankedCandidate<T>[], planGated: boolean): UsageCandidate<T>[];

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

@@ -17,6 +17,13 @@ import { type AuthCredentialSnapshotEntry, type AuthStorageOptions, type OAuthCr
  * the rotation cadence by <4%.
  */
 export declare const OAUTH_REFRESH_SKEW_MS = 60000;
+type OrganizationScope = Pick<OAuthCredentials, "orgId" | "region" | "inferenceRegion" | "activeOrganizationId" | "orgName">;
+/**
+ * Organization-scoped identity after a refresh: refreshed values win; stored
+ * org/residency/inference scope carries over only while the organization is
+ * unchanged. The WorkOS selection always falls back to the stored one.
+ */
+export declare function mergeRefreshedOrganizationScope(current: OrganizationScope, refreshed: OrganizationScope): OrganizationScope;
 /** Merge provider refresh bytes with the stored OAuth row, preserving subtype metadata for every refresh path. */
 export declare function mergeRefreshedCredential<T extends OAuthCredential>(current: T, refreshed: OAuthCredentials): T;
 /** Dependencies for lease-guarded OAuth refresh. */
@@ -57,3 +64,4 @@ export declare class OAuthRefresher {
      */
     refreshById(id: number, signal?: AbortSignal, options?: OAuthRefreshByIdOptions): Promise<AuthCredentialSnapshotEntry>;
 }
+export {};

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

@@ -180,6 +180,9 @@ export type CompletionProbeCredential = {
     email?: string;
     enterpriseUrl?: string;
     apiEndpoint?: string;
+    orgId?: string;
+    region?: string;
+    inferenceRegion?: "global" | "eu" | "us";
 };
 /**
  * Caller-supplied bearer probe. Receives the post-refresh credential for a
@@ -422,6 +425,12 @@ export type AuthApiKeyOptions = {
     /** Explicit provider-401 recovery; generic force refreshes leave this unset. */
     refreshReason?: OAuthRefreshReason;
 };
+/** Non-secret identity bound to the OAuth credential selected for one request attempt. */
+export interface OAuthRequestIdentity {
+    orgId?: string;
+    region?: string;
+    inferenceRegion?: "global" | "eu" | "us";
+}
 /**
  * Refreshed OAuth access plus identity metadata returned by
  * {@link AuthStorage.oauth.access}. Callers that authenticate via a bearer
@@ -441,6 +450,8 @@ export interface OAuthAccess {
     /** Organization/workspace the credential is scoped to (Anthropic/ChatGPT multi-subscription). */
     orgId?: string;
     orgName?: string;
+    region?: string;
+    inferenceRegion?: "global" | "eu" | "us";
 }
 /**
  * Identity slice of the credential a successful {@link AuthStorage.oauth.login}
@@ -848,10 +859,16 @@ export interface KeysApi {
      *
      * Lower priority than {@link setRuntimeApiKey} so a CLI `--api-key`
      * still wins for the duration of a single invocation.
+     *
+     * `fallback: true` ranks the value below stored OAuth and `/login`
+     * credentials instead, so a provider's default key reference cannot shadow
+     * a key the user logged in with.
      */
-    setConfig(provider: string, apiKeyConfig: string): void;
+    setConfig(provider: string, apiKeyConfig: string, options?: {
+        fallback?: boolean;
+    }): void;
     /**
-     * Remove a single config-sourced API key override.
+     * Remove a single config-sourced API key (override or fallback).
      */
     removeConfig(provider: string): void;
     /**

package/dist/types/auth-broker/protocol.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Auth-broker wire-protocol helpers shared by the server and the client store.
+ */
+import type { CredentialBlockSnapshot } from "./types.js";
+/** Parse a snapshot `ETag` / `If-None-Match` value (`"N"`, `W/"N"`, or bare `N`) into a generation. */
+export declare function parseGenerationTag(header: string | null): number | undefined;
+/**
+ * Canonical order for a credential's block snapshots. The server and the client
+ * store both sort with it, because block lists are compared positionally; the
+ * `updatedAtMs` tiebreak keeps otherwise-identical blocks in one stable order.
+ */
+export declare function compareCredentialBlockSnapshots(a: CredentialBlockSnapshot, b: CredentialBlockSnapshot): number;

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

@@ -1,4 +1,4 @@
-import type { ApiKeyResolver } from "../auth-retry.js";
+import type { ApiKeyResolver, ResolvedApiKey } from "../auth-retry.js";
 import type { AuthStorage } from "../auth-storage.js";
 import { type GatewayErrorClassification } from "../error/gateway.js";
 import type { Api, FetchImpl, Model, Usage } from "../types.js";
@@ -42,12 +42,12 @@ export declare function resolveGatewayAccount(storage: AuthStorage, provider: st
  * Resolve the credential for one request from broker-backed storage.
  *
  * pi-ai clients never consult `AuthStorage`; the gateway resolves the bearer
- * (an OAuth access token refreshed through the broker when needed) and hands
- * it to the client. Returns the key, or the error classification the route
- * should encode in its own envelope: storage failures map through
- * {@link classifyGatewayError}, a provider without any credential is a 401.
+ * and its OAuth identity together (refreshing through the broker when needed).
+ * Keep this selection snapshot intact even if another request replaces the
+ * stored token before dispatch. Storage failures map through
+ * {@link classifyGatewayError}; a provider without any credential is a 401.
  */
-export declare function resolveGatewayApiKey(storage: AuthStorage, model: Model<Api>, sessionId: string, signal: AbortSignal, peer: string): Promise<string | GatewayErrorClassification>;
+export declare function resolveGatewayApiKey(storage: AuthStorage, model: Model<Api>, sessionId: string, signal: AbortSignal, peer: string): Promise<ResolvedApiKey | GatewayErrorClassification>;
 /**
  * Build the {@link ApiKeyResolver} handed to a pi-ai client for a gateway
  * request. Drives the central a/b/c auth-retry policy server-side:
@@ -63,7 +63,7 @@ export declare function resolveGatewayApiKey(storage: AuthStorage, model: Model<
  * routes that retain provider session state use it to re-key the account
  * lease, one-shot routes pass `undefined`.
  */
-export declare function buildGatewayApiKeyResolver(storage: AuthStorage, model: Model<Api>, sessionId: string, initialKey: string, requestSignal: AbortSignal, format: string, peer: string, onResolvedKey?: (apiKey: string) => void): ApiKeyResolver;
+export declare function buildGatewayApiKeyResolver(storage: AuthStorage, model: Model<Api>, sessionId: string, initialKey: ResolvedApiKey, requestSignal: AbortSignal, format: string, peer: string, onResolvedKey?: (apiKey: string) => void): ApiKeyResolver;
 /**
  * Attribute one settled upstream request to the originating client via the
  * broker's observed-usage channel (`AuthStorage.usage.observe`, batched

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

@@ -16,7 +16,10 @@ export declare function gatewayResponseHeaders(model: Model<Api>, info: {
     costUsd?: number;
     startedAt?: number;
 }): Record<string, string>;
-export declare function resolvePeer(req: Request): string;
+/** Use the socket peer unless the gateway explicitly trusts its reverse proxy. */
+export declare function resolvePeer(req: Request, socketAddress: string, trustProxyHeaders?: boolean): string;
+/** Keep configured gateway credentials out of URL and forwarded/logged request fields. */
+export declare function hasMisplacedBearer(req: Request, url: URL, tokens: ReadonlySet<string>): boolean;
 /**
  * Constant-time byte comparison. Falls back to a manual XOR accumulator if
  * `node:crypto.timingSafeEqual` isn't available. Always processes every byte

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

@@ -125,6 +125,8 @@ export interface AuthGatewayServerOptions {
     bind?: string;
     /** Accept any of these bearer tokens. Empty allows unauthenticated calls. */
     bearerTokens: string[];
+    /** Honor forwarded peer headers only when the connecting proxy is trusted. Default false. */
+    trustProxyHeaders?: boolean;
     /** Version surfaced on `/healthz`. */
     version?: string;
 }

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

@@ -1,4 +1,4 @@
-import type { LimitsApi, OAuthAccess, OAuthApi } from "./auth/types.js";
+import type { LimitsApi, OAuthAccess, OAuthApi, OAuthRequestIdentity } from "./auth/types.js";
 import { isAuthRetryableError } from "./error/auth-classify.js";
 /**
  * Context passed to an {@link ApiKeyResolver} on each resolution attempt.
@@ -42,6 +42,8 @@ export interface ResolvedApiKey {
      * already sent it before that block.
      */
     afterSiblingWait?: boolean;
+    /** Non-secret request scope belonging to this bearer, replaced on account rotation. */
+    oauthIdentity?: OAuthRequestIdentity;
 }
 export type ApiKeyResolution = string | ResolvedApiKey | undefined;
 export type ApiKeyResolver = (ctx: ApiKeyResolveContext) => Promise<ApiKeyResolution> | ApiKeyResolution;

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

@@ -1,4 +1,5 @@
 import type { AssistantMessage, Message, ToolCall } from "../types.js";
+import { type ToolArgShape } from "./coercion.js";
 import type { DialectRenderOptions, DialectToolResult } from "./types.js";
 export declare function renderToolResponseResults(results: readonly DialectToolResult[]): string;
 export declare function kimiCallId(name: string, id: string, index: number): string;
@@ -15,6 +16,9 @@ export declare function pyCall(name: string, args: Record<string, unknown>): str
 export declare function pyValue(value: unknown): string;
 export declare function escapeXmlAttr(value: string): string;
 export declare function escapeXmlText(value: string): string;
+/** Render one Anthropic-style `<invoke>`; declared string args stay raw, everything else is JSON. */
+export declare function renderInvoke(call: ToolCall, shape: ToolArgShape | undefined): string;
+export declare function renderInvokes(calls: readonly ToolCall[], tools: NonNullable<DialectRenderOptions["tools"]>): string;
 export type AssistantTranscriptParts = {
     readonly text: string;
     readonly thinking: string;

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

@@ -10,9 +10,11 @@ export declare function usageFromWire(value: unknown): Usage;
 export declare function imageBaseUrl(model: Model): string;
 export declare function modelHeaders(model: Model, signal?: AbortSignal): Promise<Record<string, string>>;
 export declare function errorMessage(rawText: string): string;
+/** Request URL, or a builder for routes that depend on the bearer (xAI's `XAI_BASE_URL` rule). */
+type ImageRequestUrl = string | ((bearer: string) => string);
 export declare function postJson(options: {
     model: Model;
-    url: string;
+    url: ImageRequestUrl;
     body: unknown;
     apiKey: ApiKey;
     fetch: FetchImpl;
@@ -20,7 +22,7 @@ export declare function postJson(options: {
 }): Promise<unknown>;
 export declare function postMultipart(options: {
     model: Model;
-    url: string;
+    url: ImageRequestUrl;
     body: FormData;
     apiKey: ApiKey;
     fetch: FetchImpl;
@@ -32,3 +34,4 @@ export declare function decodeImageResponse(value: unknown, fetch: FetchImpl, si
 }>;
 export declare function toDataUrl(image: GeneratedImage): string;
 export declare function resolveOpenAIImageSize(aspectRatio?: string, imageSize?: string): string | undefined;
+export {};

package/dist/types/index.d.ts

@@ -45,6 +45,7 @@ export * from "./usage.js";
 export * from "./usage/claude.js";
 export * from "./usage/claude-reset.js";
 export * from "./usage/cursor.js";
+export * from "./usage/factory-droid.js";
 export * from "./usage/gemini.js";
 export * from "./usage/github-copilot.js";
 export * from "./usage/google-antigravity.js";

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

@@ -225,7 +225,15 @@ export type ThinkingConfigAdaptive = {
     /** Preserved-thinking prefix mismatch policy. */
     block_binding?: ThinkingBlockBinding;
 };
-export type ThinkingConfigParam = ThinkingConfigEnabled | ThinkingConfigDisabled | ThinkingConfigAdaptive;
+/**
+ * Sonnet 5.5's replacement for `disabled`: no up-front thinking, progress
+ * updates between tool calls only. Takes no other field, and effort above
+ * `high` is rejected alongside it.
+ */
+export type ThinkingConfigBetweenTools = {
+    type: "between_tools";
+};
+export type ThinkingConfigParam = ThinkingConfigEnabled | ThinkingConfigDisabled | ThinkingConfigAdaptive | ThinkingConfigBetweenTools;
 export type OutputConfig = {
     /** Adaptive-thinking effort level (effort beta). */
     effort?: "low" | "medium" | "high" | "xhigh" | "max" | null;

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

@@ -217,6 +217,30 @@ type SystemBlockOptions = {
 export declare function buildAnthropicSystemBlocks(systemPrompt: readonly string[] | undefined, options?: SystemBlockOptions): AnthropicSystemBlock[] | undefined;
 export declare function normalizeExtraBetas(betas?: string[] | string): string[];
 export declare function buildAnthropicClientOptions(args: AnthropicClientOptionsArgs): AnthropicClientOptionsResult;
+/**
+ * True when enabled thinking on `model` is budget thinking
+ * (`thinking.type: "enabled"` with `budget_tokens`) rather than adaptive.
+ */
+export declare function usesBudgetThinking(model: Model<"anthropic-messages">): boolean;
+/** The most output tokens a request to `model` may ask for (`max_tokens` ceiling). */
+export declare function anthropicOutputLimit(model: Model<"anthropic-messages">): number;
+/**
+ * The `max_tokens` and thinking budget of budget thinking: `max_tokens`
+ * rises to leave {@link OUTPUT_FALLBACK_BUFFER} visible output tokens after
+ * the budget, within `maxAllowedTokens`, and the budget shrinks when that
+ * ceiling leaves less (a non-positive budget means the ceiling is too low).
+ */
+export declare function budgetThinkingOutput(maxTokens: number | undefined, budgetTokens: number, maxAllowedTokens: number): {
+    maxTokens: number;
+    budgetTokens: number;
+};
+/**
+ * Whether the conversation has stopped being thinking-led, so routes with
+ * `compat.stripThinkingHistory` drop the budget `thinking` config and replay
+ * history without thinking blocks. Exported so the factory-droid provider can
+ * gate its header-level interleaved beta on the same decision.
+ */
+export declare function shouldStripThinkingHistory(messages: readonly Message[]): boolean;
 /**
  * A single Anthropic conversation turn, including the mid-conversation
  * `system` role (Opus 4.8+ and Fable/Mythos 5).

package/dist/types/providers/aws-sigv4.d.ts

@@ -33,6 +33,11 @@ export interface SignParams {
     /** Override clock for deterministic tests. */
     date?: Date;
 }
+/** Coerce a possibly-ArrayBufferLike-backed `Uint8Array` into one over a fresh
+ * `ArrayBuffer`, which is what `crypto.subtle.{digest,sign,importKey}` requires
+ * under the strict TS DOM typings. No-op when already strict.
+ */
+export declare function asStrict(bytes: Uint8Array): Uint8Array<ArrayBuffer>;
 export declare function toHex(bytes: Uint8Array): string;
 export declare function sha256(data: Uint8Array | string): Promise<Uint8Array>;
 export declare function sha256Hex(data: Uint8Array | string): Promise<string>;

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

@@ -0,0 +1,9 @@
+/**
+ * Fit an Anthropic request body to Bedrock's Anthropic Messages API
+ * (`compat.bedrockMessagesApi`): both `/anthropic` routes reject the tool
+ * `strict` field, and bedrock-runtime rejects a `metadata.user_id` outside
+ * Bedrock's request-metadata pattern. A user id that fits is kept, otherwise
+ * its embedded session id, otherwise the metadata is dropped. Mutates and
+ * returns `payload`.
+ */
+export declare function fitBedrockAnthropicPayload<T>(payload: T): T;

package/dist/types/providers/bedrock-request-metadata.d.ts

@@ -0,0 +1,2 @@
+/** Check Bedrock's request-metadata character and length limits. Keys must also be nonempty. */
+export declare function isBedrockRequestMetadataValue(value: string): boolean;

package/dist/types/providers/cursor/interaction-query.d.ts

@@ -1,5 +1,16 @@
-import type http2 from "node:http2";
 import { type InteractionQuery } from "@oh-my-pi/pi-catalog/discovery/cursor-proto";
+type ProtoUnknownField = {
+    no: number;
+    wireType: number;
+    data: Uint8Array;
+};
+interface CursorInteractionWriter {
+    write(frame: Uint8Array): void;
+}
+/** Wrap one Connect-protocol message: 1 flag byte + 4-byte big-endian length + payload. */
+export declare function frameConnectMessage(data: Uint8Array, flags?: number): Buffer;
+/** Well-formed protobuf-es `$unknown` entries on `message`; anything else on the bag is ignored. */
+export declare function protoUnknownFields(message: object): ProtoUnknownField[];
 /**
  * Answer a Cursor `interaction_query` so the Run RPC can continue.
  *
@@ -12,4 +23,5 @@ import { type InteractionQuery } from "@oh-my-pi/pi-catalog/discovery/cursor-pro
  * Unsupported interactive queries are rejected so the server is not stranded.
  * VM setup is left unanswered rather than reporting a fake success.
  */
-export declare function handleInteractionQuery(query: InteractionQuery, h2Request: http2.ClientHttp2Stream): void;
+export declare function handleInteractionQuery(query: InteractionQuery, h2Request: CursorInteractionWriter): void;
+export {};

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

@@ -1,12 +1,12 @@
-import http2 from "node:http2";
 import type { CursorRule, McpToolDefinition } from "@oh-my-pi/pi-catalog/discovery/cursor-proto";
+import { CURSOR_CLIENT_VERSION } from "@oh-my-pi/pi-catalog/wire/cursor";
 import { type AgentServerMessage, type ConversationStateStructure } from "@oh-my-pi/pi-catalog/discovery/cursor-proto";
 import { type JsonValue } from "@oh-my-pi/pi-catalog/discovery/protobuf";
 import type { AssistantMessage, Context, CursorExecHandlerResult, CursorExecHandlers, CursorExecPairing, CursorTodoSyncHandler, CursorToolResultHandler, Message, Model, StreamFunction, StreamOptions, TextContent, ThinkingContent, Tool, ToolCall, ToolResultMessage } from "../types.js";
 import { kCursorExecResolved, kStreamingBlockIndex, kStreamingBlockKind, kStreamingEnvelopeId, kStreamingLastParseLen, kStreamingPartialJson } from "../utils/block-symbols.js";
 import { AssistantMessageEventStream } from "../utils/event-stream.js";
 export declare const CURSOR_API_URL = "https://api2.cursor.sh";
-export declare const CURSOR_CLIENT_VERSION = "cli-2026.07.23-e383d2b";
+export { CURSOR_CLIENT_VERSION };
 export interface CursorOptions extends StreamOptions {
     customSystemPrompt?: string;
     conversationId?: string;
@@ -16,28 +16,31 @@ export interface CursorOptions extends StreamOptions {
     externalToolExecutor?: boolean;
     /** Wire model id selected after thinking-effort routing (`resolveWireModelId`). */
     wireModelId?: string;
+    /** Run transport. `auto` starts with HTTP/2 and falls back on failed ALPN negotiation. */
+    transport?: "auto" | "http2" | "http1";
 }
 interface CursorRequestState {
     conversationId: string;
     blobStore: Map<string, Uint8Array>;
     conversationState?: ConversationStateStructure;
-    rotatedFresh?: boolean;
+    resume?: boolean;
 }
 interface CursorGrpcRequest {
     requestBytes: Uint8Array;
     blobStore: Map<string, Uint8Array>;
     conversationState: ConversationStateStructure;
 }
+interface CursorMessageWriter {
+    write(frame: Uint8Array): void;
+}
 /**
  * Maps an opaque HTTP/2 negotiation failure into an actionable error.
  *
- * bun only opens an HTTP/2 session when TLS-ALPN negotiates `h2`. Behind a
- * TLS-intercepting proxy that strips ALPN (e.g. Zscaler), the handshake yields
- * no `h2` protocol and bun throws `ERR_HTTP2_ERROR: h2 is not supported`. The
- * Cursor run RPC is HTTP/2-only (the ALB rejects HTTP/1.1 with 464), so there
- * is no h1 fallback the way model discovery has one — the run simply cannot
- * proceed. Replace the opaque message with one that names the cause and points
- * at the `providers.cursor.baseUrl` workaround.
+ * Bun only opens an HTTP/2 session when TLS-ALPN negotiates `h2`. Behind a
+ * TLS-intercepting proxy that strips ALPN, the handshake can fail with
+ * `ERR_HTTP2_ERROR: h2 is not supported`. Automatic transport retries the
+ * official RunSSE/BidiAppend HTTP/1 path; this mapped error remains observable
+ * when a caller explicitly forces HTTP/2.
  *
  * Non-ALPN errors pass through untouched.
  */
@@ -106,7 +109,7 @@ export interface UsageState {
     sawTokenDelta: boolean;
 }
 /** Exported for tests: drives one Cursor server message through the stream (exec waits mark the stream busy). */
-export declare function handleServerMessage(msg: AgentServerMessage, output: AssistantMessage, stream: AssistantMessageEventStream, state: BlockState, blobStore: Map<string, Uint8Array>, h2Request: http2.ClientHttp2Stream, execHandlers: CursorExecHandlers | undefined, onToolResult: CursorToolResultHandler | undefined, usageState: UsageState, requestContextTools: McpToolDefinition[], requestContextRules?: CursorRule[], onConversationCheckpoint?: (checkpoint: ConversationStateStructure) => void, externalToolExecutor?: boolean): Promise<void>;
+export declare function handleServerMessage(msg: AgentServerMessage, output: AssistantMessage, stream: AssistantMessageEventStream, state: BlockState, blobStore: Map<string, Uint8Array>, runTransport: CursorMessageWriter, execHandlers: CursorExecHandlers | undefined, onToolResult: CursorToolResultHandler | undefined, usageState: UsageState, requestContextTools: McpToolDefinition[], requestContextRules?: CursorRule[], onConversationCheckpoint?: (checkpoint: ConversationStateStructure) => void, externalToolExecutor?: boolean): Promise<void>;
 /**
  * Exported for tests: verifies handler is invoked with correct `this` when passed as bound.
  *
@@ -259,4 +262,3 @@ export declare function buildCursorHistoryForTest(messages: Message[], activeUse
 };
 /** Builds the normalized Cursor Run request used by transport callers and request inspection hooks. */
 export declare function buildGrpcRequest(model: Model<"cursor-agent">, context: Context, options: CursorOptions | undefined, state: CursorRequestState): Promise<CursorGrpcRequest>;
-export {};

package/dist/types/providers/factory-droid/gemini.d.ts

@@ -0,0 +1,15 @@
+import type { RequestPolicy } from "@oh-my-pi/pi-catalog/compat/types";
+import type { Effort } from "@oh-my-pi/pi-catalog/effort";
+import type { Context, Model, StreamOptions } from "../../types.js";
+import { AssistantMessageEventStream } from "../../utils/event-stream.js";
+export interface FactoryDroidGeminiOptions extends StreamOptions {
+    /** Base URL including the `/api/llm/g/v1` namespace. */
+    baseUrl: string;
+    reasoning?: Effort;
+    disableReasoning?: boolean;
+    /** Additional droid identity headers (merged over the client's own). */
+    headers: Record<string, string>;
+    /** Thinking dialect selected by the route policy. */
+    thinkingDialect?: RequestPolicy["googleThinking"];
+}
+export declare function streamFactoryDroidGemini(model: Model<"factory-droid-agent">, context: Context, options: FactoryDroidGeminiOptions): AssistantMessageEventStream;

package/dist/types/providers/factory-droid.d.ts

@@ -0,0 +1,13 @@
+import type { Effort } from "@oh-my-pi/pi-catalog/effort";
+import type { ServiceTier, StreamFunction, StreamOptions, ToolChoice } from "../types.js";
+export interface FactoryDroidOptions extends StreamOptions {
+    reasoning?: Effort;
+    disableReasoning?: boolean;
+    toolChoice?: ToolChoice;
+    serviceTier?: ServiceTier;
+    /** OMP-native "omit thinking summaries" (anthropic adaptive display). */
+    hideThinkingSummary?: boolean;
+    /** OMP-native response verbosity (responses wire `text.verbosity`). */
+    textVerbosity?: "low" | "medium" | "high";
+}
+export declare const streamFactoryDroid: StreamFunction<"factory-droid-agent">;

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

@@ -75,6 +75,7 @@ export declare function isThinkingPart(part: Pick<Part, "thought" | "thoughtSign
  * a signature from being overwritten with `undefined` within the same streamed block.
  */
 export declare function retainThoughtSignature(existing: string | undefined, incoming: string | undefined): string | undefined;
+export declare const SKIP_THOUGHT_SIGNATURE = "skip_thought_signature_validator";
 /**
  * Convert internal messages to Gemini Content[] format.
  */
@@ -212,3 +213,14 @@ export declare function streamGoogleGenAI<T extends "google-generative-ai" | "go
     retainTextSignature?: boolean;
     prepare: () => GoogleGenAIRequestPlan | Promise<GoogleGenAIRequestPlan>;
 }): AssistantMessageEventStream;
+/**
+ * Human-readable message for a non-2xx Google response.
+ *
+ * On a usage-limit status the RPC `status`/`details` residue is kept after the
+ * message: `parseGoogleRpcRateLimitReason` reads `RESOURCE_EXHAUSTED` plus the
+ * `google.rpc.ErrorInfo` reason to tell an account billing cap (terminal) from
+ * a per-minute throttle (retryable), and reducing the body to `error.message`
+ * hid both, so every billing 429 replayed as a transient rate limit (#13090).
+ * The Cloud Code Assist path keeps the whole raw body for the same reason.
+ */
+export declare function extractGoogleErrorMessage(errorText: string, status: number): string;