@oh-my-pi/pi-ai 18.4.4 → 18.4.6

package/CHANGELOG.md

@@ -2,6 +2,28 @@
 
 ## [Unreleased]
 
+## [18.4.6] - 2026-10-01
+
+### Fixed
+
+- Fixed forced tool calls failing for Claude Opus 5.5 and Sonnet 5.5 through Amazon Bedrock, including required-tool retries in plan mode.
+
+## [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
@@ -2294,29 +2316,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
-
-Older entries are archived in [packages\ai\CHANGELOG.md@07e9197a3012](https://github.com/can1357/oh-my-pi/blob/07e9197a3012f58c459f1faabeb324decc21f41d/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-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/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.d.ts

@@ -234,6 +234,13 @@ export declare function budgetThinkingOutput(maxTokens: number | undefined, budg
     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/cursor/interaction-query.d.ts

@@ -1,10 +1,12 @@
-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. */
@@ -21,5 +23,5 @@ export declare function protoUnknownFields(message: object): ProtoUnknownField[]
  * 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;

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

@@ -231,14 +231,19 @@ export interface ChatCompletionUserMessageParam {
     /** Optional participant name. */
     name?: string;
 }
+/** Mistral Medium 3.5 reasoning content part on assistant history. */
+export interface ChatCompletionMistralThinkingPart {
+    type: "thinking";
+    thinking: ChatCompletionContentPartText[];
+}
 /** Assistant (model) message. */
 export interface ChatCompletionAssistantMessageParam {
     /** Always `assistant`. */
     role: "assistant";
     /** Data about a previous audio response from the model. */
     audio?: ChatCompletionAssistantMessageParamAudio | null;
-    /** Message contents. Required unless `tool_calls` or `function_call` is specified. */
-    content?: string | Array<ChatCompletionContentPartText | ChatCompletionContentPartRefusal> | null;
+    /** Message contents. Mistral reasoning uses typed thinking parts in this array. */
+    content?: string | Array<ChatCompletionContentPartText | ChatCompletionContentPartRefusal | ChatCompletionMistralThinkingPart> | null;
     /** Deprecated by OpenAI; replaced by `tool_calls`. */
     function_call?: ChatCompletionAssistantMessageParamFunctionCall | null;
     /** Optional participant name. */

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

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

package/dist/types/registry/oauth/device-code.d.ts

@@ -12,8 +12,8 @@ export type OAuthDeviceCodePollResult<T> = {
 };
 /** Options for polling an RFC 8628-style OAuth device-code flow. */
 export interface OAuthDeviceCodeFlowOptions<T> {
-    /** Poll the provider once and classify the response. */
-    poll(): OAuthDeviceCodePollResult<T> | Promise<OAuthDeviceCodePollResult<T>>;
+    /** Poll the provider once and classify the response. Signal includes caller cancellation and device-code expiry. */
+    poll(signal?: AbortSignal): OAuthDeviceCodePollResult<T> | Promise<OAuthDeviceCodePollResult<T>>;
     /** Provider-requested polling cadence; defaults to RFC 8628's five seconds. */
     intervalSeconds?: number;
     /** Provider-issued expiry window for the device code. */

package/dist/types/registry/oauth/factory-droid.d.ts

@@ -0,0 +1,3 @@
+import type { AfterExchangeHook } from "../hooks/types.js";
+/** Resolve canonical Factory identity; residency chooses the host, inference scope chooses eligible routes. */
+export declare const attachFactoryDroidRegion: AfterExchangeHook;

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

@@ -11,13 +11,23 @@ export type OAuthCredentials = {
     apiEndpoint?: string;
     /**
      * Organization/workspace the token is scoped to (e.g. an Anthropic org
-     * UUID or a ChatGPT workspace id). Captured once at login; token refreshes
-     * never rewrite it. Lets one account email hold credentials for multiple
-     * subscriptions.
+     * UUID or canonical Factory org ID). Lets one account email hold
+     * credentials for multiple subscriptions.
      */
     orgId?: string;
     /** Human-readable organization name for display (may embed the email). */
     orgName?: string;
+    /**
+     * Account residency region (e.g. `"eu"`), when the provider is
+     * region-partitioned. Captured at login; refreshed identity may update it
+     * when the account migrates, while failed lookups preserve the stored value.
+     * Residency selects the API host, not inference eligibility.
+     */
+    region?: string;
+    /** Factory organization inference scope, independent of account residency. */
+    inferenceRegion?: "global" | "eu" | "us";
+    /** WorkOS selected organization; never used as a Factory API organization header. */
+    activeOrganizationId?: string;
     /**
      * Epoch ms of the interactive login that minted this grant. Set by
      * `AuthStorage.oauth.login`; token refreshes preserve it. Providers with an

package/dist/types/types.d.ts

@@ -6,6 +6,7 @@ import type { DeleteArgs, DeleteResult, DiagnosticsArgs, DiagnosticsResult, Grep
 import type { Effort } from "@oh-my-pi/pi-catalog/effort";
 import type { Api, FetchImpl, Model, Provider, ThinkingBudgets, Usage } from "@oh-my-pi/pi-catalog/types";
 import type { ApiKey } from "./auth-retry.js";
+import type { OAuthRequestIdentity } from "./auth/types.js";
 import type { BedrockOptions } from "./providers/amazon-bedrock.js";
 import type { AnthropicOptions } from "./providers/anthropic.js";
 import type { FallbackParam, StopDetails } from "./providers/anthropic-wire.js";
@@ -13,6 +14,7 @@ import type { AzureOpenAIResponsesOptions } from "./providers/azure-openai-respo
 import type { CursorOptions } from "./providers/cursor.js";
 import type { AppleFoundationModelsOptions } from "./providers/apple-foundation-models.js";
 import type { DevinOptions } from "./providers/devin.js";
+import type { FactoryDroidOptions } from "./providers/factory-droid.js";
 import type { GitLabDuoWorkflowOptions } from "./providers/gitlab-duo-workflow.js";
 import type { GoogleOptions } from "./providers/google.js";
 import type { GoogleGeminiCliOptions } from "./providers/google-gemini-cli.js";
@@ -49,6 +51,7 @@ export interface ApiOptionsMap {
     "google-vertex": GoogleVertexOptions;
     "ollama-chat": OllamaChatOptions;
     "cursor-agent": CursorOptions;
+    "factory-droid-agent": FactoryDroidOptions;
     "gitlab-duo-agent": GitLabDuoWorkflowOptions;
     "devin-agent": DevinOptions;
     "apple-foundation-models": AppleFoundationModelsOptions;
@@ -247,6 +250,8 @@ export interface StreamOptions {
     apiKey?: string;
     /** @internal Stored credential row serving this request, when known. */
     credentialId?: number;
+    /** @internal Non-secret identity of the bearer serving this attempt; never persisted in history. */
+    oauthIdentity?: OAuthRequestIdentity;
     cacheRetention?: CacheRetention;
     /**
      * Anthropic preserved-thinking behavior when a signed block no longer matches

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

@@ -0,0 +1,11 @@
+import type { CredentialRankingStrategy, UsageProvider, UsageReport } from "../usage.js";
+/**
+ * Parses `GET /api/billing/limits` into a usage report: per-pool
+ * (Standard credits / Droid Core)
+ * × per-window (5h / weekly / monthly) percent-used limits, plus the extra
+ * usage balance when present.
+ */
+export declare function parseFactoryDroidUsage(payload: unknown, fetchedAt?: number): UsageReport | null;
+export declare const factoryDroidUsageProvider: UsageProvider;
+/** Factory's Core and Standard credits have independent subscription windows. */
+export declare const factoryDroidRankingStrategy: CredentialRankingStrategy;

package/dist/types/usage.d.ts

@@ -563,6 +563,10 @@ export interface UsageCredential {
     /** Human-readable organization name for display. */
     orgName?: string;
     enterpriseUrl?: string;
+    /** Account residency used for region-aware provider routing. */
+    region?: string;
+    inferenceRegion?: "global" | "eu" | "us";
+    activeOrganizationId?: string;
     metadata?: Record<string, unknown>;
     apiEndpoint?: string;
 }

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

@@ -0,0 +1,2 @@
+/** Project a dereferenced JSON Schema onto Factory Gemini's allowed fields. */
+export declare function normalizeSchemaForFactoryDroid(value: unknown): unknown;

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

@@ -1,4 +1,5 @@
 export * from "./adapt.js";
+export * from "./allowlist.js";
 export * from "./compatibility.js";
 export * from "./dereference.js";
 export * from "./draft.js";