@oh-my-pi/pi-ai 18.4.9 → 18.4.11

package/CHANGELOG.md

@@ -2,6 +2,24 @@
 
 ## [Unreleased]
 
+## [18.4.11] - 2026-10-02
+
+### Fixed
+
+- Fixed Cursor cached prompt token accounting to prevent duplicate input-token and cost reporting on cached turns.
+- Fixed auth-broker credential handling so late token-refresh responses cannot restore logged-out credentials or overwrite a newer login.
+
+## [18.4.10] - 2026-10-02
+
+### Fixed
+
+- Factory Droid login now reports the account's organization error instead of accepting a credential that every request rejects ([#14032](https://github.com/can1357/oh-my-pi/issues/14032)).
+- Fixed Cursor turns being aborted with "Provider stream stalled while waiting for the next event" right after a long local tool finished; the provider now gets a full idle window once local tool work completes ([#13682](https://github.com/can1357/oh-my-pi/pull/13682) by [@eggpeat](https://github.com/eggpeat))
+- Tool calls whose final argument JSON is cut off or followed by trailing text are no longer executed from an auto-closed preview. OpenAI Completions, Anthropic, Bedrock, Responses, Codex, Devin, Ollama, Apple, Cursor, GitLab Duo, and the in-band JSON dialects now give such a call the existing parse-error arguments, so the tool is not run and the model receives the parse error and can resend the call ([#13868](https://github.com/can1357/oh-my-pi/pull/13868) by [@alphastorm](https://github.com/alphastorm))
+- Fixed Cursor "prepaid balance is used up" (`USAGE_PRICING_REQUIRED`) failures repeating on the same account instead of rotating to a sibling Cursor credential ([#14053](https://github.com/can1357/oh-my-pi/issues/14053))
+- Sessions no longer get stuck on `400 string_above_max_length` after a model writes its whole tool invocation into the tool name. Tool calls with blank names, names longer than 128 characters, or names containing whitespace or control characters are dropped from replayed history, together with their tool results. This also applies when OpenAI Responses replays its stored native history ([#13985](https://github.com/can1357/oh-my-pi/pull/13985) by [@Xytronix](https://github.com/Xytronix)).
+- Fixed Bedrock Converse requests failing with a "bound to a different conversation" 400 after the system prompt changed under signed thinking: the request is retried once without replayed reasoning ([#14019](https://github.com/can1357/oh-my-pi/pull/14019) by [@nick-maderight](https://github.com/nick-maderight))
+
 ## [18.4.9] - 2026-10-01
 
 ### Fixed

package/dist/types/providers/transform-messages.d.ts

@@ -1,4 +1,11 @@
 import type { Api, AssistantMessage, Message, Model } from "../types.js";
+/**
+ * Whether a tool-call name cannot belong to any declared tool: missing, empty,
+ * longer than OpenAI's 128-character replay limit, or containing whitespace or
+ * control characters (tool schemas never allow them; their presence means the
+ * name slot carries invocation text).
+ */
+export declare function isMalformedToolCallName(name: unknown): boolean;
 /**
  * Normalize tool call ID for cross-provider compatibility.
  * OpenAI Responses API generates IDs that are 450+ chars with special characters like `|`.

package/dist/types/utils/event-stream.d.ts

@@ -2,6 +2,12 @@ import type { AssistantMessage, AssistantMessageEvent } from "../types.js";
 /** Anything a stream watchdog can consult for in-flight consumer-side local work. */
 export interface LocalWorkSource {
     readonly hasPendingLocalWork: boolean;
+    /**
+     * Epoch ms at which tracked local work last drained to zero, or 0 if none
+     * has completed. The provider cannot answer until it receives the local
+     * result, so idle watchdogs measure provider silence from this instant.
+     */
+    readonly localWorkSettledAt: number;
 }
 export declare class EventStream<T, R = T> implements AsyncIterable<T> {
     #private;
@@ -35,6 +41,8 @@ export declare class EventStream<T, R = T> implements AsyncIterable<T> {
     result(): Promise<R>;
     /** True while local work tracked via {@link trackLocalWork} — on this stream or a forwarded delegate — is pending. */
     get hasPendingLocalWork(): boolean;
+    /** Latest {@link LocalWorkSource.localWorkSettledAt} across this stream and a forwarded delegate. */
+    get localWorkSettledAt(): number;
     /**
      * Count `source`'s pending local work as this stream's own. Used when this
      * stream forwards another's events (Cursor discovered-id retry) so the

package/dist/types/utils/idle-iterator.d.ts

@@ -1,3 +1,4 @@
+import type { LocalWorkSource } from "./event-stream.js";
 /**
  * Returns the idle timeout used for provider streaming transports.
  *
@@ -86,15 +87,17 @@ export interface IdleTimeoutIteratorOptions {
      */
     isProgressItem?: (item: unknown) => boolean;
     /**
-     * Reports consumer-side local work in flight for the stream: the provider
-     * transport is waiting on a server-requested local tool bridge (e.g. the
-     * Cursor exec channel) before anything can flow upstream again. While it
-     * returns true, an expired idle / first-item deadline slides forward
-     * instead of aborting — the silence is ours, not a provider stall. The
-     * watchdog re-arms with a full budget once the local work completes, so a
-     * provider that stalls afterwards is still caught.
+     * Consumer-side local work in flight for the stream: the provider transport
+     * is waiting on a server-requested local tool bridge (e.g. the Cursor exec
+     * channel) before anything can flow upstream again. While work is pending,
+     * an expired idle / first-item deadline slides forward instead of aborting —
+     * the silence is ours, not a provider stall. The provider cannot respond
+     * before it receives the local result, so both deadlines are measured from
+     * no earlier than `localWorkSettledAt`: a tool that finishes just before the
+     * deadline gets a full budget, and a provider that stalls afterwards is
+     * still caught.
      */
-    hasPendingLocalWork?: () => boolean;
+    localWork?: LocalWorkSource;
     /**
      * Cancel iteration as soon as this signal aborts. Required for caller-driven
      * cancellation (ESC) when the underlying transport does not surface signal

package/dist/types/utils/tool-call-arguments.d.ts

@@ -0,0 +1,9 @@
+import type { ToolCall } from "../types.js";
+/** Final arguments must not reuse the streaming parser's auto-closed preview. */
+export declare function parseToolCallArguments(json: string | undefined): ToolCall["arguments"];
+/** Longest raw argument text kept in the parse-error diagnostic. */
+export declare const INVALID_ARGUMENTS_RAW_LIMIT = 512;
+/** Bound raw argument text for a diagnostic. Text this function already bounded is returned unchanged. */
+export declare function boundRawToolArguments(raw: string): string;
+/** Preserve a bounded diagnostic, never any partially recovered executable keys. */
+export declare function invalidToolCallArguments(raw: string, error: unknown): ToolCall["arguments"];

package/dist/types/utils.d.ts

@@ -63,6 +63,22 @@ export declare function sanitizeOpenAIResponsesAssistantHistoryItemsForReplay(it
  * Drop hidden-only fallback assistant replay after a native Responses snapshot is rejected.
  */
 export declare function sanitizeOpenAIResponsesAssistantFallbackItemsForReplay(items: ResponseInput): ResponseInput;
+/**
+ * Drop each native tool call with a malformed name and only the matching
+ * `function_call_output` / `custom_tool_call_output` in the same window.
+ *
+ * `call_id` is not unique across a snapshot. Pair the same way
+ * `sanitizeMalformedToolCalls` does for transcript messages: a per-id FIFO of
+ * malformed-ness, keyed by function vs custom, cleared at user/developer and
+ * other non-result client boundaries so a missing result cannot eat the next
+ * window's output. Returns `items` itself when nothing is malformed.
+ */
+export declare function dropMalformedOpenAIResponsesToolCalls<T extends {
+    type?: unknown;
+    call_id?: unknown;
+    name?: unknown;
+    role?: unknown;
+}>(items: readonly T[]): T[];
 export declare function createOpenAIResponsesHistoryPayload(provider: string, items: Array<Record<string, unknown>>, incremental?: boolean): OpenAIResponsesHistoryPayload;
 export declare function getOpenAIResponsesHistoryPayload(providerPayload: ProviderPayload | undefined, currentProvider: string, fallbackProvider?: string): OpenAIResponsesHistoryPayload | undefined;
 export declare function getOpenAIResponsesHistoryItems(providerPayload: ProviderPayload | undefined, currentProvider: string, fallbackProvider?: string): Array<Record<string, unknown>> | undefined;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@oh-my-pi/pi-ai",
-	"version": "18.4.9",
+	"version": "18.4.11",
 	"description": "Unified LLM API with automatic model discovery and provider configuration",
 	"keywords": [
 		"ai",
@@ -155,11 +155,11 @@
 		"fmt": "oxfmt --no-error-on-unmatched-pattern 'src/**/*.{ts,tsx}' '{test,bench,examples,scripts}/**/*.ts' '*.ts'"
 	},
 	"dependencies": {
-		"@oh-my-pi/omptype": "18.4.9",
-		"@oh-my-pi/pi-catalog": "18.4.9",
-		"@oh-my-pi/pi-natives": "18.4.9",
-		"@oh-my-pi/pi-utils": "18.4.9",
-		"@oh-my-pi/pi-wire": "18.4.9"
+		"@oh-my-pi/omptype": "18.4.11",
+		"@oh-my-pi/pi-catalog": "18.4.11",
+		"@oh-my-pi/pi-natives": "18.4.11",
+		"@oh-my-pi/pi-utils": "18.4.11",
+		"@oh-my-pi/pi-wire": "18.4.11"
 	},
 	"devDependencies": {
 		"@types/bun": "^1.3.14"

package/src/auth-broker/remote-store.ts

@@ -17,6 +17,7 @@ import {
 	type OAuthCredential,
 	type OAuthRefreshReason,
 	REMOTE_REFRESH_SENTINEL,
+	type RemoteOAuthCredential,
 	type StoredAuthCredential,
 	type StoredCredentialBlock,
 } from "../auth/types";
@@ -849,15 +850,7 @@ export class RemoteAuthCredentialStore implements AuthCredentialStore {
 
 	async markCredentialSuspect(credentialId: number, opts: { signal?: AbortSignal } = {}): Promise<void> {
 		this.#noteActivity();
-		const { entry } = await this.#client.refreshCredential(credentialId, opts.signal, "auth-recovery");
-		if (entry.credential.type !== "oauth") {
-			throw new AIError.AuthBrokerError(`Broker returned non-OAuth credential for id=${credentialId}`);
-		}
-		if (!this.#applyCredentialEntry(entry)) {
-			throw new AIError.AuthBrokerError(
-				`Broker refreshed credential id=${credentialId} outside the configured account pool`,
-			);
-		}
+		await this.#refreshThroughBroker(credentialId, opts.signal, "auth-recovery");
 		this.#maybeRefreshSnapshot("suspect credential refresh");
 	}
 
@@ -1168,21 +1161,12 @@ export class RemoteAuthCredentialStore implements AuthCredentialStore {
 		reason?: OAuthRefreshReason,
 	): Promise<OAuthCredentials> {
 		this.#noteActivity();
-		const { entry } = await this.#client.refreshCredential(credentialId, signal, reason);
-		if (entry.credential.type !== "oauth") {
-			throw new AIError.AuthBrokerError(`Broker returned non-OAuth credential for id=${credentialId}`);
-		}
-		if (!this.#applyCredentialEntry(entry)) {
-			throw new AIError.AuthBrokerError(
-				`Broker refreshed credential id=${credentialId} outside the configured account pool`,
-			);
-		}
+		const refreshed = await this.#refreshThroughBroker(credentialId, signal, reason);
 		if (!this.#streamingActive) {
 			await this.refreshSnapshot().catch(error => {
 				logger.debug("auth-broker snapshot refresh after credential refresh failed", { error: String(error) });
 			});
 		}
-		const refreshed = entry.credential;
 		return {
 			access: refreshed.access,
 			refresh: REMOTE_REFRESH_SENTINEL,
@@ -1194,6 +1178,38 @@ export class RemoteAuthCredentialStore implements AuthCredentialStore {
 		};
 	}
 
+	/**
+	 * Refresh one credential through the broker and apply the reply. If this
+	 * client's copy changed to something else while the request was in flight,
+	 * the reply may be stale, so the broker's current row wins: a logout stays
+	 * logged out and a newer login is kept.
+	 */
+	async #refreshThroughBroker(
+		credentialId: number,
+		signal?: AbortSignal,
+		reason?: OAuthRefreshReason,
+	): Promise<RemoteOAuthCredential> {
+		const local = () => this.#snapshot.credentials.find(candidate => candidate.id === credentialId);
+		const before = JSON.stringify(local()?.credential);
+		let { entry } = await this.#client.refreshCredential(credentialId, signal, reason);
+		const current = JSON.stringify(local()?.credential);
+		if (current !== before && current !== JSON.stringify(entry.credential)) {
+			await this.refreshSnapshot();
+			const latest = local();
+			if (!latest) throw new AIError.AuthBrokerError(`Credential id=${credentialId} was removed during refresh`);
+			entry = latest;
+		}
+		if (entry.credential.type !== "oauth") {
+			throw new AIError.AuthBrokerError(`Broker returned non-OAuth credential for id=${credentialId}`);
+		}
+		if (!this.#applyCredentialEntry(entry)) {
+			throw new AIError.AuthBrokerError(
+				`Broker refreshed credential id=${credentialId} outside the configured account pool`,
+			);
+		}
+		return entry.credential;
+	}
+
 	/**
 	 * Store-level hook consumed by `AuthStorage.usage.reports()` — proxies
 	 * to the broker's `/v1/usage` endpoint. Shared per-credential caches and

package/src/dialect/deepseek.ts

@@ -1,5 +1,6 @@
 import { parseJsonWithRepair } from "@oh-my-pi/pi-utils";
 import type { Message, ToolCall } from "../types";
+import { parseToolCallArguments } from "../utils/tool-call-arguments";
 import { asRecord, mintToolCallId, partialSuffixOverlapAny } from "./coercion";
 import dialectPrompt from "./deepseek.md" with { type: "text" };
 import { assistantTranscriptParts, collectToolResultRun, messageContentText, stringifyJson } from "./rendering";
@@ -477,11 +478,7 @@ export class DeepSeekInbandScanner implements InbandScanner {
 	#parseArgs(rawArgs: string): Record<string, unknown> {
 		const trimmed = rawArgs.trim();
 		if (trimmed.length === 0) return {};
-		try {
-			return asRecord(parseJsonWithRepair<unknown>(trimmed));
-		} catch {
-			return {};
-		}
+		return asRecord(parseToolCallArguments(trimmed));
 	}
 
 	#skipWhitespace(): string {

package/src/dialect/harmony.ts

@@ -1,5 +1,5 @@
-import { parseJsonWithRepair } from "@oh-my-pi/pi-utils";
 import type { Message, ToolCall } from "../types";
+import { parseToolCallArguments } from "../utils/tool-call-arguments";
 import { asRecord, mintToolCallId, partialSuffixOverlapAny } from "./coercion";
 import dialectPrompt from "./harmony.md" with { type: "text" };
 import {
@@ -225,11 +225,7 @@ export class HarmonyInbandScanner implements InbandScanner {
 	#parseArgs(): Record<string, unknown> {
 		const raw = this.#toolArgs.trim();
 		if (raw.length === 0) return {};
-		try {
-			return asRecord(parseJsonWithRepair<unknown>(raw));
-		} catch {
-			return {};
-		}
+		return asRecord(parseToolCallArguments(raw));
 	}
 
 	#clearBody(resetRawBlock = true): void {

package/src/dialect/hermes.ts

@@ -1,5 +1,6 @@
 import { parseJsonWithRepair, parseStreamingJson } from "@oh-my-pi/pi-utils";
 import type { Message, ToolCall } from "../types";
+import { parseToolCallArguments } from "../utils/tool-call-arguments";
 import { asRecord, mintToolCallId, partialSuffixOverlapAny } from "./coercion";
 import dialectPrompt from "./hermes.md" with { type: "text" };
 import { renderChatMlTranscript, renderDelimitedThinking, renderToolResponseResults, stringifyJson } from "./rendering";
@@ -147,11 +148,7 @@ export class HermesInbandScanner implements InbandScanner {
 			if (typeof parsed.name !== "string" || parsed.name.length === 0) return undefined;
 			let args = parsed.arguments;
 			if (typeof args === "string") {
-				try {
-					args = parseJsonWithRepair<unknown>(args);
-				} catch {
-					args = {};
-				}
+				args = parseToolCallArguments(args);
 			}
 			return { name: parsed.name, arguments: asRecord(args) };
 		} catch {

package/src/dialect/kimi.ts

@@ -1,5 +1,5 @@
-import { parseJsonWithRepair } from "@oh-my-pi/pi-utils";
 import type { Message, ToolCall } from "../types";
+import { parseToolCallArguments } from "../utils/tool-call-arguments";
 import { asRecord, normalizeKimiFunctionName, partialSuffixOverlapAny } from "./coercion";
 import dialectPrompt from "./kimi.md" with { type: "text" };
 import { assistantTranscriptParts, collectToolResultRun, messageContentText, stringifyJson } from "./rendering";
@@ -212,11 +212,7 @@ export class KimiInbandScanner implements InbandScanner {
 
 	#parseArgs(rawArgs: string): Record<string, unknown> {
 		if (rawArgs.length === 0) return {};
-		try {
-			return asRecord(parseJsonWithRepair<unknown>(rawArgs));
-		} catch {
-			return {};
-		}
+		return asRecord(parseToolCallArguments(rawArgs));
 	}
 
 	#nextTokenIndex(): number {

package/src/dialect/owned-stream.ts

@@ -13,6 +13,7 @@ import {
 	setStreamingPartialJson,
 } from "../utils/block-symbols";
 import { AssistantMessageEventStream } from "../utils/event-stream";
+import { INVALID_ARGUMENTS_RAW_LIMIT, invalidToolCallArguments } from "../utils/tool-call-arguments";
 import { buildStringArgsResolver } from "./coercion";
 import { createInbandScanner } from "./factory";
 import type { Dialect, InbandScanEvent, InbandScanner, InbandTool } from "./types";
@@ -180,6 +181,9 @@ class InbandStreamProjector {
 	#fedLen = 0;
 	#stopped = false;
 	#responsePending = "";
+	// Bounded tail of the text actually fed to the scanner: the diagnostic for an
+	// unfinished envelope, which excludes anything cut off after a response token.
+	#scannerTail = "";
 	// Provider-native tool calls forwarded live (e.g. Gemini still returns
 	// `functionCall` parts under owned mode), keyed by the inner stream's
 	// `contentIndex`. `#toolChannel` records which channel produced the turn's
@@ -291,7 +295,7 @@ class InbandStreamProjector {
 		const responseIndex = firstTokenIndex(combined, this.#responseOpenTokens);
 		if (responseIndex !== -1) {
 			this.#responsePending = "";
-			this.#apply(this.#scanner.feed(combined.slice(0, responseIndex)));
+			this.#apply(this.#feedScanner(combined.slice(0, responseIndex)));
 			this.#stopped = true;
 			return true;
 		}
@@ -303,7 +307,7 @@ class InbandStreamProjector {
 
 		const emitLength = combined.length - this.#responseOverlapLength;
 		this.#responsePending = combined.slice(emitLength);
-		this.#apply(this.#scanner.feed(combined.slice(0, emitLength)));
+		this.#apply(this.#feedScanner(combined.slice(0, emitLength)));
 		return false;
 	}
 
@@ -339,10 +343,26 @@ class InbandStreamProjector {
 		for (const block of message.content) if (block.type === "text") fullText += block.text;
 		if (!this.#stopped && fullText.length > this.#fedLen) this.text(fullText.slice(this.#fedLen));
 		if (!this.#stopped && this.#responsePending.length > 0) {
-			this.#apply(this.#scanner.feed(this.#responsePending));
+			this.#apply(this.#feedScanner(this.#responsePending));
 			this.#responsePending = "";
 		}
 		this.#apply(this.#scanner.flush());
+		// Scanners discard incomplete envelopes, but their toolStart previews already
+		// live in the message. Refuse those calls instead of executing partial fields.
+		// The unfinished envelope ends the scanner-fed text, so the diagnostic keeps
+		// that tail rather than any prose before the call.
+		for (const entry of this.#toolBlocks.values()) {
+			entry.block.arguments = invalidToolCallArguments(this.#scannerTail, "Incomplete in-band tool call");
+			if (this.#emitEvents) {
+				this.#out.push({
+					type: "toolcall_end",
+					contentIndex: entry.index,
+					toolCall: entry.block,
+					partial: this.#partial,
+				});
+			}
+		}
+		this.#toolBlocks.clear();
 		this.#closeText();
 		this.#closeThinking();
 		const hasTools = this.#partial.content.some(block => block.type === "toolCall");
@@ -353,6 +373,11 @@ class InbandStreamProjector {
 		return finalMessage;
 	}
 
+	#feedScanner(text: string): InbandScanEvent[] {
+		this.#scannerTail = (this.#scannerTail + text).slice(-INVALID_ARGUMENTS_RAW_LIMIT);
+		return this.#scanner.feed(text);
+	}
+
 	#apply(events: InbandScanEvent[]): void {
 		for (const event of events) {
 			switch (event.type) {

package/src/dialect/qwen3.ts

@@ -1,5 +1,6 @@
 import { parseJsonWithRepair } from "@oh-my-pi/pi-utils";
 import type { Message, ToolCall } from "../types";
+import { parseToolCallArguments } from "../utils/tool-call-arguments";
 import { asRecord, mintToolCallId, partialSuffixOverlapAny } from "./coercion";
 import dialectPrompt from "./qwen3.md" with { type: "text" };
 import { renderChatMlTranscript, renderToolResponseResults, stringifyJson } from "./rendering";
@@ -180,11 +181,7 @@ export class Qwen3InbandScanner implements InbandScanner {
 			if (typeof parsed.name !== "string" || parsed.name.length === 0) return undefined;
 			let args = parsed.arguments;
 			if (typeof args === "string") {
-				try {
-					args = parseJsonWithRepair<unknown>(args);
-				} catch {
-					args = {};
-				}
+				args = parseToolCallArguments(args);
 			}
 			return { name: parsed.name, arguments: asRecord(args) };
 		} catch {

package/src/error/rate-limit.ts

@@ -37,6 +37,12 @@ const CREDITS_EXHAUSTED_PATTERN =
 // in unrelated diagnostics ("Failed to fetch usage credits from billing
 // service"), which must not rotate a healthy credential.
 const ANTHROPIC_CREDITS_REQUIRED_PATTERN = /\busage credits are required\b|\bcredits_required\b/i;
+// Prepaid-balance exhaustion: Cursor ERROR_USAGE_PRICING_REQUIRED (code 44,
+// surfaced as 429) "Your prepaid balance is used up: Add funds or enable auto
+// top-up …". Account-local until topped up, so rotate to a sibling. The `\b`
+// after the code keeps USAGE_PRICING_REQUIRED_CHANGEABLE out.
+const PREPAID_BALANCE_EXHAUSTED_PATTERN =
+	/\busage_pricing_required\b|\bprepaid balance\b[^\n]{0,40}\b(?:used up|exhausted|depleted)\b/i;
 // Account billing ceilings: Anthropic "monthly spend limit" (#4787) and Google
 // "Your project has exceeded its monthly spending cap" (#13090). The `\b` after
 // `cap` keeps "spending capacity" — a throttle, not a billing ceiling — out.
@@ -260,6 +266,10 @@ export function parseRateLimitReason(errorMessage: string): RateLimitReason {
 		return "QUOTA_EXHAUSTED";
 	}
 
+	if (PREPAID_BALANCE_EXHAUSTED_PATTERN.test(errorMessage)) {
+		return "QUOTA_EXHAUSTED";
+	}
+
 	if (
 		lower.includes("per minute") ||
 		lower.includes("rate limit") ||
@@ -434,6 +444,7 @@ export function matchesUsageLimitText(errorMessage: string): boolean {
 	return (
 		USAGE_LIMIT_PATTERN.test(errorMessage) ||
 		ANTHROPIC_CREDITS_REQUIRED_PATTERN.test(errorMessage) ||
+		PREPAID_BALANCE_EXHAUSTED_PATTERN.test(errorMessage) ||
 		CREDITS_EXHAUSTED_PATTERN.test(errorMessage) ||
 		(CN_QUOTA_EXHAUSTED_PATTERN.test(errorMessage) && !CN_TRANSIENT_CAP_PATTERN.test(errorMessage)) ||
 		SPEND_LIMIT_PATTERN.test(errorMessage) ||