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

package/CHANGELOG.md

@@ -2,6 +2,24 @@
 
 ## [Unreleased]
 
+## [18.4.3] - 2026-09-28
+
+### Added
+
+- Added Command Code usage limits (5-hour, weekly, and credit balance) to /usage and the status line ([#13666](https://github.com/can1357/oh-my-pi/pull/13666) by [@riicodespretty](https://github.com/riicodespretty))
+
+### Changed
+
+- Reduced per-token CPU and allocations while streaming: the leaked-thinking scanner used for OpenAI-compatible and custom endpoints no longer allocates per character, chat-completions and Bedrock look up a delta's content block in constant time, Google, Gemini CLI, Codex, and chat-completions streams skip raw SSE line capture unless an `onSseEvent` listener is attached, and event streams drain backlogs without `Array#shift` ([#13650](https://github.com/can1357/oh-my-pi/pull/13650) by [@H4vC](https://github.com/H4vC)).
+
+## [18.4.2] - 2026-09-28
+
+### Fixed
+
+- Fixed successful Cursor agent turns being treated as context overflows, which ran overflow compaction and showed "Compaction freed too little context to make progress" while `/context` read well under the window; overflow detection now uses the reported context size instead of input totals summed across a turn's model calls ([#13608](https://github.com/can1357/oh-my-pi/pull/13608) by [@H4vC](https://github.com/H4vC))
+- Fixed Anthropic requests with thinking enabled failing on models whose output ceiling cannot fit the minimum thinking budget; thinking is now disabled for those requests instead ([#13359](https://github.com/can1357/oh-my-pi/pull/13359) by [@jchanghong023](https://github.com/jchanghong023))
+- Fixed Cursor native Grep/Glob results showing no matches or raw output, Write failing to create files, StrReplace missing edits beyond the read limit, and Read/Shell/Delete results misreporting content or metadata ([#13600](https://github.com/can1357/oh-my-pi/issues/13600)).
+
 ## [18.4.1] - 2026-09-28
 
 ### Fixed
@@ -2298,28 +2316,4 @@
 
 - Fixed `google-gemini-cli` ignoring `Model.requestModelId` when serializing the request model id
 
-## [15.11.5] - 2026-06-12
-
-### Added
-
-- Added `AuthStorage.listUsageHistory` to retrieve historical usage snapshots with optional `provider` and `sinceMs` filtering
-- Added durable usage-history persistence in the sqlite auth store so successful usage reports are recorded as time-series snapshots of limit utilization for later trend inspection
-- Added `AuthStorage.redeemResetCredit` to redeem stored OpenAI Codex saved rate-limit reset credits for a target account by `credentialId`, `accountId`, or `email`
-- Added `listCodexResetCredits` and `consumeCodexResetCredit` exports for OpenAI Codex saved reset-credit listing and redemption
-- Added `resetCredits` with `availableCount` to `UsageReport` so OpenAI Codex usage data now exposes redeemable rate-limit resets
-- Added `openai-codex-reset` exports via package barrel for out-of-band tooling usage
-- Added a one-shot request-debug target that writes the next provider HTTP request JSON to an explicit path.
-
-### Changed
-
-- Changed `AuthStorage.redeemResetCredit` to invalidate cached usage data after a successful redemption so the next usage report reflects the reset immediately
-
-### Fixed
-
-- Fixed temporary credential block state so redeemed reset credits immediately make the affected account selectable again after `redeemResetCredit` succeeds
-- Fixed one-shot request-debug path handling so an explicit request log target is consumed after the next request and no longer affects subsequent calls
-- Fixed explicit request-debug path mode to create missing parent directories before writing request logs
-- Fixed explicit request-debug mode to overwrite existing `.res.log` files for the requested path instead of failing when they already exist
-- Fixed OpenAI Responses `previous_response_id` chaining on Zero Data Retention orgs: the in-provider retry classifier missed the ZDR-specific 400 ("Previous response cannot be used for this organization due to Zero Data Retention"), so chained turns kept failing every other request after a brief recovery — the chain was reset but not disabled, so the next successful full-replay turn re-armed it. The ZDR phrasing is now classified categorically: one strike disables chaining for the session (skipping the three-strike circuit breaker) and the in-call retry drops `store: true`/`previous_response_id` and replays the full transcript instead ([#2341](https://github.com/can1357/oh-my-pi/issues/2341)).
-
-Older entries are archived in [packages/ai/CHANGELOG.md@dfbf3cc34eeb](https://github.com/can1357/oh-my-pi/blob/dfbf3cc34eeb5653580f51bfbcae558a9840f697/packages/ai/CHANGELOG.md).
+Older entries are archived in [packages/ai/CHANGELOG.md@689a3418cb45](https://github.com/can1357/oh-my-pi/blob/689a3418cb45d54a459cde2e1abf3f66f50e47a4/packages/ai/CHANGELOG.md).

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

@@ -126,9 +126,16 @@ export declare function classifyMessage(message: {
 export declare function attach<E extends object>(error: E, id: number): E;
 /** Overflow-classification evidence, including errors received before token usage is available. */
 export interface ContextOverflowMessage extends Pick<AssistantMessage, "errorId" | "stopReason" | "errorMessage"> {
-    readonly usage?: Pick<Usage, "input" | "cacheRead" | "cacheWrite">;
+    readonly usage?: Pick<Usage, "input" | "cacheRead" | "cacheWrite" | "contextTokens">;
 }
-/** Provider-reported usage proves context-window excess — authoritative, compaction-owned (#9235). */
+/**
+ * Provider-reported usage proves context-window excess — authoritative, compaction-owned (#9235).
+ *
+ * Prefers `contextTokens` when the provider reports it: providers that run
+ * several model calls per turn (Cursor's server-side tool loop) report
+ * `input`/`cacheRead` summed across those calls, which can exceed the window
+ * many times over while the conversation itself stays small.
+ */
 export declare function isUsageBackedContextOverflow(message: ContextOverflowMessage, contextWindow?: number): boolean;
 /** Classify overflow from error flags, available token usage, or provider error text. */
 export declare function isContextOverflow(message: ContextOverflowMessage, contextWindow?: number): boolean;

package/dist/types/images/openai-hosted.d.ts

@@ -1,3 +1,3 @@
-import type { Model } from "@oh-my-pi/pi-catalog/types";
+import { type Model } from "@oh-my-pi/pi-catalog/types";
 import type { ImageGenerationOptions, ImageGenerationRequest, ImageGenerationResult } from "./types.js";
 export declare function generateHostedImage(model: Model, request: ImageGenerationRequest, options: ImageGenerationOptions): Promise<ImageGenerationResult>;

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 { cursorEditOwnedReadPath, cursorRawReadPath, omitUndefinedArgs, piEscapeRegexLiteral, piGrepSkip, piJoinPath, piLimit, piLsPath, piReadDisplayPath, piReadPath, piReadPathHasRange, piTimeout, shellTimeoutSeconds, } from "../cursor-pi-args.js";
+export { cursorExecReadPath, cursorRawReadPath, omitUndefinedArgs, piEscapeRegexLiteral, piGrepSkip, piJoinPath, piLimit, piLsPath, piReadDisplayPath, piReadPath, piReadPathHasRange, piTimeout, shellTimeoutSeconds, } 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

@@ -22,18 +22,14 @@
  * 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 declare function piReadPath(readPath: string, offset?: number, limit?: number): string | null;
 /**
@@ -55,14 +51,13 @@ export declare function piReadPathHasRange(readPath: string): boolean;
  */
 export declare 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 declare function cursorEditOwnedReadPath(readPath: string, offset?: number, limit?: number): string | null;
+export declare function cursorExecReadPath(readPath: string, offset?: number, limit?: number): string | null;
 /**
  * The same range as {@link piReadPath}, rendered for a transcript block rather
  * than for execution.

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

@@ -0,0 +1,4 @@
+import type { CredentialRankingStrategy, UsageProvider } from "../usage.js";
+export declare const commandCodeUsageProvider: UsageProvider;
+/** Ranks Command Code accounts by the 5-hour and weekly credit windows. */
+export declare const commandCodeRankingStrategy: CredentialRankingStrategy;

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

@@ -5,6 +5,13 @@ export interface LocalWorkSource {
 }
 export declare class EventStream<T, R = T> implements AsyncIterable<T> {
     #private;
+    /**
+     * Events pushed while no consumer was waiting. The iterator dequeues by
+     * advancing {@link #queueHead} instead of `shift()` — O(remaining) per event,
+     * quadratic for a consumer draining a backlog — so while it drains, the
+     * slots before the head are consumed (cleared) placeholders. Do not mutate
+     * the array while the stream is being iterated.
+     */
     queue: T[];
     waiting: Array<{
         resolve: (value: IteratorResult<T>) => void;

package/dist/types/utils/openai-http.d.ts

@@ -28,8 +28,14 @@ export interface OpenAIStreamRequestInit {
     fetch?: FetchImpl;
     /** Optional caller-specific gate composed with shared transport retry exclusions. */
     shouldRetryResponse?: (response: Response, bodyText: string) => boolean | Promise<boolean>;
-    /** Raw wire-frame observer (`onSseEvent` debug pipeline). */
+    /**
+     * Raw wire-frame observer (`onSseEvent` debug pipeline). Leave it unset
+     * when no diagnostic listener exists: any observer turns on per-line raw
+     * capture for every frame.
+     */
     onSseEvent?: SseEventObserver;
+    /** Called when the stream ends on the OpenAI `[DONE]` sentinel; independent of {@link onSseEvent}. */
+    onDoneSentinel?: () => void;
 }
 export interface OpenAIStreamHandle<TEvent> {
     /** Decoded `data:` payloads; terminates on `[DONE]` or stream end. */

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@oh-my-pi/pi-ai",
-	"version": "18.4.1",
+	"version": "18.4.3",
 	"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.1",
-		"@oh-my-pi/pi-catalog": "18.4.1",
-		"@oh-my-pi/pi-natives": "18.4.1",
-		"@oh-my-pi/pi-utils": "18.4.1",
-		"@oh-my-pi/pi-wire": "18.4.1"
+		"@oh-my-pi/omptype": "18.4.3",
+		"@oh-my-pi/pi-catalog": "18.4.3",
+		"@oh-my-pi/pi-natives": "18.4.3",
+		"@oh-my-pi/pi-utils": "18.4.3",
+		"@oh-my-pi/pi-wire": "18.4.3"
 	},
 	"devDependencies": {
 		"@types/bun": "^1.3.14"

package/src/dialect/thinking.ts

@@ -36,6 +36,18 @@ const TAGS: readonly Tag[] = [
 const OPENS = TAGS.map(tag => tag.open);
 const IMPLIED_OPEN_TAGS = TAGS.filter(tag => tag.impliedOpen);
 const IMPLIED_OPEN_DELIMITERS = [...OPENS, ...IMPLIED_OPEN_TAGS.map(tag => tag.close)];
+/** A hold needs the buffer tail to be a proper prefix of some delimiter, so it must be shorter than this. */
+const MAX_DELIMITER_LENGTH = Math.max(...IMPLIED_OPEN_DELIMITERS.map(delimiter => delimiter.length));
+const BACKTICK = 0x60;
+const BOUNDARY_LEAD_CODES = [...IMPLIED_OPEN_DELIMITERS.map(delimiter => delimiter.charCodeAt(0)), BACKTICK];
+/**
+ * `1` at the char code of every character a {@link scanVisible} boundary can
+ * start on: the first character of any delimiter (a tag open, an implied close,
+ * or a partial of either) and the backtick. Every other character — including
+ * any code past the table — is skipped without comparing.
+ */
+const BOUNDARY_LEAD = new Uint8Array(Math.max(...BOUNDARY_LEAD_CODES) + 1);
+for (const code of BOUNDARY_LEAD_CODES) BOUNDARY_LEAD[code] = 1;
 
 export interface ThinkingInbandScannerOptions {
 	/**
@@ -240,20 +252,26 @@ type VisibleHit =
  */
 function scanVisible(buffer: string, final: boolean, impliedOpen: boolean): VisibleHit {
 	const delimiters = impliedOpen ? IMPLIED_OPEN_DELIMITERS : OPENS;
+	// Only the tail can be a proper prefix of a delimiter.
+	const holdFrom = final ? buffer.length : buffer.length - MAX_DELIMITER_LENGTH + 1;
 	for (let i = 0; i < buffer.length; i++) {
-		const tag = TAGS.find(candidate => buffer.startsWith(candidate.open, i));
-		if (tag) return { kind: "tag", index: i, tag };
+		const code = buffer.charCodeAt(i);
+		if (code >= BOUNDARY_LEAD.length || BOUNDARY_LEAD[code] === 0) continue;
+		for (const tag of TAGS) {
+			if (buffer.startsWith(tag.open, i)) return { kind: "tag", index: i, tag };
+		}
 		if (impliedOpen) {
-			const closed = IMPLIED_OPEN_TAGS.find(candidate => buffer.startsWith(candidate.close, i));
-			if (closed) return { kind: "impliedClose", index: i, tag: closed };
+			for (const tag of IMPLIED_OPEN_TAGS) {
+				if (buffer.startsWith(tag.close, i)) return { kind: "impliedClose", index: i, tag };
+			}
 		}
-		if (!final) {
+		if (i >= holdFrom) {
 			const rest = buffer.slice(i);
 			if (delimiters.some(delimiter => delimiter.length > rest.length && delimiter.startsWith(rest))) {
 				return { kind: "hold", index: i };
 			}
 		}
-		if (buffer[i] === "`") {
+		if (code === BACKTICK) {
 			const ticks = backtickRun(buffer, i);
 			if (!final && i + ticks === buffer.length) return { kind: "hold", index: i };
 			return { kind: "code", index: i, ticks };

package/src/error/flags.ts

@@ -875,14 +875,21 @@ export function attach<E extends object>(error: E, id: number): E {
 
 /** Overflow-classification evidence, including errors received before token usage is available. */
 export interface ContextOverflowMessage extends Pick<AssistantMessage, "errorId" | "stopReason" | "errorMessage"> {
-	readonly usage?: Pick<Usage, "input" | "cacheRead" | "cacheWrite">;
+	readonly usage?: Pick<Usage, "input" | "cacheRead" | "cacheWrite" | "contextTokens">;
 }
 
-/** Provider-reported usage proves context-window excess — authoritative, compaction-owned (#9235). */
+/**
+ * Provider-reported usage proves context-window excess — authoritative, compaction-owned (#9235).
+ *
+ * Prefers `contextTokens` when the provider reports it: providers that run
+ * several model calls per turn (Cursor's server-side tool loop) report
+ * `input`/`cacheRead` summed across those calls, which can exceed the window
+ * many times over while the conversation itself stays small.
+ */
 export function isUsageBackedContextOverflow(message: ContextOverflowMessage, contextWindow?: number): boolean {
 	const usage = message.usage;
 	if (!contextWindow || !usage) return false;
-	const inputTokens = usage.input + usage.cacheRead + usage.cacheWrite;
+	const inputTokens = usage.contextTokens ?? usage.input + usage.cacheRead + usage.cacheWrite;
 	return inputTokens > contextWindow;
 }
 

package/src/images/openai-hosted.ts

@@ -1,4 +1,4 @@
-import type { Api, Model } from "@oh-my-pi/pi-catalog/types";
+import { type Api, type Model, modelKind } from "@oh-my-pi/pi-catalog/types";
 import {
 	applyCodexResidencyHeader,
 	CODEX_BASE_URL,
@@ -155,7 +155,10 @@ export async function generateHostedImage(
 		action: content.length > 1 ? "edit" : "generate",
 		output_format: "webp",
 		...(size ? { size } : {}),
-		...(model.api === "openai-responses" ? { model: model.requestModelId ?? model.id } : {}),
+		// A chat model generating on its own lets the host pick the image model.
+		...(model.api === "openai-responses" && modelKind(model) === "image"
+			? { model: model.requestModelId ?? model.id }
+			: {}),
 	};
 	const body = {
 		model: carrier.requestModelId ?? carrier.id,

package/src/providers/amazon-bedrock.ts

@@ -446,6 +446,7 @@ export const streamBedrock: StreamFunction<"bedrock-converse-stream"> = (
 		};
 
 		const blocks = output.content as Block[];
+		const contentIndexByBlockIndex = new Map<number, number>();
 		let rawRequestDump: RawHttpRequestDump | undefined;
 		const region = resolveBedrockRegion(model.id, options);
 
@@ -640,7 +641,7 @@ export const streamBedrock: StreamFunction<"bedrock-converse-stream"> = (
 				if (messageType === "exception") {
 					const exceptionType = message.headers[":exception-type"] || "Exception";
 					const payload = safeParsePayload(message.payload) as { message?: string } | undefined;
-					const errorMessage = payload?.message || new TextDecoder().decode(message.payload);
+					const errorMessage = payload?.message || PAYLOAD_DECODER.decode(message.payload);
 					const text = `${exceptionType}: ${errorMessage}`;
 					throw new AIError.BedrockApiError(text, bedrockStreamExceptionStatus(exceptionType), {
 						code: exceptionType,
@@ -648,7 +649,7 @@ export const streamBedrock: StreamFunction<"bedrock-converse-stream"> = (
 				}
 				if (messageType === "error") {
 					const code = message.headers[":error-code"] || "UnknownError";
-					const errorMessage = message.headers[":error-message"] || new TextDecoder().decode(message.payload);
+					const errorMessage = message.headers[":error-message"] || PAYLOAD_DECODER.decode(message.payload);
 					throw new AIError.BedrockApiError(`${code}: ${errorMessage}`, bedrockStreamExceptionStatus(code), {
 						code,
 					});
@@ -673,16 +674,35 @@ export const streamBedrock: StreamFunction<"bedrock-converse-stream"> = (
 					}
 					case "contentBlockStart": {
 						if (!firstTokenTime) firstTokenTime = performance.now();
-						handleContentBlockStart(payload as ContentBlockStartEvent, blocks, output, stream, sentinelInjected);
+						handleContentBlockStart(
+							payload as ContentBlockStartEvent,
+							blocks,
+							contentIndexByBlockIndex,
+							output,
+							stream,
+							sentinelInjected,
+						);
 						break;
 					}
 					case "contentBlockDelta": {
 						if (!firstTokenTime) firstTokenTime = performance.now();
-						handleContentBlockDelta(payload as ContentBlockDeltaEvent, blocks, output, stream);
+						handleContentBlockDelta(
+							payload as ContentBlockDeltaEvent,
+							blocks,
+							contentIndexByBlockIndex,
+							output,
+							stream,
+						);
 						break;
 					}
 					case "contentBlockStop": {
-						handleContentBlockStop(payload as ContentBlockStopEvent, blocks, output, stream);
+						handleContentBlockStop(
+							payload as ContentBlockStopEvent,
+							blocks,
+							contentIndexByBlockIndex,
+							output,
+							stream,
+						);
 						break;
 					}
 					case "messageStop": {
@@ -782,18 +802,40 @@ export const streamBedrock: StreamFunction<"bedrock-converse-stream"> = (
 	return stream;
 };
 
+/** Shared across events: every payload decode is a complete, non-streaming call. */
+const PAYLOAD_DECODER = new TextDecoder();
+
 function safeParsePayload(payload: Uint8Array): unknown {
 	if (payload.length === 0) return {};
 	try {
-		return JSON.parse(new TextDecoder().decode(payload));
+		return JSON.parse(PAYLOAD_DECODER.decode(payload));
 	} catch {
 		return undefined;
 	}
 }
 
+/**
+ * Append a streamed block and index it by Bedrock's `contentBlockIndex`, so
+ * per-delta routing is an O(1) lookup instead of a scan over every block
+ * (quadratic over a long turn). The first block registered for an index wins,
+ * as the first-match scan did. Returns the block's content index.
+ */
+function pushStreamBlock(
+	blocks: Block[],
+	contentIndexByBlockIndex: Map<number, number>,
+	block: Block,
+	contentBlockIndex: number,
+): number {
+	const contentIndex = blocks.length;
+	blocks.push(block);
+	if (!contentIndexByBlockIndex.has(contentBlockIndex)) contentIndexByBlockIndex.set(contentBlockIndex, contentIndex);
+	return contentIndex;
+}
+
 function handleContentBlockStart(
 	event: ContentBlockStartEvent,
 	blocks: Block[],
+	contentIndexByBlockIndex: Map<number, number>,
 	output: AssistantMessage,
 	stream: AssistantMessageEventStream,
 	sentinelInjected: boolean,
@@ -815,29 +857,29 @@ function handleContentBlockStart(
 			[kStreamingPartialJson]: "",
 			[kStreamingBlockIndex]: index,
 		};
-		output.content.push(block);
-		stream.push({ type: "toolcall_start", contentIndex: blocks.length - 1, partial: output });
+		const contentIndex = pushStreamBlock(blocks, contentIndexByBlockIndex, block, index);
+		stream.push({ type: "toolcall_start", contentIndex, partial: output });
 	}
 }
 
 function handleContentBlockDelta(
 	event: ContentBlockDeltaEvent,
 	blocks: Block[],
+	contentIndexByBlockIndex: Map<number, number>,
 	output: AssistantMessage,
 	stream: AssistantMessageEventStream,
 ): void {
 	const contentBlockIndex = event.contentBlockIndex;
 	const delta = event.delta;
-	let index = blocks.findIndex(b => b[kStreamingBlockIndex] === contentBlockIndex);
+	let index = contentIndexByBlockIndex.get(contentBlockIndex) ?? -1;
 	let block = blocks[index];
 
 	if (delta?.text !== undefined) {
 		// If no text block exists yet, create one — `handleContentBlockStart` is not sent for text blocks
 		if (!block) {
 			const newBlock: Block = { type: "text", text: "", [kStreamingBlockIndex]: contentBlockIndex };
-			output.content.push(newBlock);
-			index = blocks.length - 1;
-			block = blocks[index];
+			index = pushStreamBlock(blocks, contentIndexByBlockIndex, newBlock, contentBlockIndex);
+			block = newBlock;
 			stream.push({ type: "text_start", contentIndex: index, partial: output });
 		}
 		if (block.type === "text") {
@@ -863,9 +905,8 @@ function handleContentBlockDelta(
 				thinkingSignature: "",
 				[kStreamingBlockIndex]: contentBlockIndex,
 			};
-			output.content.push(newBlock);
-			thinkingIndex = blocks.length - 1;
-			thinkingBlock = blocks[thinkingIndex];
+			thinkingIndex = pushStreamBlock(blocks, contentIndexByBlockIndex, newBlock, contentBlockIndex);
+			thinkingBlock = newBlock;
 			stream.push({ type: "thinking_start", contentIndex: thinkingIndex, partial: output });
 		}
 
@@ -901,10 +942,11 @@ function handleMetadata(event: MetadataEvent, model: Model<"bedrock-converse-str
 function handleContentBlockStop(
 	event: ContentBlockStopEvent,
 	blocks: Block[],
+	contentIndexByBlockIndex: Map<number, number>,
 	output: AssistantMessage,
 	stream: AssistantMessageEventStream,
 ): void {
-	const index = blocks.findIndex(b => b[kStreamingBlockIndex] === event.contentBlockIndex);
+	const index = contentIndexByBlockIndex.get(event.contentBlockIndex) ?? -1;
 	const block = blocks[index];
 	if (!block) return;
 

package/src/providers/aws-eventstream.ts

@@ -24,6 +24,8 @@ const PRELUDE_CRC_LEN = 4;
 const MESSAGE_CRC_LEN = 4;
 const HEADER_BLOCK_OFFSET = PRELUDE_LEN + PRELUDE_CRC_LEN;
 const MIN_MESSAGE_LEN = HEADER_BLOCK_OFFSET + MESSAGE_CRC_LEN;
+/** Shared across messages: every header decode is a complete, non-streaming call. */
+const HEADER_DECODER = new TextDecoder();
 
 export interface EventStreamMessage {
 	/** Lower-cased copy is *not* applied — Bedrock uses casing like `:event-type` verbatim. */
@@ -64,12 +66,11 @@ export function decodeMessage(frame: Uint8Array): EventStreamMessage {
 function parseHeaders(buf: Uint8Array): Record<string, string> {
 	const out: Record<string, string> = {};
 	const view = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
-	const decoder = new TextDecoder();
 	let p = 0;
 	while (p < buf.length) {
 		const nameLen = view.getUint8(p);
 		p += 1;
-		const name = decoder.decode(buf.subarray(p, p + nameLen));
+		const name = HEADER_DECODER.decode(buf.subarray(p, p + nameLen));
 		p += nameLen;
 		const type = view.getUint8(p);
 		p += 1;
@@ -108,7 +109,7 @@ function parseHeaders(buf: Uint8Array): Record<string, string> {
 				// string
 				const len = view.getUint16(p, false);
 				p += 2;
-				out[name] = decoder.decode(buf.subarray(p, p + len));
+				out[name] = HEADER_DECODER.decode(buf.subarray(p, p + len));
 				p += len;
 				break;
 			}

package/src/providers/azure-openai-responses.ts

@@ -1,11 +1,10 @@
-import { $env } from "@oh-my-pi/pi-utils";
+import { $env, type ServerSentEvent } from "@oh-my-pi/pi-utils";
 import * as AIError from "../error";
 import { getEnvApiKey } from "../stream";
 import type {
 	AssistantMessage,
 	Context,
 	Model,
-	RawSseEvent,
 	ServiceTier,
 	StreamFunction,
 	StreamOptions,
@@ -104,7 +103,7 @@ const streamAzureOpenAIResponsesOnce = (
 		const { requestAbortController, requestSignal } = abortTracker;
 		const onSseEvent = options?.onSseEvent;
 		const rawSseObserver = onSseEvent
-			? (event: RawSseEvent) => {
+			? (event: ServerSentEvent) => {
 					if (!event.event && event.data && event.data !== "[DONE]") {
 						try {
 							const parsed = JSON.parse(event.data);
@@ -120,7 +119,7 @@ const streamAzureOpenAIResponsesOnce = (
 							}
 						} catch {}
 					}
-					onSseEvent(event, model);
+					onSseEvent({ event: event.event, data: event.data, raw: [...event.raw] }, model);
 				}
 			: undefined;
 

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);