@oh-my-pi/pi-ai 18.4.0 → 18.4.2

package/src/error/rate-limit.ts

@@ -110,6 +110,17 @@ export function isDashScopeTokenLimitText(errorMessage: string): boolean {
 	);
 }
 
+// Rolling per-minute token/request throttles (TPM/RPM). Providers report these
+// with quota wording — "tpm exhausted (type=quota_exceeded_error)",
+// "inference exceeds tpm/rpm limit", "RateLimitExceeded.EndpointTPMExceeded" —
+// but the window self-heals within the minute, so they belong in the transient
+// backoff lane, not the 30-minute credential-blocking quota lane (#13253).
+// Deliberately subordinate to the account-scoped arms of
+// {@link parseRateLimitReason}: a message that also carries a plan/spend/
+// account-quota signal classifies there first and keeps its quota verdict.
+const TPM_RPM_THROTTLE_PATTERN =
+	/\b(?:tpm|rpm)\b[^\n]{0,40}\b(?:exhaust\w*|exceed\w*|limit\w*|throttl\w*|reach\w*)\b|\b(?:exhaust\w*|exceed\w*|limit\w*|throttl\w*|reach\w*)\b[^\n]{0,40}\b(?:tpm|rpm)\b|\bRateLimitExceeded\.(?:Endpoint)?(?:TPM|RPM)\w*/i;
+
 const GOOGLE_RPC_ERROR_INFO_TYPE = "type.googleapis.com/google.rpc.ErrorInfo";
 const ANTIGRAVITY_MODEL_QUOTA_PATTERN = /\bexhausted your capacity on this model\b/i;
 const LONG_RATE_LIMIT_DELAY_MS = 5 * 60 * 1000;
@@ -180,8 +191,9 @@ function isQuotaExhaustedReason(reason: RateLimitReason): boolean {
  * Classify a rate-limit error message into a reason category.
  * Priority order: explicit details in a resource-exhausted error > QUOTA
  * (Antigravity "quota will reset") > CN quota > DASHSCOPE_TOKEN_LIMIT (TPM/TPS
- * throttle) > CONCURRENT_LIMIT > MODEL_CAPACITY > QUOTA (account) > RATE_LIMIT >
- * QUOTA (generic) > SERVER_ERROR > bare resource-exhausted > UNKNOWN.
+ * throttle) > CONCURRENT_LIMIT > MODEL_CAPACITY > QUOTA (account) > RATE_LIMIT
+ * (including TPM/RPM rolling windows) > QUOTA (generic) > SERVER_ERROR > bare
+ * resource-exhausted > UNKNOWN.
  *
  * Bare "resource exhausted" / "resource_exhausted" maps to MODEL_CAPACITY (transient, short wait).
  * Explicit details such as "quota exceeded" retain their normal classification.
@@ -252,7 +264,8 @@ export function parseRateLimitReason(errorMessage: string): RateLimitReason {
 		lower.includes("per minute") ||
 		lower.includes("rate limit") ||
 		lower.includes("too many requests") ||
-		lower.includes("presque")
+		lower.includes("presque") ||
+		TPM_RPM_THROTTLE_PATTERN.test(errorMessage)
 	) {
 		return "RATE_LIMIT_EXCEEDED";
 	}
@@ -411,6 +424,13 @@ export function matchesUsageLimitText(errorMessage: string): boolean {
 	const structuredReason = parseGoogleRpcRateLimitReason(errorMessage);
 	if (structuredReason !== undefined) return isQuotaExhaustedReason(structuredReason);
 	if (isDashScopeTokenLimitText(errorMessage)) return false;
+	// Rolling TPM/RPM windows self-heal, so they never rotate a credential. The
+	// reason re-check is the precedence guard: an account-scoped cap that merely
+	// quotes a TPM number resolves to QUOTA_EXHAUSTED earlier in that ladder and
+	// keeps its usage-limit verdict.
+	if (TPM_RPM_THROTTLE_PATTERN.test(errorMessage) && parseRateLimitReason(errorMessage) === "RATE_LIMIT_EXCEEDED") {
+		return false;
+	}
 	return (
 		USAGE_LIMIT_PATTERN.test(errorMessage) ||
 		ANTHROPIC_CREDITS_REQUIRED_PATTERN.test(errorMessage) ||

package/src/providers/anthropic.ts

@@ -15,6 +15,7 @@ import {
 	parseStreamingJsonThrottled,
 	readSseEvents,
 } from "@oh-my-pi/pi-utils";
+import { NO_AUTH_SENTINEL } from "../auth-retry";
 import { renderDemotedThinking } from "../dialect/demotion";
 import * as AIError from "../error";
 import { getEnvApiKey, OUTPUT_FALLBACK_BUFFER } from "../stream";
@@ -404,10 +405,17 @@ export function buildAnthropicHeaders(options: AnthropicHeaderOptions): Record<s
 		};
 		return allowAnthropicHeaderOverrides ? mergeHeaders(headers, anthropicHeaderOverrides) : headers;
 	} else if (!isOfficialAnthropicApiUrl(options.baseUrl)) {
+		// A keyless provider (`auth: none`) resolves to the `N/A` sentinel
+		// rather than a real key; custom endpoints that authenticate via their
+		// own headers may reject a bogus bearer, so send no Authorization —
+		// same sentinel guard as the openai transports. A caller-supplied
+		// Authorization in `model.headers` still wins.
+		const bearer =
+			incomingAuthorization ?? (options.apiKey !== NO_AUTH_SENTINEL ? `Bearer ${options.apiKey}` : undefined);
 		return {
 			...modelHeaders,
 			Accept: acceptHeader,
-			Authorization: incomingAuthorization ?? `Bearer ${options.apiKey}`,
+			...(bearer ? { Authorization: bearer } : {}),
 			...sharedHeaders,
 			...(incomingUserAgent ? { "User-Agent": incomingUserAgent } : {}),
 			...(betaHeader ? { "anthropic-beta": betaHeader } : {}),
@@ -3723,8 +3731,13 @@ export function buildAnthropicClientOptions(args: AnthropicClientOptionsArgs): A
 	// the proxy to deal with two competing credentials when the user explicitly
 	// asked for one.
 	const authorizationHeader = getHeaderCaseInsensitive(defaultHeaders, "Authorization");
+	// A keyless provider resolves to the `N/A` sentinel, for which no
+	// Authorization was built above; the client would otherwise inject a
+	// bogus `X-Api-Key: N/A` of its own.
 	const shouldSuppressClientApiKey =
-		!oauthToken && !model.compat.officialEndpoint && typeof authorizationHeader === "string";
+		!oauthToken &&
+		!model.compat.officialEndpoint &&
+		(typeof authorizationHeader === "string" || apiKey === NO_AUTH_SENTINEL);
 
 	return {
 		isOAuthToken: oauthToken,
@@ -4004,34 +4017,33 @@ function applyPromptCaching(params: MessageCreateParamsStreaming, cacheControl?:
 }
 
 /**
- * Trailing system-prompt segments carrying per-turn volatile content (memory
- * recall blocks). They are rendered by the coding agent as their own
- * `systemPrompt` array elements and appended last, so on the wire they
- * normally form a volatile suffix after the stable prefix. The system cache
- * breakpoint anchors on the last stable segment instead of the array tail, so
- * a recall refresh re-bills only the suffix and the message tail for one turn
- * while the tools+stable-system prefix stays a cache hit.
+ * System-prompt segments whose bytes differ between sessions or turns of the
+ * same agent: per-turn memory recall (`<memories>`) and the coding agent's
+ * working-directory context (`<project-context>`: context files with their
+ * paths, workspace tree, workspace roots, session append text; advisors use
+ * the same tag for their context-file block). The coding agent renders them
+ * as their own `systemPrompt` array elements after the large static prompt.
+ * The system cache breakpoint anchors on the block right before the first
+ * such segment, so the static head is shared byte-for-byte across sessions in
+ * different directories (e.g. one git worktree per task) and a recall refresh
+ * re-bills only the suffix and the message tail.
  *
- * Only a genuinely trailing volatile run counts: a `before_agent_start`
- * extension override may append a stable policy block after the staged recall
- * block, and that block stays in the cached head. A volatile block stranded
- * mid-array still poisons the prefix at its position — prefix caching is
- * positional, so no classification can save the bytes after it.
+ * Everything from the first volatile segment on sits after the head
+ * breakpoint, including stable blocks appended behind it (per-spawn subagent
+ * role text, `before_agent_start` extension policy): prefix caching is
+ * positional, so bytes after a changing segment can never extend the cached
+ * head anyway; the rolling message breakpoints still cover them.
  *
- * Detection is by our own markup, not model identity: recall blocks always
- * open with `<memories>`. Stable segments containing recalled text elsewhere
- * (e.g. quoted in conversation) are unaffected — only a leading tag counts.
+ * Detection is by our own markup, not model identity: only a leading tag
+ * counts, so stable segments quoting these tags elsewhere are unaffected.
  */
-const VOLATILE_SYSTEM_SEGMENT_MARKERS = ["<memories>"];
+const VOLATILE_SYSTEM_SEGMENT_MARKERS = ["<memories>", "<project-context>"];
 
-function stableSystemSuffixStart(systemBlocks: readonly AnthropicSystemBlock[]): number {
-	let start = systemBlocks.length;
-	while (start > 0) {
-		const text = systemBlocks[start - 1]?.text ?? "";
-		if (!VOLATILE_SYSTEM_SEGMENT_MARKERS.some(marker => text.startsWith(marker))) break;
-		start--;
-	}
-	return start;
+function volatileSystemSuffixStart(systemBlocks: readonly AnthropicSystemBlock[]): number {
+	const start = systemBlocks.findIndex(block =>
+		VOLATILE_SYSTEM_SEGMENT_MARKERS.some(marker => block.text.startsWith(marker)),
+	);
+	return start === -1 ? systemBlocks.length : start;
 }
 
 /**
@@ -4045,10 +4057,10 @@ function stableSystemSuffixStart(systemBlocks: readonly AnthropicSystemBlock[]):
  * (Claude Code, Pi) use. Without it, the general API-key path anchors only the
  * moving message tail, so tail churn re-writes the whole head uncached.
  *
- * Volatile trailing segments (memory recall) sit after the breakpoint, so a
- * recall refresh re-bills only the suffix and the tail for one turn instead of
- * the whole head. When every system block is volatile there is no stable
- * boundary and the breakpoint stays on the array tail (previous behavior).
+ * Volatile segments (memory recall, working-directory context) sit after the
+ * breakpoint, so a recall refresh or a different cwd re-bills only the suffix
+ * and the tail instead of the whole head. When every system block is volatile
+ * there is no stable boundary and the breakpoint stays on the array tail.
  *
  * Anthropic allows at most 4 cache breakpoints per request. At most one is
  * spent on tools and one on system here, leaving the remaining budget for
@@ -4058,9 +4070,12 @@ function stableSystemSuffixStart(systemBlocks: readonly AnthropicSystemBlock[]):
  * sit first in wire order and survive message rewrites, and sibling subagents of
  * the same definition share this prefix byte for byte.
  *
- * When the OAuth Claude Code path already anchors its identity system block at
- * buildAnthropicSystemBlocks, the system check skips adding a second system
- * breakpoint, while the tool check still anchors the last tool definition.
+ * The OAuth Claude Code path pre-decorates its identity system block in
+ * buildAnthropicSystemBlocks. That breakpoint moves to the anchor block instead
+ * of a second one being added: the identity block is a prefix of the anchored
+ * head, so the move keeps the budget at last tool + last stable system block +
+ * 2 message breakpoints while the agent's static system prompt, not just the
+ * identity line, becomes a cached prefix of its own.
  *
  * Runs on the fresh system blocks and wire tools built for this request, after
  * the declared tool list was derived from the transcript's request controls.
@@ -4084,26 +4099,20 @@ function applyHeadCaching(
 	}
 
 	if (systemBlocks && systemBlocks.length > 0) {
-		// Anchor on the last stable block so a volatile recall suffix refresh
-		// re-bills only the suffix, not the whole head. The skip-if-decorated
-		// check applies only when there is no volatile suffix (previous
-		// behavior): with a suffix present the boundary anchor is added
-		// whenever the anchor block itself lacks a breakpoint, even if the
-		// OAuth path pre-decorated its identity block — otherwise the only
-		// system breakpoint sits before the stable prompt and a recall
-		// refresh re-bills it. The message budget in `applyPromptCaching`
-		// shrinks accordingly (4 minus head breakpoints). All-volatile falls
-		// back to tail anchoring (previous behavior).
-		const suffixStart = stableSystemSuffixStart(systemBlocks);
-		if (suffixStart === systemBlocks.length) {
-			if (!systemBlocks.some(block => block.cache_control != null)) {
-				const lastBlock = systemBlocks[systemBlocks.length - 1];
-				if (lastBlock) lastBlock.cache_control = cloneAnthropicCacheControl(cacheControl);
-			}
-		} else {
-			const anchorIndex = suffixStart === 0 ? systemBlocks.length - 1 : suffixStart - 1;
-			const anchor = systemBlocks[anchorIndex];
-			if (anchor && anchor.cache_control == null) anchor.cache_control = cloneAnthropicCacheControl(cacheControl);
+		// Anchor on the last block before the volatile suffix so a recall
+		// refresh or a different working directory re-bills only the suffix,
+		// not the whole head. An earlier system breakpoint (the OAuth identity
+		// block) moves to the anchor rather than staying as a second one: a
+		// breakpoint left on the identity block caches only tools + identity,
+		// and keeping both would take a rolling message breakpoint from
+		// `applyPromptCaching` (4 minus head breakpoints). All-volatile falls
+		// back to tail anchoring.
+		const suffixStart = volatileSystemSuffixStart(systemBlocks);
+		const anchorIndex = suffixStart === 0 ? systemBlocks.length - 1 : suffixStart - 1;
+		const anchor = systemBlocks[anchorIndex];
+		if (anchor && anchor.cache_control == null) {
+			for (const block of systemBlocks) delete block.cache_control;
+			anchor.cache_control = cloneAnthropicCacheControl(cacheControl);
 		}
 	}
 }

package/src/providers/cowork-fetch.ts

@@ -125,11 +125,53 @@ function decodedResponseStream(message: IncomingMessage): stream.Readable {
 	return stream.pipeline(message, decoder, () => {});
 }
 
-function createResponse(message: IncomingMessage, method: string): Response {
+/**
+ * Bun's `node:http` shim reports a response body cut off mid-stream (peer reset,
+ * dead connection) as a bare `Error("aborted")` with code `ECONNRESET` — wording
+ * indistinguishable from a cancellation, so retry classification treated every
+ * mid-stream drop on this transport as terminal. Native `fetch` reports the same
+ * failure as "The socket connection was closed unexpectedly", a recognized
+ * transient. Re-raise with that wording, keeping the original as `cause`; a
+ * caller abort keeps its own error.
+ */
+function withFetchParityErrors(
+	body: ReadableStream<Uint8Array>,
+	signal: AbortSignal | undefined,
+): ReadableStream<Uint8Array> {
+	const reader = body.getReader();
+	return new ReadableStream<Uint8Array>({
+		async pull(controller) {
+			try {
+				const chunk = await reader.read();
+				if (chunk.done) controller.close();
+				else controller.enqueue(chunk.value);
+			} catch (error) {
+				const prematureClose =
+					!signal?.aborted &&
+					error instanceof Error &&
+					error.message === "aborted" &&
+					(error as NodeJS.ErrnoException).code === "ECONNRESET";
+				controller.error(
+					prematureClose
+						? Object.assign(
+								new Error("The socket connection was closed unexpectedly before the response completed", {
+									cause: error,
+								}),
+								{ code: "ECONNRESET" },
+							)
+						: error,
+				);
+			}
+		},
+		cancel: reason => reader.cancel(reason),
+	});
+}
+
+function createResponse(message: IncomingMessage, method: string, signal: AbortSignal | undefined): Response {
 	const status = message.statusCode;
 	if (status === undefined) throw new Error("Cowork transport received a response without an HTTP status.");
 	const hasBody = method !== "HEAD" && status !== 204 && status !== 304;
-	const body = hasBody ? stream.Readable.toWeb(decodedResponseStream(message)) : null;
+	const body = hasBody ? withFetchParityErrors(stream.Readable.toWeb(decodedResponseStream(message)), signal) : null;
 	return new Response(body, {
 		status,
 		statusText: message.statusMessage,
@@ -190,7 +232,7 @@ async function sendCoworkRequest(
 				});
 			}
 			try {
-				result.resolve(createResponse(message, method));
+				result.resolve(createResponse(message, method, signal));
 			} catch (error) {
 				message.destroy();
 				release();

package/src/providers/cursor/exec-modern.ts

@@ -74,7 +74,7 @@ import type { ToolResultMessage } from "../../types";
  * and their translation are consumed together.
  */
 export {
-	cursorEditOwnedReadPath,
+	cursorExecReadPath,
 	cursorRawReadPath,
 	omitUndefinedArgs,
 	piEscapeRegexLiteral,

package/src/providers/cursor-pi-args.ts

@@ -25,18 +25,14 @@ import * as path from "node:path";
  * A `pi_read` range composed onto the path as `read`'s inline `:raw:N+K`
  * selector.
  *
- * `read` exposes no range kwargs, so an uncomposed range reads the whole file.
- * `offset` is a 1-indexed start clamped like the reference's
- * `Math.max(0, offset - 1)` over 0-indexed lines; `limit` is a line count.
- * `null` marks a present `limit: 0` — zero lines, which no selector expresses
- * and which must not degrade into a whole-file read.
- *
- * The range is `raw` because a plain `:N+K` deliberately pads with one leading
- * and three trailing context lines: helpful for a human reading a snippet,
- * wrong for a caller that asked for exactly `limit` lines from `offset`. The
- * wire result is an opaque `output` string, so the hashline and line-number
- * gutter that `raw` also drops carry nothing the frame's contract needs.
- * A range-free read keeps the ordinary form — whole-file reads want them.
+ * `read` exposes no range kwargs; `offset` and `limit` are composed onto the
+ * path. A negative offset needs the source line count and is resolved by the
+ * coding-agent bridge before calling this helper. `limit: 0` has no selector
+ * representation and returns `null`.
+ *
+ * Range selectors are raw because plain ranges add context lines. Cursor
+ * numbers the returned text itself, so it cannot use read's hashline gutter.
+ * Use [`cursorExecReadPath`] for a range-free read, which also needs `:raw`.
  */
 export function piReadPath(readPath: string, offset?: number, limit?: number): string | null {
 	if (limit !== undefined && Math.floor(limit) <= 0) return null;
@@ -100,14 +96,13 @@ export function cursorRawReadPath(readPath: string): string {
 }
 
 /**
- * Path the edit-owned materialization read should execute.
+ * Raw selector for a Cursor exec read, including edit-owned materialization.
  *
- * Range is composed first (`piReadPath` already uses `:raw` for a range),
- * then a whole-file path is forced onto `:raw`. The caller must drop
- * `offset`/`limit` after this so the bridge's `piReadPath` cannot append a
- * second `:raw` onto the already-composed selector.
+ * Compose a requested window before forcing `:raw` on whole-file reads. The
+ * caller drops `offset`/`limit` after composing so the handler cannot append
+ * another selector.
  */
-export function cursorEditOwnedReadPath(readPath: string, offset?: number, limit?: number): string | null {
+export function cursorExecReadPath(readPath: string, offset?: number, limit?: number): string | null {
 	const ranged = piReadPath(readPath, offset, limit);
 	if (ranged === null) return null;
 	return cursorRawReadPath(ranged);