@code-yeongyu/senpi 2026.9.15 → 2026.9.16-2

package/node_modules/@code-yeongyu/senpi-codemode/src/tool/managed-cell.ts

@@ -0,0 +1,78 @@
+import type { AgentToolResult } from "@code-yeongyu/senpi";
+import { type CellDeadlineExpiry, CellDeadlines } from "./cell-deadlines.ts";
+import type { EvalDetachedCellSnapshot, EvalDetachedCellState } from "./detached-cell-contract.ts";
+import { detachedNotificationSpillPath } from "./detached-cell-notification.ts";
+import type { EvalKernel, EvalToolDetails, EvalToolInput } from "./types.ts";
+
+export type LiveResultProvider = () => AgentToolResult<EvalToolDetails>;
+
+export type ManagedCell = {
+	readonly cellId: string;
+	readonly input: EvalToolInput;
+	readonly spillPath: string | undefined;
+	readonly startedAtMs: number;
+	readonly terminal: PromiseWithResolvers<EvalDetachedCellSnapshot>;
+	state: EvalDetachedCellState;
+	canDetach: boolean;
+	wasDetached: boolean;
+	kernel: EvalKernel | undefined;
+	stateRetained: boolean | undefined;
+	interruptNote: string | undefined;
+	/** Holds the completion notification until the interrupt has reported whether kernel state survived. */
+	interruptOutcome: PromiseWithResolvers<void> | undefined;
+	liveResult: LiveResultProvider | undefined;
+	terminalResult: AgentToolResult<EvalToolDetails> | undefined;
+	notificationQueued: boolean;
+	readonly deadlines: CellDeadlines;
+	readonly hardLimitSeconds: number;
+	readonly runBudgetSeconds: number;
+	hardLimited: boolean;
+	runBudgetExhausted: boolean;
+	/** Foreground killer: the still-awaited CellExecution owns interrupting and rejecting its own call; bound from creation so a deadline firing during kernel boot still ends it. */
+	onKill: ((error: Error) => void) | undefined;
+};
+
+export interface ManagedCellInit {
+	readonly cellId: string;
+	readonly input: EvalToolInput;
+	readonly artifactsDir: string | undefined;
+	readonly now: () => number;
+	readonly defaultHardLimitSeconds: number;
+	readonly defaultRunBudgetSeconds: number;
+	readonly onKill: ((error: Error) => void) | undefined;
+	readonly onExpire: (cellId: string, expiry: CellDeadlineExpiry) => void;
+}
+
+export function createManagedCell(init: ManagedCellInit): ManagedCell {
+	// An explicit longer per-call timeout raises the deadline, mirroring bash keeping explicit timeouts.
+	const hardLimitSeconds = Math.max(init.defaultHardLimitSeconds, init.input.timeout ?? 0);
+	const runBudgetSeconds = init.input.timeout ?? init.defaultRunBudgetSeconds;
+	return {
+		cellId: init.cellId,
+		input: init.input,
+		spillPath: detachedNotificationSpillPath(init.artifactsDir, init.cellId),
+		startedAtMs: init.now(),
+		state: "running",
+		canDetach: false,
+		wasDetached: false,
+		kernel: undefined,
+		stateRetained: undefined,
+		interruptNote: undefined,
+		interruptOutcome: undefined,
+		liveResult: undefined,
+		terminalResult: undefined,
+		notificationQueued: false,
+		deadlines: new CellDeadlines({
+			cellId: init.cellId,
+			hardLimitSeconds,
+			runBudgetSeconds,
+			onExpire: (expiry) => init.onExpire(init.cellId, expiry),
+		}),
+		hardLimitSeconds,
+		runBudgetSeconds,
+		hardLimited: false,
+		runBudgetExhausted: false,
+		onKill: init.onKill,
+		terminal: Promise.withResolvers<EvalDetachedCellSnapshot>(),
+	};
+}

package/node_modules/@code-yeongyu/senpi-codemode/src/tool/render.ts

@@ -71,10 +71,15 @@ const TOOL_CALL_COLLAPSED_VISUAL_LINES = 4;
 const TOOL_CALL_COLLAPSED_ERROR_CODE_POINTS = 512;
 const TOOL_ERROR_OMISSION_MARKER = "[tool error omitted]";
 const LIVE_ELAPSED_TICK_MS = 1_000;
+// A live row repaints on every tick, so this many ticks without a render means the row is gone.
+const LIVE_TICKER_MAX_IDLE_TICKS = 60;
 
 class PlainTextComponent implements EvalRenderComponent {
 	#blocks: readonly RenderBlock[] = [];
 	#ticker: ReturnType<typeof setInterval> | undefined;
+	#live = false;
+	#invalidate: (() => void) | undefined;
+	#idleTicks = 0;
 
 	setBlocks(blocks: readonly RenderBlock[]): void {
 		this.#blocks = blocks;
@@ -84,16 +89,19 @@ class PlainTextComponent implements EvalRenderComponent {
 	 * The host only animates tool rows for streaming args, `task`, and results carrying
 	 * `details.progress`; an eval row matches none of them, so nothing repaints it between
 	 * update events. While a cell is non-terminal this drives the repaint itself so the
-	 * header's elapsed time advances, and it emits no tool updates or RPC traffic.
+	 * header's elapsed time advances, and it emits no tool updates or RPC traffic. Detached
+	 * and terminal cards never arm it, and a ticker whose row stopped rendering (transcript
+	 * rebuild, session switch) stops itself after LIVE_TICKER_MAX_IDLE_TICKS and rearms on
+	 * the next render, so dropped rows cannot accumulate intervals.
 	 */
 	syncLiveTicker(isLive: boolean, invalidate: () => void): void {
+		this.#live = isLive;
+		this.#invalidate = invalidate;
 		if (!isLive) {
 			this.stopLiveTicker();
 			return;
 		}
-		if (this.#ticker !== undefined) return;
-		this.#ticker = setInterval(invalidate, LIVE_ELAPSED_TICK_MS);
-		this.#ticker.unref?.();
+		this.#armTicker();
 	}
 
 	stopLiveTicker(): void {
@@ -102,7 +110,24 @@ class PlainTextComponent implements EvalRenderComponent {
 		this.#ticker = undefined;
 	}
 
+	#armTicker(): void {
+		if (this.#ticker !== undefined || this.#invalidate === undefined) return;
+		this.#ticker = setInterval(() => this.#tick(), LIVE_ELAPSED_TICK_MS);
+		this.#ticker.unref?.();
+	}
+
+	#tick(): void {
+		this.#idleTicks += 1;
+		if (this.#idleTicks >= LIVE_TICKER_MAX_IDLE_TICKS) {
+			this.stopLiveTicker();
+			return;
+		}
+		this.#invalidate?.();
+	}
+
 	render(width: number): string[] {
+		this.#idleTicks = 0;
+		if (this.#live) this.#armTicker();
 		const lines: string[] = [];
 		for (const block of this.#blocks) {
 			switch (block.kind) {
@@ -269,7 +294,7 @@ function spinner(frame: number | undefined): string {
 }
 
 function isLiveCellStatus(status: CellStatus): boolean {
-	return status === "pending" || status === "running" || status === "detached";
+	return status === "pending" || status === "running";
 }
 
 function cellPresentation(status: CellStatus, spinnerFrame: number | undefined): StatusPresentation {

package/node_modules/@code-yeongyu/senpi-codemode/src/tool/run-eval-cell.ts

@@ -1,7 +1,8 @@
 import { randomUUID } from "node:crypto";
 import { join } from "node:path";
-import type { AgentToolResult, ExtensionContext } from "@code-yeongyu/senpi";
+import { type AgentToolResult, type ExtensionContext, kernelToolsStorage } from "@code-yeongyu/senpi";
 import { DEFAULT_FOREGROUND_WINDOW_SECONDS, defaultCodemodeSettings } from "../config/settings.ts";
+import type { KernelToolsCapability } from "../kernels/js/kernel-tools-types.ts";
 import { TIMEOUT_PAUSE_OP, TIMEOUT_RESUME_OP } from "../timeouts/bridge-timeout.ts";
 import { abortError, CellExecution, defaultTimeoutFactory } from "./cell-execution.ts";
 import { CellHandler, type CellState } from "./cell-handler.ts";
@@ -11,7 +12,7 @@ import { buildEvalExecutionEventPayload, type EvalExecutionSettleOutcome } from
 import { evalTimeoutBehavior } from "./eval-request.ts";
 import type { CreateEvalToolOptions, EvalCellInvocation } from "./eval-tool-options.ts";
 import { describeTimeoutState } from "./interrupt-note.ts";
-import type { EvalToolDetails } from "./types.ts";
+import type { EvalKernel, EvalToolDetails } from "./types.ts";
 
 export async function runEvalCell(
 	options: CreateEvalToolOptions,
@@ -166,34 +167,42 @@ async function executeCell(
 				void pending.catch((error: unknown) => execution.cancel(error));
 			}),
 		);
-		execution.setKernel(kernel);
-		const activeHandler = new CellHandler(kernel, state, {
-			executeTool: options.executeTool,
-			...(options.listTools === undefined ? {} : { listTools: options.listTools }),
-			settings: options.settings ?? defaultCodemodeSettings,
-			...(options.complete === undefined ? {} : { complete: options.complete }),
-			ctx: bridgeContext,
-			...(options.artifactsDir === undefined
-				? {}
-				: { artifactPath: join(options.artifactsDir, `eval-${randomUUID()}.log`) }),
-			...(options.imageResizer === undefined ? {} : { imageResizer: options.imageResizer }),
-		});
-		handler = activeHandler;
-		cellManager.markRunning(
-			cell,
-			kernel,
-			() => activeHandler.liveResult(),
-			(error) => execution.cancel(error),
-		);
-		// Includes a steer already queued at execute start or received while acquiring the kernel.
-		onReady();
-		if ("setContext" in options.kernelManager && typeof options.kernelManager.setContext === "function") {
-			options.kernelManager.setContext(bridgeContext);
-		}
-		if (invocation.input.reset) await execution.wait(kernel.reset());
-		const result = await execution.wait(kernel.run({ cellId: invocation.cellId, code: invocation.input.code }));
-		if (result.ok && state.pendingBridgeCalls.length > 0) await execution.wait(Promise.all(state.pendingBridgeCalls));
-		return await handler.finalize(result);
+		// Computed before the handler so the cell's capability can be entered per host tool call from the
+		// worker's message loop, which runs outside the `kernelToolsStorage.run` context below (#1754).
+		const kernelTools = jsKernelTools(kernel, invocation.input.language);
+		const runBound = async (): Promise<AgentToolResult<EvalToolDetails>> => {
+			execution.setKernel(kernel);
+			const activeHandler = new CellHandler(kernel, state, {
+				executeTool: options.executeTool,
+				...(options.listTools === undefined ? {} : { listTools: options.listTools }),
+				settings: options.settings ?? defaultCodemodeSettings,
+				...(options.complete === undefined ? {} : { complete: options.complete }),
+				ctx: bridgeContext,
+				...(options.artifactsDir === undefined
+					? {}
+					: { artifactPath: join(options.artifactsDir, `eval-${randomUUID()}.log`) }),
+				...(options.imageResizer === undefined ? {} : { imageResizer: options.imageResizer }),
+				...(kernelTools === undefined ? {} : { kernelTools }),
+			});
+			handler = activeHandler;
+			cellManager.markRunning(
+				cell,
+				kernel,
+				() => activeHandler.liveResult(),
+				(error) => execution.cancel(error),
+			);
+			// Includes a steer already queued at execute start or received while acquiring the kernel.
+			onReady();
+			if ("setContext" in options.kernelManager && typeof options.kernelManager.setContext === "function") {
+				options.kernelManager.setContext(bridgeContext);
+			}
+			if (invocation.input.reset) await execution.wait(kernel.reset());
+			const result = await execution.wait(kernel.run({ cellId: invocation.cellId, code: invocation.input.code }));
+			if (result.ok && state.pendingBridgeCalls.length > 0)
+				await execution.wait(Promise.all(state.pendingBridgeCalls));
+			return await handler.finalize(result);
+		};
+		return kernelTools ? await kernelToolsStorage.run(kernelTools, runBound) : await runBound();
 	} catch (error) {
 		if (handler && error instanceof Error && error.name === "CodemodeSessionDisposedError")
 			return await handler.finalizeCancellation(error);
@@ -206,3 +215,16 @@ async function executeCell(
 		if (handler) await handler.flushOutput();
 	}
 }
+
+function jsKernelTools(kernel: EvalKernel, language: string): KernelToolsCapability | undefined {
+	if (language !== "js") return undefined;
+	if (!("describeKernelTools" in kernel) || typeof kernel.describeKernelTools !== "function") return undefined;
+	const js = kernel as EvalKernel & {
+		describeKernelTools: KernelToolsCapability["describe"];
+		invokeKernelTool: KernelToolsCapability["invoke"];
+	};
+	return {
+		describe: (names) => js.describeKernelTools(names),
+		invoke: (request, signal) => js.invokeKernelTool(request, signal),
+	};
+}

package/node_modules/@code-yeongyu/senpi-codemode/src/tool/terminal-snapshot-store.ts

@@ -0,0 +1,35 @@
+import type { EvalDetachedCellSnapshot } from "./detached-cell-contract.ts";
+
+export const TERMINAL_SNAPSHOT_CAP = 32;
+
+/** Bounded LRU of settled-cell snapshots; without it every settled cell pins its result and closures for the session lifetime (#1695). */
+export class TerminalSnapshotStore {
+	readonly #snapshots = new Map<string, EvalDetachedCellSnapshot>();
+	readonly #cap: number;
+
+	constructor(cap = TERMINAL_SNAPSHOT_CAP) {
+		this.#cap = cap;
+	}
+
+	remember(snapshot: EvalDetachedCellSnapshot): void {
+		this.#snapshots.delete(snapshot.cellId);
+		this.#snapshots.set(snapshot.cellId, snapshot);
+		while (this.#snapshots.size > this.#cap) {
+			const oldest = this.#snapshots.keys().next();
+			if (oldest.done === true) break;
+			this.#snapshots.delete(oldest.value);
+		}
+	}
+
+	get(cellId: string): EvalDetachedCellSnapshot | undefined {
+		return this.#snapshots.get(cellId);
+	}
+
+	delete(cellId: string): void {
+		this.#snapshots.delete(cellId);
+	}
+
+	clear(): void {
+		this.#snapshots.clear();
+	}
+}

package/node_modules/@code-yeongyu/senpi-codemode/src/tool/tool-result-marshal.ts

@@ -0,0 +1,23 @@
+import type { AgentToolResult } from "@code-yeongyu/senpi";
+
+export function marshalToolResult(result: AgentToolResult<unknown>) {
+	const texts = result.content.filter((part) => part.type === "text").map((part) => part.text);
+	const images = result.content
+		.filter((part) => part.type === "image")
+		.map((part) => ({ mimeType: part.mimeType, dataBase64: part.data }));
+	const details =
+		typeof result.details === "object" &&
+		result.details !== null &&
+		!Array.isArray(result.details) &&
+		Object.keys(result.details).length === 0
+			? undefined
+			: result.details;
+	const hasError = toolResultIsError(result);
+	const text = texts.join("\n");
+	return images.length === 0 && details === undefined && !hasError ? { text } : { text, details, images, hasError };
+}
+
+export function toolResultIsError(result: AgentToolResult<unknown>): boolean {
+	const details = result.details;
+	return typeof details === "object" && details !== null && "isError" in details && details.isError === true;
+}

package/node_modules/@code-yeongyu/senpi-codemode/src/tool/types.ts

@@ -132,6 +132,8 @@ export interface EvalKernel {
 	deliverToolReply(message: Extract<HostToKernelMessage, { type: "tool-reply" }>): void;
 	reset(): Promise<void>;
 	close(): Promise<void>;
+	/** Names this kernel has registered; JS collides with other languages in the same session. */
+	listKernelToolNames?(): readonly string[];
 }
 
 export interface EvalKernelManager {

package/node_modules/@earendil-works/pi-agent-core/dist/agent-loop.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"agent-loop.d.ts","sourceRoot":"","sources":["../src/agent-loop.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAIN,KAAK,OAAO,EAEZ,WAAW,EAIX,MAAM,uBAAuB,CAAC;AAW/B,OAAO,KAAK,EACX,YAAY,EACZ,UAAU,EACV,eAAe,EAEf,YAAY,EACZ,SAAS,EACT,aAAa,EAEb,QAAQ,EACR,MAAM,YAAY,CAAC;AAEpB,MAAM,MAAM,cAAc,GAAG,CAAC,KAAK,EAAE,UAAU,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;AAEzE;;;GAGG;AACH,wBAAgB,SAAS,CACxB,OAAO,EAAE,YAAY,EAAE,EACvB,OAAO,EAAE,YAAY,EACrB,MAAM,EAAE,eAAe,EACvB,MAAM,EAAE,WAAW,GAAG,SAAS,EAC/B,QAAQ,EAAE,QAAQ,GAChB,WAAW,CAAC,UAAU,EAAE,YAAY,EAAE,CAAC,CAiBzC;AAED;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAChC,OAAO,EAAE,YAAY,EACrB,MAAM,EAAE,eAAe,EACvB,MAAM,EAAE,WAAW,GAAG,SAAS,EAC/B,QAAQ,EAAE,QAAQ,GAChB,WAAW,CAAC,UAAU,EAAE,YAAY,EAAE,CAAC,CAwBzC;AAED,wBAAsB,YAAY,CACjC,OAAO,EAAE,YAAY,EAAE,EACvB,OAAO,EAAE,YAAY,EACrB,MAAM,EAAE,eAAe,EACvB,IAAI,EAAE,cAAc,EACpB,MAAM,EAAE,WAAW,GAAG,SAAS,EAC/B,QAAQ,EAAE,QAAQ,GAChB,OAAO,CAAC,YAAY,EAAE,CAAC,CAgBzB;AAED,wBAAsB,oBAAoB,CACzC,OAAO,EAAE,YAAY,EACrB,MAAM,EAAE,eAAe,EACvB,IAAI,EAAE,cAAc,EACpB,MAAM,EAAE,WAAW,GAAG,SAAS,EAC/B,QAAQ,EAAE,QAAQ,GAChB,OAAO,CAAC,YAAY,EAAE,CAAC,CAiBzB;AAmBD,qBAAa,uBAAwB,SAAQ,KAAK;IACjD,YAAY,SAAS,EAAE,MAAM,EAK5B;CACD;AA2ND,uGAAuG;AACvG,wBAAsB,oBAAoB,CACzC,OAAO,EAAE,YAAY,EACrB,MAAM,EAAE,IAAI,CAAC,eAAe,EAAE,cAAc,GAAG,kBAAkB,CAAC,EAClE,MAAM,CAAC,EAAE,WAAW,GAClB,OAAO,CAAC,OAAO,CAAC,CAIlB;AA+mBD,MAAM,WAAW,qBAAqB;IACrC,QAAQ,EAAE,aAAa,CAAC;IACxB,IAAI,EAAE,SAAS,CAAC;IAChB,IAAI,EAAE,OAAO,CAAC;CACd;AAED,wBAAgB,6BAA6B,CAAC,IAAI,EAAE,SAAS,EAAE,QAAQ,EAAE,aAAa,GAAG,aAAa,CAYrG;AAED,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,SAAS,EAAE,QAAQ,EAAE,aAAa,GAAG,qBAAqB,CAOpG"}
+{"version":3,"file":"agent-loop.d.ts","sourceRoot":"","sources":["../src/agent-loop.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAIN,KAAK,OAAO,EAEZ,WAAW,EAIX,MAAM,uBAAuB,CAAC;AAgB/B,OAAO,KAAK,EACX,YAAY,EACZ,UAAU,EACV,eAAe,EAEf,YAAY,EACZ,SAAS,EACT,aAAa,EAEb,QAAQ,EACR,MAAM,YAAY,CAAC;AAEpB,MAAM,MAAM,cAAc,GAAG,CAAC,KAAK,EAAE,UAAU,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;AAEzE;;;GAGG;AACH,wBAAgB,SAAS,CACxB,OAAO,EAAE,YAAY,EAAE,EACvB,OAAO,EAAE,YAAY,EACrB,MAAM,EAAE,eAAe,EACvB,MAAM,EAAE,WAAW,GAAG,SAAS,EAC/B,QAAQ,EAAE,QAAQ,GAChB,WAAW,CAAC,UAAU,EAAE,YAAY,EAAE,CAAC,CAiBzC;AAED;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAChC,OAAO,EAAE,YAAY,EACrB,MAAM,EAAE,eAAe,EACvB,MAAM,EAAE,WAAW,GAAG,SAAS,EAC/B,QAAQ,EAAE,QAAQ,GAChB,WAAW,CAAC,UAAU,EAAE,YAAY,EAAE,CAAC,CAwBzC;AAED,wBAAsB,YAAY,CACjC,OAAO,EAAE,YAAY,EAAE,EACvB,OAAO,EAAE,YAAY,EACrB,MAAM,EAAE,eAAe,EACvB,IAAI,EAAE,cAAc,EACpB,MAAM,EAAE,WAAW,GAAG,SAAS,EAC/B,QAAQ,EAAE,QAAQ,GAChB,OAAO,CAAC,YAAY,EAAE,CAAC,CAgBzB;AAED,wBAAsB,oBAAoB,CACzC,OAAO,EAAE,YAAY,EACrB,MAAM,EAAE,eAAe,EACvB,IAAI,EAAE,cAAc,EACpB,MAAM,EAAE,WAAW,GAAG,SAAS,EAC/B,QAAQ,EAAE,QAAQ,GAChB,OAAO,CAAC,YAAY,EAAE,CAAC,CAiBzB;AAmBD,qBAAa,uBAAwB,SAAQ,KAAK;IACjD,YAAY,SAAS,EAAE,MAAM,EAK5B;CACD;AA2ND,uGAAuG;AACvG,wBAAsB,oBAAoB,CACzC,OAAO,EAAE,YAAY,EACrB,MAAM,EAAE,IAAI,CAAC,eAAe,EAAE,cAAc,GAAG,kBAAkB,CAAC,EAClE,MAAM,CAAC,EAAE,WAAW,GAClB,OAAO,CAAC,OAAO,CAAC,CAIlB;AA2oBD,MAAM,WAAW,qBAAqB;IACrC,QAAQ,EAAE,aAAa,CAAC;IACxB,IAAI,EAAE,SAAS,CAAC;IAChB,IAAI,EAAE,OAAO,CAAC;CACd;AAED,wBAAgB,6BAA6B,CAAC,IAAI,EAAE,SAAS,EAAE,QAAQ,EAAE,aAAa,GAAG,aAAa,CAYrG;AAED,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,SAAS,EAAE,QAAQ,EAAE,aAAa,GAAG,qBAAqB,CAOpG"}

package/node_modules/@earendil-works/pi-agent-core/dist/agent-loop.js

@@ -5,6 +5,7 @@
 import { EventStream, isCursorExecResolved, validateToolArguments, } from "@earendil-works/pi-ai";
 import { createTerminalFailureAssistantMessage, demoteToolUseWithoutToolCalls, isStreamIdleTimeoutError, normalizeTerminalAssistantMessage, promoteStopWithPendingToolCalls, shouldFinalizeIdleAsStop, shouldTerminateAssistantTurn, } from "./assistant-terminal-state.js";
 import { getDefaultStreamFn, withEmptyAssistantRecovery } from "./stream-fn.js";
+import { createStreamThroughputWatchdog, estimateStreamedUnits, } from "./stream-throughput-watchdog.js";
 /**
  * Start an agent loop with a new prompt message.
  * The prompt is added to the context and events are emitted for it.
@@ -346,7 +347,7 @@ async function streamAssistantResponse(context, config, signal, emit, streamFunc
                 : {}),
         });
         const iterator = response[Symbol.asyncIterator]();
-        const eventReader = createAssistantEventReader(iterator, streamIdleTimeoutMs, requestAbortController.signal, (error) => requestAbortController.abort(error), config.streamStartTimeoutMs, response);
+        const eventReader = createAssistantEventReader(iterator, streamIdleTimeoutMs, requestAbortController.signal, (error) => requestAbortController.abort(error), config.streamStartTimeoutMs, response, createStreamThroughputWatchdog(config.streamThroughput));
         try {
             while (true) {
                 const next = await eventReader.next();
@@ -496,7 +497,13 @@ function closeAssistantIterator(iterator) {
 function normalizeTimeoutMs(timeoutMs) {
     return typeof timeoutMs === "number" && Number.isFinite(timeoutMs) && timeoutMs > 0 ? timeoutMs : undefined;
 }
-function createAssistantEventReader(iterator, timeoutMs, signal, onIdleTimeout, streamStartTimeoutMs, stream) {
+/** Streamed units carried by one assistant event; only text and thinking count. */
+function streamedUnitsOf(event) {
+    if (event.type === "text_delta" || event.type === "thinking_delta")
+        return estimateStreamedUnits(event.delta);
+    return 0;
+}
+function createAssistantEventReader(iterator, timeoutMs, signal, onIdleTimeout, streamStartTimeoutMs, stream, throughput) {
     const idleTimeoutMs = normalizeTimeoutMs(timeoutMs);
     const startTimeoutMs = normalizeTimeoutMs(streamStartTimeoutMs);
     let sawFirstEvent = false;
@@ -527,9 +534,29 @@ function createAssistantEventReader(iterator, timeoutMs, signal, onIdleTimeout,
             const makeTimeoutError = useStartBound
                 ? (ms) => new StreamStartTimeoutError(ms)
                 : (ms) => new StreamIdleTimeoutError(ms);
+            // A provider executing a server-requested tool locally (Cursor's exec
+            // channel) is not streaming; that span must not count against the rate.
+            const localWorkPending = throughput !== undefined && stream?.hasPendingLocalWork?.() === true;
+            const waitStartedAt = localWorkPending ? Date.now() : 0;
             const result = await readNextAssistantEvent(iterator, readTimeoutMs, makeTimeoutError, abortPromise, onIdleTimeout, stream, signal);
-            if (!result.done)
+            if (localWorkPending)
+                throughput?.exclude(Date.now() - waitStartedAt);
+            if (!result.done) {
                 sawFirstEvent = true;
+                if (throughput !== undefined) {
+                    // The rate clock starts at the first event, exactly where the
+                    // stream-start bound stops applying.
+                    throughput.start();
+                    const degraded = throughput.record(streamedUnitsOf(result.value));
+                    if (degraded !== undefined) {
+                        closeAssistantIterator(iterator);
+                        // Abort before rejecting: the caller inspects the request signal's
+                        // reason, and the crawling upstream must be torn down either way.
+                        onIdleTimeout?.(degraded);
+                        throw degraded;
+                    }
+                }
+            }
             return result;
         },
         dispose: () => removeAbortListener?.(),