@oh-my-pi/pi-ai 17.2.11 → 17.2.13

package/CHANGELOG.md

@@ -2,6 +2,31 @@
 
 ## [Unreleased]
 
+## [17.2.13] - 2026-08-11
+
+### Changed
+
+- Standardized first-party outbound User-Agent headers on `omp/<version>` via the shared `USER_AGENT` utility.
+
+### Fixed
+
+- Fixed the Amazon Bedrock and Cursor transports ignoring `StreamOptions.headers`; both built their request headers from scratch, so caller-supplied tracing or attribution headers were silently dropped while working on every other provider ([#8107](https://github.com/can1357/oh-my-pi/pull/8107) by [@svperfecta](https://github.com/svperfecta)).
+- Fixed Antigravity Flash turns hanging after successful response headers when the endpoint never emitted an SSE event; the provider now cancels the stalled body and fails over after 60 seconds while retaining the longer allowance for Pro reasoning starts.
+- Fixed Cursor exec-bridge bash/grep calls failing ArkType validation when the server omitted optional frame fields: synthesized and executed tool args now drop `undefined` keys (`cwd`, `case`, `skip`, `timeout`) instead of writing `optional: value || undefined`.
+- Fixed Cursor sessions double-executing settled tools when `tools.format` is an owned dialect (e.g. `gemini`): `wrapInbandToolStream` rebuilt toolCall blocks without copying `kCursorExecResolved`, so agent-loop re-ran bash/grep/todo and appended a second result for the same call id.
+- Fixed Codex Responses Lite requests for opaque model codenames such as Daybreak omitting the required `reasoning.context: "all_turns"` value and failing with HTTP 400.
+- Fixed Cursor personal usage reporting for current Pro / Pro+ / Ultra `/api/usage-summary` payloads that expose `individualUsage.plan` (and optional `onDemand`) instead of the older `individualUsage.overall` bucket ([#7998](https://github.com/can1357/oh-my-pi/pull/7998) by [@dnth](https://github.com/dnth)).
+- Allowed passive Google callers to accept empty or thinking-only `STOP` responses as successful silence instead of exhausting the provider's empty-response retry budget. ([#8223](https://github.com/can1357/oh-my-pi/issues/8223))
+- Fixed the AWS credential resolver ignoring `role_arn` profiles: shared-config role chaining (`source_profile` recursion, `web_identity_token_file`, `credential_source`) now resolves via STS `AssumeRole`/`AssumeRoleWithWebIdentity`, honoring `role_session_name`/`duration_seconds`/`external_id`, so Bedrock is detected on EKS/IRSA and multi-account setups instead of reporting "No models available" ([#8209](https://github.com/can1357/oh-my-pi/issues/8209)).
+- Fixed Bedrock availability being under-detected on Nitro/EKS hosts: the EC2 metadata probe now recognizes Nitro DMI markers (`board_asset_tag` instance ids, `Amazon EC2` vendor fields) in addition to the Xen `ec2` UUID prefix ([#8209](https://github.com/can1357/oh-my-pi/issues/8209)).
+- Fixed DeepSeek Responses targets (opencode-go) rejecting a thinking-mode continuation with `400 The reasoning_text in the thinking mode must be passed back to the API` after a prewalk hand-off plus mid-run compaction: the Responses input builder re-encoded replayed assistant turns without a reasoning item, so the request enabled reasoning but shipped no `reasoning_text`. The encoder now synthesizes a `reasoning_text` reasoning item for every replayed assistant turn when the target requires reasoning replay in thinking mode (`requiresReasoningContentForAllAssistantTurns` / `requiresReasoningContentForToolCalls`), mirroring the chat-completions `reasoning_content` safety net ([#8248](https://github.com/can1357/oh-my-pi/issues/8248)).
+
+## [17.2.12] - 2026-08-08
+
+### Fixed
+
+- Fixed account-scoped Codex cyber-policy denials bypassing sibling credential rotation; replay-safe requests now try every configured account before surfacing the error.
+
 ## [17.2.11] - 2026-08-07
 
 ### Breaking Changes

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

@@ -14,9 +14,9 @@ import { isAuthRetryableError } from "./error/auth-classify.js";
  *   (invalidate/usage-limit the current credential and rotate to a sibling).
  *
  * Current drivers preserve that bounded a/b/c sequence for ordinary 401/auth
- * failures. 403/usage-limit failures skip refresh and may repeat step (c)
- * until the resolver returns `undefined`, cycles, or hits
- * {@link AUTH_RETRY_MAX_ATTEMPTS}.
+ * failures. Account-scoped policy denials, 403s, and usage-limit failures skip
+ * refresh and may repeat step (c) until the resolver returns `undefined`,
+ * cycles, or hits {@link AUTH_RETRY_MAX_ATTEMPTS}.
  */
 export interface ApiKeyResolveContext {
     /** True when the resolver should rotate to a sibling credential. */

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

@@ -1143,6 +1143,8 @@ export declare class AuthStorage {
      * - usage-limit / account-rate-limit error → {@link AuthStorage.markUsageLimitReached}
      *   (temporary block via its own backoff — default plus server usage-report
      *   reset; sticky left intact so the next resolve re-ranks around the block).
+     * - account-scoped policy denial → temporarily block that account without
+     *   marking its credential suspect, then rotate through eligible siblings.
      * - otherwise (hard 401 / auth failure) → mark the credential suspect (or
      *   reload when no broker hook is wired) and block it, then drop matching
      *   sticky state.

package/dist/types/error/auth-classify.d.ts

@@ -10,11 +10,11 @@ export declare function isInvalidatedOAuthTokenError(error: unknown): boolean;
 /**
  * Whether an upstream failure should rotate to a sibling credential: a hard
  * `401`, a `403` (token valid but access denied — plan, model policy, or org
- * restriction a sibling account may not share), a body-classified usage limit
- * (Codex `usage_limit_reached`, Anthropic account rate-limit, Google
+ * restriction a sibling account may not share), an account-scoped policy
+ * denial such as Codex `cyber_policy`, a body-classified usage limit (Codex
+ * `usage_limit_reached`, Anthropic account rate-limit, Google
  * `resource_exhausted`, OpenAI `insufficient_quota`, …), or a bare `429`
- * whose payload did not preserve a richer quota code.
- * Transient 429s (`Too many requests`, per-minute caps) stay in the
- * upstream-backoff lane.
+ * whose payload did not preserve a richer quota code. Transient 429s
+ * (`Too many requests`, per-minute caps) stay in the upstream-backoff lane.
  */
 export declare function isAuthRetryableError(error: unknown): boolean;

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

@@ -13,7 +13,11 @@ export type AwsCredentialsErrorKind =
 /** STS web-identity exchange failed or returned malformed credentials. */
  | "web-identity"
 /** ECS/container credential endpoint failed or returned malformed credentials. */
- | "container";
+ | "container"
+/** Shared-config role chain is misconfigured (cycle, missing source_profile, unsupported credential_source). */
+ | "profile"
+/** STS `AssumeRole` call failed or returned malformed credentials. */
+ | "assume-role";
 /** A failure resolving AWS credentials for the Bedrock provider. */
 export declare class AwsCredentialsError extends Error {
     readonly kind: AwsCredentialsErrorKind;

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

@@ -9,6 +9,8 @@ export declare const Flag: {
     readonly MalformedFunctionCall: 2097152;
     readonly ProviderFinishError: 4194304;
     readonly ContentBlocked: 32768;
+    /** Account-scoped provider policy denial that may succeed with another credential. */
+    readonly AccountPolicy: 16384;
     readonly ContextOverflow: 8388608;
     readonly AuthFailed: 16777216;
     readonly SilentAbort: 33554432;
@@ -53,6 +55,8 @@ export declare function classify(error: unknown, api?: Api): number;
  * regexes at call sites.
  */
 export declare function isUsageLimit(error: unknown, api?: Api): boolean;
+/** Whether an upstream rejection is an account-scoped policy denial worth retrying with a sibling credential. */
+export declare function isAccountPolicyError(error: unknown, api?: Api): boolean;
 /**
  * Strict-tool rejection: grammar too large, schema too complex, or structured
  * outputs unsupported by the model/endpoint.

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

@@ -5,8 +5,9 @@
  *  1. Static credentials from the environment
  *     (`AWS_ACCESS_KEY_ID` + `AWS_SECRET_ACCESS_KEY` [+ `AWS_SESSION_TOKEN`]).
  *  2. Web identity (`AWS_WEB_IDENTITY_TOKEN_FILE` + `AWS_ROLE_ARN`).
- *  3. Profile in `~/.aws/credentials` (and `~/.aws/config` for SSO):
- *      - static keys, SSO, or `credential_process`.
+ *  3. Profile in `~/.aws/credentials` (and `~/.aws/config` for SSO/roles):
+ *      - static keys, SSO, `credential_process`, or `role_arn` role chaining
+ *        (`source_profile` recursion, `web_identity_token_file`, `credential_source`).
  *  4. ECS/container credentials from `AWS_CONTAINER_CREDENTIALS_*`.
  *  5. EC2 IMDSv2 when metadata is enabled.
  *
@@ -14,7 +15,7 @@
  * 60 s before `Expiration` to absorb clock skew.
  */
 import type { FetchImpl } from "../types.js";
-import type { AwsCredentials } from "./aws-sigv4.js";
+import { type AwsCredentials } from "./aws-sigv4.js";
 export interface ResolvedCredentials extends AwsCredentials {
     /** Absolute expiration timestamp in ms. `undefined` for non-expiring static creds. */
     expiresAt?: number;

package/dist/types/providers/cursor/exec-modern.d.ts

@@ -17,7 +17,7 @@ import type { ToolResultMessage } from "../../types.js";
  * virtual registry. Re-exported here because this is where the frame builders
  * and their translation are consumed together.
  */
-export { piEscapeRegexLiteral, piGrepSkip, piJoinPath, piLimit, piLsPath, piReadDisplayPath, piReadPath, piReadPathHasRange, piTimeout, } from "../cursor-pi-args.js";
+export { omitUndefinedArgs, piEscapeRegexLiteral, piGrepSkip, piJoinPath, piLimit, piLsPath, piReadDisplayPath, piReadPath, piReadPathHasRange, piTimeout, } from "../cursor-pi-args.js";
 /** Flatten a tool result's content into the single `output` string the Pi frames carry. */
 export declare function piOutputText(toolResult: ToolResultMessage): string;
 /**

package/dist/types/providers/cursor-pi-args.d.ts

@@ -103,3 +103,17 @@ export declare function piLimit(limit: number | undefined): number | undefined;
  * Negative values have no local meaning and fall back to the default.
  */
 export declare function piTimeout(timeout: number | undefined): number | undefined;
+/**
+ * Drop keys whose value is `undefined` so optional local-tool kwargs stay
+ * absent rather than present-as-undefined.
+ *
+ * The Cursor exec bridge historically wrote forms like
+ * `cwd: workingDirectory || undefined` and
+ * `case: caseInsensitive === true ? false : undefined`. ArkType rejects a
+ * present `undefined` on an optional field (`was undefined`) even though
+ * omitting the key is valid — which flooded Cursor sessions with bash/grep
+ * validation errors for otherwise fine frames.
+ */
+export declare function omitUndefinedArgs<T extends Record<string, unknown>>(args: T): {
+    [K in keyof T]?: Exclude<T[K], undefined>;
+};

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

@@ -419,6 +419,14 @@ export interface BuildResponsesInputOptions<TApi extends Api> {
     repairOrphanOutputs?: boolean;
     /** Preserve assistant message item IDs from text signatures during fallback replay. */
     preserveAssistantMessageIds?: boolean;
+    /**
+     * Synthesize a reasoning item for every replayed assistant turn that carries
+     * content but no reasoning item. Set for DeepSeek-family Responses targets
+     * that reject a thinking-mode continuation lacking `reasoning_text`.
+     */
+    requiresReasoningReplayForAllTurns?: boolean;
+    /** As {@link requiresReasoningReplayForAllTurns}, but only for turns that contain a tool call. */
+    requiresReasoningReplayForToolCalls?: boolean;
 }
 /**
  * Escape reserved Harmony control tokens in the free-text fields of replayed
@@ -443,7 +451,7 @@ export interface BuildResponsesInputOptions<TApi extends Api> {
  */
 export declare function escapeReplayedControlTokens(items: ResponseInput): ResponseInput;
 export declare function buildResponsesInput<TApi extends Api>(options: BuildResponsesInputOptions<TApi>): ResponseInput;
-export declare function convertResponsesAssistantMessage<TApi extends Api>(assistantMsg: AssistantMessage, model: Model<TApi>, msgIndex: number, knownCallIds: Set<string>, includeThinkingSignatures?: boolean, customCallIds?: Set<string>, preserveMessageIds?: boolean, supportsCustomToolCalls?: boolean, customToolWireNameMap?: ReadonlyMap<string, string>, computerCallIds?: Set<string>): ResponseInput;
+export declare function convertResponsesAssistantMessage<TApi extends Api>(assistantMsg: AssistantMessage, model: Model<TApi>, msgIndex: number, knownCallIds: Set<string>, includeThinkingSignatures?: boolean, customCallIds?: Set<string>, preserveMessageIds?: boolean, supportsCustomToolCalls?: boolean, customToolWireNameMap?: ReadonlyMap<string, string>, computerCallIds?: Set<string>, requiresReasoningReplayForAllTurns?: boolean, requiresReasoningReplayForToolCalls?: boolean): ResponseInput;
 /** Appends one tool result while keeping consecutive outputs ahead of its synthetic image messages. */
 export declare function appendResponsesToolResultMessages<TApi extends Api>(messages: ResponseInput, toolResult: ToolResultMessage, model: Model<TApi>, strictResponsesPairing: boolean, supportsImageDetailOriginal: boolean, knownCallIds: ReadonlySet<string>, customCallIds?: ReadonlySet<string>, supportsCustomToolCalls?: boolean, computerCallIds?: ReadonlySet<string>): void;
 /**

package/dist/types/registry/api-key-login.d.ts

@@ -27,16 +27,18 @@ type ModelsEndpointValidation = {
 export type ApiKeyLoginConfig = {
     /** Display name used in error messages, e.g. "Cerebras", "NanoGPT". */
     providerLabel: string;
-    /** URL opened in browser for the user to grab their key. */
-    authUrl: string;
-    /** Instructions shown with the onAuth callback. */
-    instructions: string;
+    /** URL opened in browser for the user to grab their key, or omitted to skip onAuth. */
+    authUrl?: string;
+    /** Instructions shown with the onAuth callback, or omitted to skip onAuth. */
+    instructions?: string;
     /** Prompt message shown when asking for the key paste. */
     promptMessage: string;
     /** Placeholder string for the prompt (e.g. "sk-...", "csk-..."). */
     placeholder: string;
     /** Validation strategy, or `null` to skip validation. */
     validation: ChatCompletionsValidation | AnthropicMessagesValidation | ModelsEndpointValidation | null;
+    /** Value returned for an empty key; also allows an empty prompt response. */
+    emptyKeyFallback?: string;
 };
 export declare function createApiKeyLogin(config: ApiKeyLoginConfig): (options: OAuthController) => Promise<string>;
 export {};

package/dist/types/registry/cloudflare-ai-gateway.d.ts

@@ -1,11 +1,11 @@
-import type { OAuthController, OAuthLoginCallbacks } from "./oauth/types.js";
+import type { OAuthLoginCallbacks } from "./oauth/types.js";
 /**
  * Login to Cloudflare AI Gateway.
  *
  * Opens browser to Cloudflare AI Gateway authentication docs and prompts for a gateway token/API key.
  * Returns the API key directly (not OAuthCredentials - this isn't OAuth).
  */
-export declare function loginCloudflareAiGateway(options: OAuthController): Promise<string>;
+export declare const loginCloudflareAiGateway: (options: import("./oauth/index.js").OAuthController) => Promise<string>;
 export declare const cloudflareAiGatewayProvider: {
     readonly id: "cloudflare-ai-gateway";
     readonly name: "Cloudflare AI Gateway";

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

@@ -1,11 +1,11 @@
-import type { OAuthController, OAuthLoginCallbacks } from "./oauth/types.js";
+import type { OAuthLoginCallbacks } from "./oauth/types.js";
 /**
  * Login to Kagi.
  *
  * Opens browser to API settings and prompts user to paste their API key.
  * Returns the API key directly (not OAuthCredentials - this isn't OAuth).
  */
-export declare function loginKagi(options: OAuthController): Promise<string>;
+export declare const loginKagi: (options: import("./oauth/index.js").OAuthController) => Promise<string>;
 export declare const kagiProvider: {
     readonly id: "kagi";
     readonly name: "Kagi";

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

@@ -1,11 +1,11 @@
-import type { OAuthController, OAuthLoginCallbacks } from "./oauth/types.js";
+import type { OAuthLoginCallbacks } from "./oauth/types.js";
 /**
  * Login to LiteLLM.
  *
  * Opens browser to LiteLLM setup docs, prompts user to paste their API key.
  * Returns the API key directly (not OAuthCredentials - this isn't OAuth).
  */
-export declare function loginLiteLLM(options: OAuthController): Promise<string>;
+export declare const loginLiteLLM: (options: import("./oauth/index.js").OAuthController) => Promise<string>;
 export declare const litellmProvider: {
     readonly id: "litellm";
     readonly name: "LiteLLM";

package/dist/types/registry/llama-cpp.d.ts

@@ -1,5 +1,5 @@
-import type { OAuthController, OAuthLoginCallbacks } from "./oauth/types.js";
-export declare function loginLlamaCpp(options: OAuthController): Promise<string>;
+import type { OAuthLoginCallbacks } from "./oauth/types.js";
+export declare const loginLlamaCpp: (options: import("./oauth/index.js").OAuthController) => Promise<string>;
 export declare const llamaCppProvider: {
     readonly id: "llama.cpp";
     readonly name: "llama.cpp (Local OpenAI-compatible)";

package/dist/types/registry/lm-studio.d.ts

@@ -1,6 +1,6 @@
-import type { OAuthController, OAuthLoginCallbacks } from "./oauth/types.js";
+import type { OAuthLoginCallbacks } from "./oauth/types.js";
 export declare const DEFAULT_LOCAL_TOKEN = "lm-studio-local";
-export declare function loginLmStudio(options: OAuthController): Promise<string>;
+export declare const loginLmStudio: (options: import("./oauth/index.js").OAuthController) => Promise<string>;
 export declare const lmStudioProvider: {
     readonly id: "lm-studio";
     readonly name: "LM Studio (Local OpenAI-compatible)";

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

@@ -1,11 +1,11 @@
-import type { OAuthController, OAuthLoginCallbacks } from "./oauth/types.js";
+import type { OAuthLoginCallbacks } from "./oauth/types.js";
 /**
  * Login to Parallel.
  *
  * Opens browser to the API keys page, prompts the user to paste their API key,
  * and returns the API key directly.
  */
-export declare function loginParallel(options: OAuthController): Promise<string>;
+export declare const loginParallel: (options: import("./oauth/index.js").OAuthController) => Promise<string>;
 export declare const parallelProvider: {
     readonly id: "parallel";
     readonly name: "Parallel";

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

@@ -5,7 +5,7 @@ import type { OAuthLoginCallbacks } from "./oauth/types.js";
  * Opens browser to API keys page and prompts user to paste their API key.
  * Returns the API key directly (not OAuthCredentials - this isn't OAuth).
  */
-export declare function loginTavily(options: OAuthLoginCallbacks): Promise<string>;
+export declare const loginTavily: (options: import("./oauth/index.js").OAuthController) => Promise<string>;
 export declare const tavilyProvider: {
     readonly id: "tavily";
     readonly name: "Tavily";

package/dist/types/registry/vercel-ai-gateway.d.ts

@@ -1,5 +1,5 @@
-import type { OAuthController, OAuthLoginCallbacks } from "./oauth/types.js";
-export declare function loginVercelAiGateway(options: OAuthController): Promise<string>;
+import type { OAuthLoginCallbacks } from "./oauth/types.js";
+export declare const loginVercelAiGateway: (options: import("./oauth/index.js").OAuthController) => Promise<string>;
 export declare const vercelAiGatewayProvider: {
     readonly id: "vercel-ai-gateway";
     readonly name: "Vercel AI Gateway";

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

@@ -1,5 +1,5 @@
-import type { OAuthController, OAuthLoginCallbacks } from "./oauth/types.js";
-export declare function loginVllm(options: OAuthController): Promise<string>;
+import type { OAuthLoginCallbacks } from "./oauth/types.js";
+export declare const loginVllm: (options: import("./oauth/index.js").OAuthController) => Promise<string>;
 export declare const vllmProvider: {
     readonly id: "vllm";
     readonly name: "vLLM (Local OpenAI-compatible)";

package/dist/types/types.d.ts

@@ -368,6 +368,13 @@ export interface StreamOptions {
      * Optional retry delay hook for tests and transports that need custom scheduling.
      */
     providerRetryWait?: (delayMs: number, signal?: AbortSignal) => Promise<void>;
+    /**
+     * Accept a Google `STOP` response with no visible text or tool call as a
+     * successful completion. Passive callers such as advisors use this because
+     * silence is a valid result; interactive agent turns retain empty-response
+     * retries by default. Ignored by non-Google providers.
+     */
+    acceptEmptyResponse?: boolean;
     /**
      * Optional `fetch` implementation override. Providers route every HTTP
      * request — direct calls, SDK clients, and retry helpers — through this

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

@@ -1,4 +1,15 @@
 import type { UsageProvider, UsageReport } from "../usage.js";
+/**
+ * Cursor's `/api/usage-summary` has shipped two personal-bucket shapes:
+ * - Enterprise/team dashboards historically exposed `individualUsage.overall`
+ * - Current Pro / Pro+ / Ultra dashboards expose `individualUsage.plan`
+ *   (plus optional `onDemand`)
+ *
+ * Prefer a *usable* overall bucket; if overall is absent/disabled/malformed,
+ * fall through to plan rails (`autoPercentUsed` / `apiPercentUsed`). Always
+ * consider on-demand afterward so a valid on-demand meter is not dropped when
+ * the included plan bucket is empty.
+ */
 export declare function parseCursorIndividualUsage(payload: unknown, fetchedAt?: number): UsageReport | null;
 export declare function parseCursorUsage(payload: unknown, fetchedAt?: number): UsageReport | null;
 export declare const cursorUsageProvider: UsageProvider;

package/dist/types/usage/openai-codex-reset.d.ts

@@ -1,23 +1,3 @@
-/**
- * OpenAI Codex "saved rate limit reset" redemption client.
- *
- * OpenAI lets paid Codex accounts bank a usage-window reset and spend it on
- * demand (announced 2026-06-11). The count is surfaced on `/wham/usage` as
- * `rate_limit_reset_credits.available_count` (see `./openai-codex.ts`), but the
- * actual credit objects and the redeem action live on two dedicated routes:
- *
- *   GET  /wham/rate-limit-reset-credits           → list redeemable credits
- *   POST /wham/rate-limit-reset-credits/consume   → spend one credit
- *        body: { credit_id, redeem_request_id, account_id? }
- *
- * `redeem_request_id` is a client-generated idempotency key (UUID). The consume
- * response carries a `code`: `"reset"` on success, otherwise a business reason
- * (`already_redeemed`, `no_credit`, `nothing_to_reset`).
- *
- * These are thin, dependency-light functions so both the interactive session
- * (the `/usage reset` command + auto-redeem) and any out-of-band tooling can
- * share one wire contract.
- */
 import type { FetchImpl } from "../types.js";
 /** A single redeemable (or already-spent) saved reset. */
 export interface CodexResetCredit {

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

@@ -1 +1,13 @@
-export declare const toNumber: (value: unknown) => number | undefined;
+import type { UsageStatus } from "../usage.js";
+/** Milliseconds in one hour. */
+export declare const HOUR_MS: number;
+/** Milliseconds in one day. */
+export declare const DAY_MS: number;
+/** Milliseconds in one seven-day week. */
+export declare const WEEK_MS: number;
+/** Parses a finite positive epoch timestamp, tolerating seconds or milliseconds. */
+export declare function parsePositiveTimestamp(value: unknown): number | undefined;
+/** Parses an ISO timestamp into epoch milliseconds. */
+export declare function parseIsoTimestamp(value: unknown): number | undefined;
+/** Maps a used fraction to the standard quota status thresholds. */
+export declare function usageStatus(usedFraction: number | undefined): UsageStatus;

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

@@ -45,6 +45,18 @@ export declare const kCursorExecResolved: unique symbol;
 export type CursorExecResolvedCarrier = object & {
     [kCursorExecResolved]?: true;
 };
+/** True when a toolCall block was already executed by Cursor's exec channel. */
+export declare function isCursorExecResolved(block: CursorExecResolvedCarrier | null | undefined): boolean;
+/**
+ * Copy {@link kCursorExecResolved} onto a cloned/projected toolCall block.
+ *
+ * Stream projectors (owned/in-band dialect, leaked-thinking heal) rebuild
+ * toolCall objects field-by-field. Dropping this marker lets `agent-loop.ts`
+ * re-execute a call Cursor already settled — duplicate toolResults and a
+ * second bash/write/delete. Partial-JSON is already copied explicitly; this
+ * marker is the other load-bearing symbol that must survive the same way.
+ */
+export declare function copyCursorExecResolved(target: CursorExecResolvedCarrier, source: CursorExecResolvedCarrier): void;
 /**
  * Marks a text block synthesized by cross-model thinking demotion in
  * `transformMessages`. Converters that flatten adjacent text blocks into one

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-ai",
-	"version": "17.2.11",
+	"version": "17.2.13",
 	"description": "Unified LLM API with automatic model discovery and provider configuration",
 	"homepage": "https://omp.sh",
 	"author": "Can Boluk",
@@ -38,10 +38,10 @@
 	},
 	"dependencies": {
 		"@bufbuild/protobuf": "^2.12.1",
-		"@oh-my-pi/omptype": "17.2.11",
-		"@oh-my-pi/pi-catalog": "17.2.11",
-		"@oh-my-pi/pi-utils": "17.2.11",
-		"@oh-my-pi/pi-wire": "17.2.11"
+		"@oh-my-pi/omptype": "17.2.13",
+		"@oh-my-pi/pi-catalog": "17.2.13",
+		"@oh-my-pi/pi-utils": "17.2.13",
+		"@oh-my-pi/pi-wire": "17.2.13"
 	},
 	"devDependencies": {
 		"@bufbuild/protoc-gen-es": "^2.12.1",

package/src/auth-retry.ts

@@ -2,7 +2,7 @@ import { extractHttpStatusFromError } from "@oh-my-pi/pi-utils";
 import type { OAuthAccess } from "./auth-storage";
 import * as AIError from "./error";
 import { isAuthRetryableError, isInvalidatedOAuthTokenError } from "./error/auth-classify";
-import { isUsageLimit } from "./error/flags";
+import { isAccountPolicyError, isUsageLimit } from "./error/flags";
 import { isConcurrencyCapExclusion, isUsageLimitOutcome } from "./error/rate-limit";
 
 /**
@@ -19,9 +19,9 @@ import { isConcurrencyCapExclusion, isUsageLimitOutcome } from "./error/rate-lim
  *   (invalidate/usage-limit the current credential and rotate to a sibling).
  *
  * Current drivers preserve that bounded a/b/c sequence for ordinary 401/auth
- * failures. 403/usage-limit failures skip refresh and may repeat step (c)
- * until the resolver returns `undefined`, cycles, or hits
- * {@link AUTH_RETRY_MAX_ATTEMPTS}.
+ * failures. Account-scoped policy denials, 403s, and usage-limit failures skip
+ * refresh and may repeat step (c) until the resolver returns `undefined`,
+ * cycles, or hits {@link AUTH_RETRY_MAX_ATTEMPTS}.
  */
 export interface ApiKeyResolveContext {
 	/** True when the resolver should rotate to a sibling credential. */
@@ -91,6 +91,7 @@ export const AUTH_RETRY_STEPS: readonly boolean[] = [false, true];
 export const AUTH_RETRY_MAX_ATTEMPTS = 64;
 
 function isDirectCredentialRotationError(error: unknown): boolean {
+	if (isAccountPolicyError(error)) return true;
 	if (isUsageLimit(error) || isInvalidatedOAuthTokenError(error)) return true;
 	const status = AIError.status(error);
 	const message = error instanceof Error ? error.message : typeof error === "string" ? error : undefined;

package/src/auth-storage.ts

@@ -1211,6 +1211,14 @@ type OAuthCandidate = UsageCandidate<OAuthCredential>;
 type ApiKeyCandidate = UsageCandidate<ApiKeyCredential>;
 type UsageRankingResult<T extends AuthCredential> = UsageCandidate<T> & { blockedUntil: number | undefined };
 
+type CredentialBlockRouting = {
+	providerKey: string;
+	strategy: CredentialRankingStrategy | undefined;
+	rankingContext: CredentialRankingContext;
+	blockScope: string | undefined;
+	siblingBlockScopes: readonly string[];
+};
+
 type UsageRankedCandidate<T extends AuthCredential> = UsageCandidate<T> & {
 	blocked: boolean;
 	blockedUntil?: number;
@@ -4271,6 +4279,58 @@ export class AuthStorage {
 		return sessionCredential ? { ...sessionCredential, explicit: false } : undefined;
 	}
 
+	#credentialBlockRouting(
+		provider: string,
+		credentialType: AuthCredential["type"],
+		modelId: string | undefined,
+	): CredentialBlockRouting {
+		const providerKey = this.#getProviderTypeKey(provider, credentialType);
+		const strategy = this.#rankingStrategyResolver?.(provider);
+		const rankingContext: CredentialRankingContext = { modelId };
+		const blockScope = strategy?.blockScope?.(rankingContext);
+		return {
+			providerKey,
+			strategy,
+			rankingContext,
+			blockScope,
+			siblingBlockScopes: strategy?.blockScopes?.(rankingContext) ?? (blockScope ? [blockScope] : []),
+		};
+	}
+
+	#blockCredentialForRotation(
+		provider: string,
+		credentialType: AuthCredential["type"],
+		targetIndex: number,
+		blockedUntil: number,
+		routing: CredentialBlockRouting,
+	): UsageLimitMarkResult {
+		if (targetIndex >= 0) {
+			this.#markCredentialBlocked(provider, routing.providerKey, targetIndex, blockedUntil, routing.blockScope);
+		}
+
+		const remainingCredentials = this.#getCredentialsForProvider(provider)
+			.map((credential, index) => ({ credential, index }))
+			.filter(
+				(entry): entry is { credential: AuthCredential; index: number } =>
+					entry.credential.type === credentialType && entry.index !== targetIndex,
+			);
+
+		let retryAtMs: number | undefined;
+		for (const candidate of remainingCredentials) {
+			// Sibling availability must use the same scope set selection reads, or
+			// this reports a sibling as free that selection will then refuse.
+			const candidateBlockedUntil = this.#getCredentialBlockedUntil(
+				provider,
+				routing.providerKey,
+				candidate.index,
+				routing.siblingBlockScopes,
+			);
+			if (candidateBlockedUntil === undefined) return { switched: true };
+			if (retryAtMs === undefined || candidateBlockedUntil < retryAtMs) retryAtMs = candidateBlockedUntil;
+		}
+		return { switched: false, retryAtMs };
+	}
+
 	/**
 	 * Marks the current session's credential as temporarily blocked due to usage limits.
 	 * Uses usage reports to determine accurate reset time when available.
@@ -4313,21 +4373,17 @@ export class AuthStorage {
 		const credentialType = sessionCredential.type;
 		const targetCredentialId = target.id;
 
-		const providerKey = this.#getProviderTypeKey(provider, credentialType);
-		const strategy = this.#rankingStrategyResolver?.(provider);
-		const rankingContext: CredentialRankingContext = { modelId: options?.modelId };
-		const blockScope = strategy?.blockScope?.(rankingContext);
-		const siblingBlockScopes = strategy?.blockScopes?.(rankingContext) ?? (blockScope ? [blockScope] : []);
+		const routing = this.#credentialBlockRouting(provider, credentialType, options?.modelId);
 		const now = Date.now();
 		let blockedUntil = now + (options?.retryAfterMs ?? AuthStorage.#defaultBackoffMs);
 
-		if (credentialType === "oauth" && target.credential.type === "oauth" && strategy) {
+		if (credentialType === "oauth" && target.credential.type === "oauth" && routing.strategy) {
 			const report = await raceUsageWithSignal(
 				this.#getUsageReport(provider, target.credential, options),
 				options?.signal,
 			);
 			if (report) {
-				const scopedLimits = this.#getScopedUsageLimits(strategy, report, rankingContext);
+				const scopedLimits = this.#getScopedUsageLimits(routing.strategy, report, routing.rankingContext);
 				if (this.#isUsageLimitReached(scopedLimits)) {
 					const resetAtMs = this.#getUsageResetAtMs(scopedLimits, Date.now());
 					if (resetAtMs && resetAtMs > blockedUntil) {
@@ -4343,32 +4399,7 @@ export class AuthStorage {
 		const targetIndex = this.#getStoredCredentials(provider).findIndex(
 			entry => entry.id === targetCredentialId && entry.credential.type === credentialType,
 		);
-		if (targetIndex >= 0) {
-			this.#markCredentialBlocked(provider, providerKey, targetIndex, blockedUntil, blockScope);
-		}
-
-		const remainingCredentials = this.#getCredentialsForProvider(provider)
-			.map((credential, index) => ({ credential, index }))
-			.filter(
-				(entry): entry is { credential: AuthCredential; index: number } =>
-					entry.credential.type === credentialType && entry.index !== targetIndex,
-			);
-
-		let retryAtMs: number | undefined;
-		for (const candidate of remainingCredentials) {
-			// Sibling availability must use the same scope set selection reads, or
-			// this reports a sibling as free that selection will then refuse, most
-			// visibly when the sibling still carries a legacy shared block.
-			const candidateBlockedUntil = this.#getCredentialBlockedUntil(
-				provider,
-				providerKey,
-				candidate.index,
-				siblingBlockScopes,
-			);
-			if (candidateBlockedUntil === undefined) return { switched: true };
-			if (retryAtMs === undefined || candidateBlockedUntil < retryAtMs) retryAtMs = candidateBlockedUntil;
-		}
-		return { switched: false, retryAtMs };
+		return this.#blockCredentialForRotation(provider, credentialType, targetIndex, blockedUntil, routing);
 	}
 
 	#resolveWindowResetAt(window: UsageLimit["window"]): number | undefined {
@@ -6078,6 +6109,8 @@ export class AuthStorage {
 	 * - usage-limit / account-rate-limit error → {@link AuthStorage.markUsageLimitReached}
 	 *   (temporary block via its own backoff — default plus server usage-report
 	 *   reset; sticky left intact so the next resolve re-ranks around the block).
+	 * - account-scoped policy denial → temporarily block that account without
+	 *   marking its credential suspect, then rotate through eligible siblings.
 	 * - otherwise (hard 401 / auth failure) → mark the credential suspect (or
 	 *   reload when no broker hook is wired) and block it, then drop matching
 	 *   sticky state.
@@ -6114,6 +6147,17 @@ export class AuthStorage {
 		});
 		if (!sessionCredential) return false;
 
+		if (AIError.isAccountPolicyError(error)) {
+			const routing = this.#credentialBlockRouting(provider, sessionCredential.type, options?.modelId);
+			return this.#blockCredentialForRotation(
+				provider,
+				sessionCredential.type,
+				sessionCredential.index,
+				Date.now() + AuthStorage.#defaultBackoffMs,
+				routing,
+			).switched;
+		}
+
 		const providerKey = this.#getProviderTypeKey(provider, sessionCredential.type);
 		// Snapshot sibling availability before mutating so a soft-deleting
 		// suspect hook can't reindex the answer out from under us.