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

package/CHANGELOG.md

@@ -2,6 +2,16 @@
 
 ## [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
@@ -2306,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/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/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.2",
+	"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.2",
-		"@oh-my-pi/pi-catalog": "18.4.2",
-		"@oh-my-pi/pi-natives": "18.4.2",
-		"@oh-my-pi/pi-utils": "18.4.2",
-		"@oh-my-pi/pi-wire": "18.4.2"
+		"@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/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/google-gemini-cli.ts

@@ -751,9 +751,16 @@ export const streamGoogleGeminiCli: StreamFunction<"google-gemini-cli"> = (
 				const responseSignal = options?.signal
 					? AbortSignal.any([options.signal, responseAbortController.signal])
 					: responseAbortController.signal;
+				const onSseEvent = options?.onSseEvent;
 				const chunks = iterateWithIdleTimeout(
-					readSseJson<CloudCodeAssistResponseChunk>(activeResponse.body, responseSignal, event =>
-						options?.onSseEvent?.({ event: event.event, data: event.data, raw: [...event.raw] }, model),
+					// Attach the observer only when a diagnostic listener exists: any
+					// observer turns on per-line raw capture in `readSseJson`.
+					readSseJson<CloudCodeAssistResponseChunk>(
+						activeResponse.body,
+						responseSignal,
+						onSseEvent
+							? event => onSseEvent({ event: event.event, data: event.data, raw: [...event.raw] }, model)
+							: undefined,
 					),
 					{
 						firstItemTimeoutMs: firstEventTimeoutMs,

package/src/providers/google-shared.ts

@@ -4,7 +4,7 @@
 
 import { scheduler } from "node:timers/promises";
 import { calculateCost } from "@oh-my-pi/pi-catalog/models";
-import { readSseJson } from "@oh-my-pi/pi-utils";
+import { readSseJson, type SseEventObserver } from "@oh-my-pi/pi-utils";
 import { renderDemotedThinking } from "../dialect/demotion";
 import { ThinkingFenceStripper } from "../dialect/thinking-fence-strip";
 import * as AIError from "../error";
@@ -1014,13 +1014,17 @@ export function streamGoogleGenAI<T extends "google-generative-ai" | "google-ver
 			let body = await openStream();
 			stream.push({ type: "start", partial: output });
 
+			// Attach the observer only when a diagnostic listener exists: any
+			// observer turns on per-line raw capture in `readSseJson`.
+			const onSseEvent = options?.onSseEvent;
+			const sseObserver: SseEventObserver | undefined = onSseEvent
+				? event => onSseEvent({ event: event.event, data: event.data, raw: [...event.raw] }, model)
+				: undefined;
 			// Gemini occasionally finishes with `finishReason: STOP` while emitting only an empty
 			// text part and no tool call. Delivered as-is the agent receives a blank message and
 			// silently halts mid-task, so retry a bounded number of times before giving up.
 			for (let emptyAttempt = 0; ; emptyAttempt++) {
-				const googleStream = readSseJson<GenerateContentResponse>(body, options?.signal, event =>
-					options?.onSseEvent?.({ event: event.event, data: event.data, raw: [...event.raw] }, model),
-				);
+				const googleStream = readSseJson<GenerateContentResponse>(body, options?.signal, sseObserver);
 				await consumeGoogleStream({
 					googleStream,
 					output,

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

@@ -4730,8 +4730,14 @@ async function openCodexSseEventStream(
 	if (!response.body) {
 		throw new CodexProviderStreamError("No response body", false);
 	}
-	return readSseJson<Record<string, unknown>>(response.body, signal, event =>
-		onSseEvent?.({ event: event.event, data: event.data, raw: [...event.raw] }, undefined),
+	// Attach the observer only when a diagnostic listener exists: any observer
+	// turns on per-line raw capture in `readSseJson`.
+	return readSseJson<Record<string, unknown>>(
+		response.body,
+		signal,
+		onSseEvent
+			? event => onSseEvent({ event: event.event, data: event.data, raw: [...event.raw] }, undefined)
+			: undefined,
 	);
 }
 

package/src/providers/openai-completions.ts

@@ -4,7 +4,13 @@ import { resolveWireModelId } from "@oh-my-pi/pi-catalog/model-thinking";
 import { calculateCost } from "@oh-my-pi/pi-catalog/models";
 import type { ResolvedOpenAICompat } from "@oh-my-pi/pi-catalog/types";
 import { clinePassClientHeaders } from "@oh-my-pi/pi-catalog/wire/cline-pass";
-import { $env, logger, parseStreamingJson, parseStreamingJsonThrottled } from "@oh-my-pi/pi-utils";
+import {
+	$env,
+	logger,
+	parseStreamingJson,
+	parseStreamingJsonThrottled,
+	type ServerSentEvent,
+} from "@oh-my-pi/pi-utils";
 import { renderDemotedThinking } from "../dialect/demotion";
 import * as AIError from "../error";
 import { getKimiCommonHeaders } from "../registry/oauth/kimi";
@@ -16,7 +22,6 @@ import type {
 	MessageAttribution,
 	Model,
 	ProviderSessionState,
-	RawSseEvent,
 	ServiceTier,
 	StopReason,
 	StreamFunction,
@@ -800,28 +805,29 @@ const streamOpenAICompletionsOnce = (
 		// Track the OpenAI `[DONE]` sentinel independently of `onSseEvent`: it is
 		// the streaming protocol's terminal signal, so a stream that ends with it
 		// completed by server agreement even when no `finish_reason` chunk arrived.
+		// It arrives through `onDoneSentinel`, so the diagnostic observer below
+		// stays unset (and raw wire-line capture off) when nobody listens.
 		let sawDoneSentinel = false;
-		const rawSseObserver = (event: RawSseEvent) => {
-			if (event.data === "[DONE]") sawDoneSentinel = true;
-			if (onSseEvent) {
-				if (!event.event && event.data && event.data !== "[DONE]") {
-					try {
-						const parsed = JSON.parse(event.data);
-						const resolvedEvent =
-							typeof parsed.type === "string"
-								? parsed.type
-								: typeof parsed.object === "string"
-									? parsed.object
-									: null;
-						if (resolvedEvent) {
-							event.event = resolvedEvent;
-							event.raw = [`event: ${resolvedEvent}`, ...event.raw];
-						}
-					} catch {}
+		const rawSseObserver = onSseEvent
+			? (event: ServerSentEvent) => {
+					if (!event.event && event.data && event.data !== "[DONE]") {
+						try {
+							const parsed = JSON.parse(event.data);
+							const resolvedEvent =
+								typeof parsed.type === "string"
+									? parsed.type
+									: typeof parsed.object === "string"
+										? parsed.object
+										: null;
+							if (resolvedEvent) {
+								event.event = resolvedEvent;
+								event.raw = [`event: ${resolvedEvent}`, ...event.raw];
+							}
+						} catch {}
+					}
+					onSseEvent({ event: event.event, data: event.data, raw: [...event.raw] }, model);
 				}
-				onSseEvent(event, model);
-			}
-		};
+			: undefined;
 		// Assigned once the block helpers exist (they are scoped to the `try`);
 		// the catch handler uses it to close open blocks before emitting the
 		// terminal error so both exit paths obey the same block lifecycle.
@@ -931,6 +937,9 @@ const streamOpenAICompletionsOnce = (
 						// bounds every attempt and backoff sleep — retries cannot
 						// extend the deadline.
 						onSseEvent: rawSseObserver,
+						onDoneSentinel: () => {
+							sawDoneSentinel = true;
+						},
 					});
 					// Disarm the first-event watchdog as soon as headers arrive — a slow
 					// onResponse callback must not abort an already-connected stream.
@@ -1030,9 +1039,19 @@ const streamOpenAICompletionsOnce = (
 			};
 			let currentBlock: OpenAIStreamBlock | undefined;
 			let messageThoughtSignature: GeminiMessageThoughtSignature | undefined;
+			// Content blocks are append-only for the lifetime of the stream, so each
+			// block's index is stable once pushed. Map block → index to keep the
+			// per-delta contentIndex lookup O(1): a linear `indexOf` per delta turns a
+			// long turn (many blocks × many deltas) quadratic, as openai-shared's
+			// Responses decoder documents (issue #10605).
+			const contentIndexByBlock = new Map<OpenAIStreamBlock, number>();
+			const pushContentBlock = (block: OpenAIStreamBlock): void => {
+				contentIndexByBlock.set(block, output.content.length);
+				output.content.push(block);
+			};
 			const blockIndex = (block: OpenAIStreamBlock | undefined): number => {
 				if (!block) return Math.max(0, output.content.length - 1);
-				return output.content.indexOf(block);
+				return contentIndexByBlock.get(block) ?? output.content.indexOf(block);
 			};
 			const finishToolCallBlock = (block: ToolCallStreamBlock): void => {
 				if (block.partialArgs === undefined) return;
@@ -1087,11 +1106,7 @@ const streamOpenAICompletionsOnce = (
 				if (currentBlock?.type !== "toolCall") finishCurrentBlock(currentBlock);
 				finishPendingToolCallBlocks();
 			};
-			const appendText = (
-				message: AssistantMessage,
-				eventStream: AssistantMessageEventStream,
-				text: string,
-			): void => {
+			const appendText = (text: string): void => {
 				if (currentBlock?.type !== "text") {
 					// Leave toolCall blocks pending across text transitions: chunks after
 					// the first typically carry only `index`, so a finished (de-registered)
@@ -1099,15 +1114,15 @@ const streamOpenAICompletionsOnce = (
 					// resume. The stream-end sweep finalizes pending calls.
 					if (currentBlock?.type !== "toolCall") finishCurrentBlock(currentBlock);
 					currentBlock = { type: "text", text: "" };
-					message.content.push(currentBlock);
-					eventStream.push({ type: "text_start", contentIndex: blockIndex(currentBlock), partial: message });
+					pushContentBlock(currentBlock);
+					stream.push({ type: "text_start", contentIndex: blockIndex(currentBlock), partial: output });
 				}
 				currentBlock.text += text;
-				eventStream.push({
+				stream.push({
 					type: "text_delta",
 					contentIndex: blockIndex(currentBlock),
 					delta: text,
-					partial: message,
+					partial: output,
 				});
 			};
 			const openThinkingBlock = (signature?: string): ThinkingContent => {
@@ -1116,7 +1131,7 @@ const streamOpenAICompletionsOnce = (
 				if (currentBlock?.type !== "toolCall") finishCurrentBlock(currentBlock);
 				const block: ThinkingContent = { type: "thinking", thinking: "", thinkingSignature: signature };
 				currentBlock = block;
-				output.content.push(block);
+				pushContentBlock(block);
 				stream.push({ type: "thinking_start", contentIndex: blockIndex(block), partial: output });
 				return block;
 			};
@@ -1177,7 +1192,7 @@ const streamOpenAICompletionsOnce = (
 			const appendTextDelta = (text: string): void => {
 				if (!text) return;
 				if (!firstTokenTime) firstTokenTime = performance.now();
-				appendText(output, stream, text);
+				appendText(text);
 			};
 			// Tracks the last full cumulative reasoning snapshot per signature (the
 			// reasoning field name) so dedup survives block transitions. Required
@@ -1249,7 +1264,7 @@ const streamOpenAICompletionsOnce = (
 				};
 				block.arguments = parseStreamingJson(call.arguments);
 				currentBlock = block;
-				output.content.push(block);
+				pushContentBlock(block);
 				stream.push({ type: "toolcall_start", contentIndex: blockIndex(block), partial: output });
 				stream.push({
 					type: "toolcall_delta",
@@ -1473,7 +1488,7 @@ const streamOpenAICompletionsOnce = (
 								if (streamIndex !== undefined) toolCallBlockByIndex.set(streamIndex, block);
 								pendingToolCallBlocks.push(block);
 								currentBlock = block;
-								output.content.push(block);
+								pushContentBlock(block);
 								stream.push({
 									type: "toolcall_start",
 									contentIndex: blockIndex(block),

package/src/providers/openai-responses.ts

@@ -1,5 +1,5 @@
 import { scheduler } from "node:timers/promises";
-import { $flag, logger, structuredCloneJSON } from "@oh-my-pi/pi-utils";
+import { $flag, logger, type ServerSentEvent, structuredCloneJSON } from "@oh-my-pi/pi-utils";
 import * as AIError from "../error";
 import { getEnvApiKey } from "../stream";
 import type {
@@ -9,7 +9,6 @@ import type {
 	Model,
 	OpenAICompat,
 	ProviderSessionState,
-	RawSseEvent,
 	ServiceTier,
 	StreamFunction,
 	StreamOptions,
@@ -455,7 +454,7 @@ const streamOpenAIResponsesOnce = (
 		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);
@@ -471,7 +470,7 @@ const streamOpenAIResponsesOnce = (
 							}
 						} catch {}
 					}
-					onSseEvent(event, model);
+					onSseEvent({ event: event.event, data: event.data, raw: [...event.raw] }, model);
 				}
 			: undefined;
 

package/src/providers/openai-shared.ts

@@ -1667,20 +1667,58 @@ function classifyResponsesBatchItem(item: object): ResponsesBatchItemKind {
  * strict validator. See #8789.
  */
 export function hoistInterleavedResponsesToolBatchMessages<T extends object>(items: readonly T[]): T[] {
-	const moved = new Set<number>();
+	const callIdOf = (item: T): string | undefined =>
+		"call_id" in item && typeof item.call_id === "string" ? item.call_id : undefined;
+	// Does a call with `callId` precede `index` within the same contiguous batch body?
+	const hasEarlierBatchCall = (index: number, callId: string): boolean => {
+		for (let probe = index - 1; probe >= 0; probe--) {
+			const kind = classifyResponsesBatchItem(items[probe]);
+			if (kind === "other") return false;
+			if (kind === "call" && callIdOf(items[probe]) === callId) return true;
+		}
+		return false;
+	};
+	const bucketOf = new Map<number, number>();
 	const insertBefore = new Map<number, number[]>();
 	for (let index = 0; index < items.length; index++) {
 		if (classifyResponsesBatchItem(items[index]) !== "output") continue;
 		// Only anchor on the first output of a run.
 		if (index > 0 && classifyResponsesBatchItem(items[index - 1]) === "output") continue;
+		// Calls the batch still owns further back: the anchor run's outputs, plus
+		// any earlier output crossed on the way.
+		const pending = new Set<string>();
+		for (let probe = index; probe < items.length; probe++) {
+			if (classifyResponsesBatchItem(items[probe]) !== "output") break;
+			const callId = callIdOf(items[probe]);
+			if (callId) pending.add(callId);
+		}
 		// Walk back over the batch body (calls interleaved with assistant messages).
+		// An earlier output is crossed only when it and a call the batch still owns
+		// both pair with calls further back — i.e. the output belongs to this same
+		// interrupted batch (#13083). Otherwise it closes a completed prior round,
+		// whose trailing messages stay put.
 		let start = index;
 		let sawCall = false;
 		const messageIndexes: number[] = [];
 		while (start > 0) {
-			const kind = classifyResponsesBatchItem(items[start - 1]);
+			const item = items[start - 1];
+			const kind = classifyResponsesBatchItem(item);
 			if (kind === "call") {
 				sawCall = true;
+				const callId = callIdOf(item);
+				if (callId) pending.delete(callId);
+			} else if (kind === "output") {
+				const callId = callIdOf(item);
+				if (!callId || !hasEarlierBatchCall(start - 1, callId)) break;
+				let ownsEarlierCall = false;
+				for (const owned of pending) {
+					if (hasEarlierBatchCall(start - 1, owned)) {
+						ownsEarlierCall = true;
+						break;
+					}
+				}
+				if (!ownsEarlierCall) break;
+				pending.add(callId);
 			} else if (kind === "assistant-message") {
 				messageIndexes.push(start - 1);
 			} else {
@@ -1693,17 +1731,25 @@ export function hoistInterleavedResponsesToolBatchMessages<T extends object>(ite
 		messageIndexes.reverse();
 		const target = insertBefore.get(start) ?? [];
 		for (const messageIndex of messageIndexes) {
-			moved.add(messageIndex);
+			// A wider batch can re-collect a message an earlier anchor already
+			// scheduled; move it rather than emitting it twice.
+			const previousStart = bucketOf.get(messageIndex);
+			if (previousStart !== undefined) {
+				const previous = insertBefore.get(previousStart);
+				const slot = previous?.indexOf(messageIndex) ?? -1;
+				if (previous && slot >= 0) previous.splice(slot, 1);
+			}
+			bucketOf.set(messageIndex, start);
 			target.push(messageIndex);
 		}
 		insertBefore.set(start, target);
 	}
-	if (moved.size === 0) return items.slice();
+	if (bucketOf.size === 0) return items.slice();
 	const result: T[] = [];
 	for (let index = 0; index < items.length; index++) {
 		const pending = insertBefore.get(index);
 		if (pending) for (const messageIndex of pending) result.push(items[messageIndex]);
-		if (moved.has(index)) continue;
+		if (bucketOf.has(index)) continue;
 		result.push(items[index]);
 	}
 	return result;
@@ -2070,11 +2116,16 @@ export function buildResponsesInput<TApi extends Api>(options: BuildResponsesInp
 					},
 				);
 				const sanitizedHistoryItems = rawSanitizedHistoryItems
-					? adaptResponsesReplayItemsForModel(
-							rawSanitizedHistoryItems,
-							supportsCustomToolCalls,
-							customToolWireNameMap,
-							options.model.supportsComputerUse === true,
+					? ensureRequiredResponsesReasoningReplay(
+							adaptResponsesReplayItemsForModel(
+								rawSanitizedHistoryItems,
+								supportsCustomToolCalls,
+								customToolWireNameMap,
+								options.model.supportsComputerUse === true,
+							),
+							assistantMsg.stopReason,
+							options.requiresReasoningReplayForAllTurns ?? false,
+							options.requiresReasoningReplayForToolCalls ?? false,
 						)
 					: undefined;
 				if (nativeReplayEnabled && sanitizedHistoryItems) {
@@ -2175,6 +2226,70 @@ function parseResponseReasoningReplayItem(signature: string | undefined): Respon
  */
 export const SYNTHETIC_REASONING_REPLAY_PLACEHOLDER = "reasoning unavailable";
 
+function createSyntheticResponsesReasoningItem(
+	text = SYNTHETIC_REASONING_REPLAY_PLACEHOLDER,
+	id?: string,
+): ResponseReasoningItem {
+	const item = {
+		type: "reasoning",
+		...(id ? { id } : {}),
+		summary: [],
+		content: [{ type: "reasoning_text", text }],
+	} satisfies Omit<ResponseReasoningItem, "id"> & Partial<Pick<ResponseReasoningItem, "id">>;
+	// The vendored SDK type marks `id` required; the wire accepts its absence.
+	return item as ResponseReasoningItem;
+}
+
+function isResponsesAssistantTurnBoundary(item: ResponseInput[number]): boolean {
+	if (responsesToolOutputKind(item.type) !== undefined) return true;
+	if (item.type === "compaction") return true;
+	return "role" in item && item.role !== "assistant";
+}
+
+function ensureRequiredResponsesReasoningReplay(
+	items: ResponseInput,
+	stopReason: AssistantMessage["stopReason"],
+	requiresAllTurns: boolean,
+	requiresToolCalls: boolean,
+): ResponseInput {
+	if (stopReason === "error" || (!requiresAllTurns && !requiresToolCalls)) return items;
+
+	const insertBefore: number[] = [];
+	let turnStart = 0;
+	for (let index = 0; index <= items.length; index++) {
+		if (index < items.length && !isResponsesAssistantTurnBoundary(items[index])) continue;
+
+		let hasContent = false;
+		let hasReasoning = false;
+		let hasToolCall = false;
+		for (let turnIndex = turnStart; turnIndex < index; turnIndex++) {
+			const item = items[turnIndex];
+			if (item.type === "reasoning") {
+				hasReasoning = true;
+				continue;
+			}
+			hasContent = true;
+			if (classifyResponsesBatchItem(item) === "call") hasToolCall = true;
+		}
+		if (hasContent && !hasReasoning && (requiresAllTurns || (requiresToolCalls && hasToolCall))) {
+			insertBefore.push(turnStart);
+		}
+		turnStart = index + 1;
+	}
+	if (insertBefore.length === 0) return items;
+
+	const repaired: ResponseInput = [];
+	let insertionIndex = 0;
+	for (let index = 0; index < items.length; index++) {
+		if (insertBefore[insertionIndex] === index) {
+			repaired.push(createSyntheticResponsesReasoningItem());
+			insertionIndex++;
+		}
+		repaired.push(items[index]);
+	}
+	return repaired;
+}
+
 export function convertResponsesAssistantMessage<TApi extends Api>(
 	assistantMsg: AssistantMessage,
 	model: Model<TApi>,
@@ -2345,14 +2460,7 @@ export function convertResponsesAssistantMessage<TApi extends Api>(
 		const carriedReasoningText = carriedReasoningTexts.join("\n");
 		const reasoningText =
 			carriedReasoningText.length > 0 ? carriedReasoningText : SYNTHETIC_REASONING_REPLAY_PLACEHOLDER;
-		const reasoningItem = {
-			type: "reasoning",
-			...(synthesizedReasoningItemId ? { id: synthesizedReasoningItemId } : {}),
-			summary: [],
-			content: [{ type: "reasoning_text", text: reasoningText }],
-		} satisfies Omit<ResponseReasoningItem, "id"> & Partial<Pick<ResponseReasoningItem, "id">>;
-		// The vendored SDK type marks `id` required; the wire accepts its absence.
-		outputItems.unshift(reasoningItem as ResponseReasoningItem);
+		outputItems.unshift(createSyntheticResponsesReasoningItem(reasoningText, synthesizedReasoningItemId));
 	}
 
 	return outputItems;

package/src/registry/engine/api-key.ts

@@ -96,9 +96,14 @@ export function createApiKeyLogin(
 			try {
 				await runValidation(rule.validate, label, trimmed, options);
 			} catch (error) {
-				// An optional probe only rejects on a real auth failure (401/403);
-				// any other validation-endpoint failure trusts the supplied key.
-				if (!rule.validate.optional || AIError.is(AIError.classify(error), AIError.Flag.AuthFailed)) {
+				// An optional probe only rejects on a real auth failure (401/403, or
+				// only 401 with `trustForbidden`); any other validation-endpoint
+				// failure trusts the supplied key.
+				const trustsForbidden = rule.validate.trustForbidden && AIError.status(error) === 403;
+				if (
+					!rule.validate.optional ||
+					(AIError.is(AIError.classify(error), AIError.Flag.AuthFailed) && !trustsForbidden)
+				) {
 					throw error;
 				}
 				options.onProgress?.(`Skipping ${label} validation endpoint; continuing with provided API key.`);

package/src/usage/commandcode.ts

@@ -0,0 +1,209 @@
+import { ProviderHttpError } from "../error";
+import type {
+	CredentialRankingStrategy,
+	UsageFetchContext,
+	UsageFetchParams,
+	UsageLimit,
+	UsageProvider,
+	UsageReport,
+} from "../usage";
+import { isRecord } from "../utils";
+import { HOUR_MS, parsePositiveTimestamp, usageStatus, WEEK_MS } from "./shared";
+
+const PROVIDER = "commandcode";
+const DEFAULT_ORIGIN = "https://api.commandcode.ai";
+// The CLI also sends `?limits=1` for its org spend-limit panel; omp reads no
+// field from that, so the plain identity route is enough.
+const WHOAMI_PATH = "/alpha/whoami";
+const CREDITS_PATH = "/alpha/billing/credits";
+
+/**
+ * Command Code's inference base carries `/provider` or `/provider/v1`, while the
+ * account routes sit at the host root, so only the configured origin is kept.
+ * A blank or unparseable override means "not configured".
+ */
+function resolveOrigin(baseUrl: string | undefined): string {
+	const trimmed = baseUrl?.trim();
+	if (!trimmed) return DEFAULT_ORIGIN;
+	try {
+		return new URL(trimmed).origin;
+	} catch {
+		return DEFAULT_ORIGIN;
+	}
+}
+
+function nonEmptyString(value: unknown): string | undefined {
+	return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+
+function finiteNumber(value: unknown): number | undefined {
+	return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+}
+
+/**
+ * Returns the unwrapped JSON body, or `null` for any failure that should read
+ * as "no data", 403 included. Only a 401 throws, so a revoked key purges the
+ * cached report instead of re-serving it.
+ */
+async function getJson(
+	url: string,
+	apiKey: string,
+	signal: AbortSignal | undefined,
+	ctx: UsageFetchContext,
+): Promise<Record<string, unknown> | null> {
+	try {
+		const response = await ctx.fetch(url, {
+			headers: {
+				Authorization: `Bearer ${apiKey}`,
+				Accept: "application/json",
+			},
+			signal,
+		});
+		if (!response.ok) {
+			if (response.status === 401) {
+				throw new ProviderHttpError(
+					`Command Code usage endpoint returned ${response.status} ${response.statusText}`.trim(),
+					response.status,
+				);
+			}
+			ctx.logger?.warn("Command Code usage fetch failed", {
+				url,
+				status: response.status,
+				statusText: response.statusText,
+			});
+			return null;
+		}
+		const json: unknown = await response.json();
+		if (!isRecord(json)) return null;
+		return isRecord(json.data) ? json.data : json;
+	} catch (error) {
+		if (error instanceof ProviderHttpError) throw error;
+		ctx.logger?.warn("Command Code usage fetch error", { url, error: String(error) });
+		return null;
+	}
+}
+
+interface WindowSpec {
+	key: "fiveHour" | "weekly";
+	id: "5h" | "7d";
+	limitLabel: string;
+	windowLabel: string;
+	durationMs: number;
+}
+
+const WINDOWS: readonly WindowSpec[] = [
+	{ key: "fiveHour", id: "5h", limitLabel: "5-hour limit", windowLabel: "5-hour", durationMs: 5 * HOUR_MS },
+	{ key: "weekly", id: "7d", limitLabel: "Weekly limit", windowLabel: "Weekly", durationMs: WEEK_MS },
+];
+
+function buildWindowLimit(
+	spec: WindowSpec,
+	raw: unknown,
+	accountId: string,
+	orgId: string | undefined,
+): UsageLimit | undefined {
+	if (!isRecord(raw)) return undefined;
+	const used = finiteNumber(raw.used);
+	if (used === undefined) return undefined;
+	const cap = finiteNumber(raw.cap);
+	const usedFraction = cap !== undefined && cap > 0 ? used / cap : undefined;
+	const resetsAt = parsePositiveTimestamp(raw.resetAt);
+	// Absent fields are omitted, not set to `undefined`: the usage wire schema
+	// rejects an explicit `undefined` for an optional key.
+	return {
+		id: `${PROVIDER}:${spec.id}`,
+		label: spec.limitLabel,
+		scope: { provider: PROVIDER, accountId, ...(orgId ? { orgId } : {}), windowId: spec.id, shared: true },
+		window: {
+			id: spec.id,
+			label: spec.windowLabel,
+			durationMs: spec.durationMs,
+			...(resetsAt !== undefined ? { resetsAt } : {}),
+		},
+		amount: {
+			used,
+			...(cap !== undefined ? { limit: cap } : {}),
+			...(usedFraction !== undefined ? { usedFraction } : {}),
+			unit: "credits",
+		},
+		status: raw.exceeded === true ? "exhausted" : usageStatus(usedFraction),
+	};
+}
+
+/**
+ * Reads the account routes that the Command Code CLI calls with the same API
+ * key; the Provider API documents no usage endpoint. Pay-as-you-go accounts
+ * carry no `windowLimits`, so they report only the credit balance. Credits
+ * are queried per org, as the CLI does, so each limit records the org that
+ * owns the pool alongside the user.
+ */
+async function fetchCommandCodeUsage(params: UsageFetchParams, ctx: UsageFetchContext): Promise<UsageReport | null> {
+	if (params.provider !== PROVIDER) return null;
+	if (params.credential.type !== "api_key" || !params.credential.apiKey) return null;
+	const origin = resolveOrigin(params.baseUrl);
+
+	const whoami = await getJson(`${origin}${WHOAMI_PATH}`, params.credential.apiKey, params.signal, ctx);
+	if (!whoami) return null;
+	const user = isRecord(whoami.user) ? whoami.user : undefined;
+	const org = isRecord(whoami.org) ? whoami.org : undefined;
+	const userId = nonEmptyString(user?.id);
+	if (!userId) return null;
+	const orgId = nonEmptyString(org?.id);
+	const orgLogin = nonEmptyString(org?.login);
+
+	const creditsUrl = `${origin}${CREDITS_PATH}${orgId ? `?orgId=${encodeURIComponent(orgId)}` : ""}`;
+	const creditsBody = await getJson(creditsUrl, params.credential.apiKey, params.signal, ctx);
+	if (!creditsBody) return null;
+	const credits = isRecord(creditsBody.credits) ? creditsBody.credits : undefined;
+	if (!credits) return null;
+	const monthly = finiteNumber(credits.monthlyCredits);
+	const purchased = finiteNumber(credits.purchasedCredits);
+	const free = finiteNumber(credits.freeCredits);
+	if (monthly === undefined && purchased === undefined && free === undefined) return null;
+
+	const limits: UsageLimit[] = [];
+	const windowLimits = isRecord(creditsBody.windowLimits) ? creditsBody.windowLimits : undefined;
+	for (const spec of WINDOWS) {
+		const limit = buildWindowLimit(spec, windowLimits?.[spec.key], userId, orgId);
+		if (limit) limits.push(limit);
+	}
+	limits.push({
+		id: `${PROVIDER}:balance`,
+		label: "Credit balance",
+		scope: { provider: PROVIDER, accountId: userId, ...(orgId ? { orgId } : {}), windowId: "balance", shared: true },
+		amount: { remaining: (monthly ?? 0) + (purchased ?? 0) + (free ?? 0), unit: "credits" },
+	});
+
+	return {
+		provider: PROVIDER,
+		fetchedAt: Date.now(),
+		limits,
+		metadata: {
+			accountId: userId,
+			email: nonEmptyString(user?.email),
+			orgId,
+			orgName: orgLogin,
+			planType: nonEmptyString(credits.planId),
+		},
+		raw: { whoami, credits: creditsBody },
+	};
+}
+
+export const commandCodeUsageProvider: UsageProvider = {
+	id: PROVIDER,
+	fetchUsage: fetchCommandCodeUsage,
+	supports: params => params.provider === PROVIDER && params.credential.type === "api_key",
+	validatesCredentials: true,
+};
+
+/** Ranks Command Code accounts by the 5-hour and weekly credit windows. */
+export const commandCodeRankingStrategy: CredentialRankingStrategy = {
+	findWindowLimits: report => ({
+		primary: report.limits.find(limit => limit.window?.id === "5h"),
+		secondary: report.limits.find(limit => limit.window?.id === "7d"),
+	}),
+	windowDefaults: {
+		primaryMs: 5 * HOUR_MS,
+		secondaryMs: WEEK_MS,
+	},
+};

package/src/usage/registry.ts

@@ -4,6 +4,7 @@ import { alibabaTokenPlanRankingStrategy, alibabaTokenPlanUsageProvider } from "
 import { charmHyperUsageProvider } from "./charm-hyper";
 import { claudeRankingStrategy, claudeUsageProvider } from "./claude";
 import { clinePassUsageProvider } from "./cline-pass";
+import { commandCodeRankingStrategy, commandCodeUsageProvider } from "./commandcode";
 import { cursorRankingStrategy, cursorUsageProvider } from "./cursor";
 import { devinUsageProvider } from "./devin";
 import { googleGeminiCliUsageProvider } from "./gemini";
@@ -45,6 +46,7 @@ export const DEFAULT_USAGE_PROVIDERS: readonly UsageProvider[] = [
 	xaiOauthUsageProvider,
 	devinUsageProvider,
 	charmHyperUsageProvider,
+	commandCodeUsageProvider,
 ];
 
 const DEFAULT_USAGE_PROVIDER_MAP = new Map<Provider, UsageProvider>(
@@ -66,6 +68,7 @@ const DEFAULT_RANKING_STRATEGIES = new Map<Provider, CredentialRankingStrategy>(
 	["zai", zaiRankingStrategy],
 	["opencode-go", opencodeGoRankingStrategy],
 	["xai-oauth", xaiOauthRankingStrategy],
+	["commandcode", commandCodeRankingStrategy],
 ]);
 
 /** Built-in ranking strategy for `provider`. */

package/src/utils/event-stream.ts

@@ -6,9 +6,21 @@ export interface LocalWorkSource {
 	readonly hasPendingLocalWork: boolean;
 }
 
+/** Consumed head slots tolerated before the backlog is compacted (see {@link EventStream.queue}). */
+const QUEUE_COMPACT_MIN_HEAD = 64;
+
 // Generic event stream class for async iteration
 export class EventStream<T, R = T> implements AsyncIterable<T> {
+	/**
+	 * 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[] = [];
+	/** Index of the next undelivered event in {@link queue}; 0 whenever the queue is empty. */
+	#queueHead = 0;
 	waiting: Array<{ resolve: (value: IteratorResult<T>) => void; reject: (err: unknown) => void }> = [];
 	done = false;
 	/** True once finalResultPromise has been resolved or rejected. */
@@ -115,10 +127,34 @@ export class EventStream<T, R = T> implements AsyncIterable<T> {
 		}
 	}
 
+	/**
+	 * Take the event at the queue head. Clears the consumed slot so it stops
+	 * retaining the event, resets the queue once drained, and compacts it once
+	 * consumed slots are at least half of it (amortized O(1) per event).
+	 */
+	#dequeue(): T {
+		const queue = this.queue;
+		const head = this.#queueHead;
+		const event = queue[head];
+		if (head + 1 === queue.length) {
+			queue.length = 0;
+			this.#queueHead = 0;
+			return event;
+		}
+		// The slot is dead once the head moves past it; `undefined` only drops the reference.
+		queue[head] = undefined as T;
+		this.#queueHead = head + 1;
+		if (this.#queueHead >= QUEUE_COMPACT_MIN_HEAD && this.#queueHead * 2 >= queue.length) {
+			queue.splice(0, this.#queueHead);
+			this.#queueHead = 0;
+		}
+		return event;
+	}
+
 	async *[Symbol.asyncIterator](): AsyncIterator<T> {
 		while (true) {
-			if (this.queue.length > 0) {
-				yield this.queue.shift()!;
+			if (this.#queueHead < this.queue.length) {
+				yield this.#dequeue();
 			} else if (this.#failed) {
 				throw this.#error;
 			} else if (this.done) {

package/src/utils/openai-http.ts

@@ -70,8 +70,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> {
@@ -117,7 +123,7 @@ export async function postOpenAIStream<TEvent>(init: OpenAIStreamRequestInit): P
 		});
 	}
 	return {
-		events: decodeStream<TEvent>(response.body, init.signal, init.onSseEvent),
+		events: decodeStream<TEvent>(response.body, init.signal, init.onSseEvent, init.onDoneSentinel),
 		response,
 		requestId: response.headers.get("x-request-id"),
 	};
@@ -140,8 +146,9 @@ async function* decodeStream<TEvent>(
 	body: ReadableStream<Uint8Array>,
 	signal: AbortSignal | undefined,
 	onSseEvent: SseEventObserver | undefined,
+	onDoneSentinel: (() => void) | undefined,
 ): AsyncGenerator<TEvent> {
-	for await (const frame of readSseJsonOrText<TEvent>(body, signal, onSseEvent)) {
+	for await (const frame of readSseJsonOrText<TEvent>(body, signal, onSseEvent, onDoneSentinel)) {
 		if (typeof frame === "string") {
 			const inBand = AIError.createInBandProviderErrorFromText(frame);
 			if (inBand) throw inBand;