@nhtio/adk 1.20260913.0 → 1.20260924.0

package/batteries/llm/claude_code_cli/adapter.mjs

@@ -1,14 +1,15 @@
 import { i as __require } from "../../../chunk-Cf1989ZW.mjs";
-import { r as Tokenizable } from "../../../tokenizable-xPXj1AQX.mjs";
 import { n as isInstanceOf, r as isObject, t as isError } from "../../../guards-BEpY7lBI.mjs";
-import { f as ArtifactTool, h as canonicalStringify, t as SpooledArtifact } from "../../../spooled_artifact-BMtuIsu6.mjs";
-import { n as Message } from "../../../thought-BEsItcp_.mjs";
-import { n as Media, t as ToolCall } from "../../../tool_call-Cahji8ZY.mjs";
-import "../../../common-AhsMepUS.mjs";
+import { r as Tokenizable } from "../../../tokenizable-xPXj1AQX.mjs";
+import { d as ArtifactTool, h as canonicalStringify, t as SpooledArtifact } from "../../../spooled_artifact-BkOe4-j-.mjs";
+import { n as Message } from "../../../thought-BrQt6HAb.mjs";
+import { n as Media, t as ToolCall } from "../../../tool_call-8crmZsO8.mjs";
+import "../../../common-B5maOoF_.mjs";
 import "../../../guards.mjs";
 import { InMemorySpoolStore } from "../../storage/in_memory.mjs";
-import { C as looksLikeSpooledArtifact, D as renderArtifactHandleBody, _ as defaultRenderUntrustedContent, c as defaultRenderMemories, d as defaultRenderRetrievables, f as defaultRenderStandingInstructions, g as defaultRenderTrustedContent, h as defaultRenderThought, i as defaultFilterThoughts, l as defaultRenderRetrievableHandleBody, m as defaultRenderThirdPartyPublicRetrievables, o as defaultRenderChatCompletionsSystemPrompt, p as defaultRenderThirdPartyPrivateRetrievables, r as defaultDescriptionToChatCompletionsJsonSchema, s as defaultRenderFirstPartyRetrievables, u as defaultRenderRetrievableSafetyDirective, v as defaultToolsToChatCompletionsTools } from "../../../helpers-So6bNfJp.mjs";
-import { E_CLAUDE_CODE_CLI_CONTEXT_OVERFLOW, E_CLAUDE_CODE_CLI_MCP_BRIDGE_STARTUP_FAILED, E_CLAUDE_CODE_CLI_PROCESS_EXITED_NONZERO, E_CLAUDE_CODE_CLI_STARTUP_TIMEOUT, E_CLAUDE_CODE_CLI_STREAM_STALLED, E_CLAUDE_CODE_CLI_TURN_FAILED, E_CLAUDE_CODE_CLI_WRAPPER_CRASHED, E_CLAUDE_CODE_CLI_WRAPPER_SPAWN_ERROR, E_INVALID_CLAUDE_CODE_CLI_OPTIONS } from "./exceptions.mjs";
+import { C as looksLikeSpooledArtifact, D as renderArtifactHandleBody, _ as defaultRenderUntrustedContent, c as defaultRenderMemories, d as defaultRenderRetrievables, f as defaultRenderStandingInstructions, g as defaultRenderTrustedContent, h as defaultRenderThought, i as defaultFilterThoughts, l as defaultRenderRetrievableHandleBody, m as defaultRenderThirdPartyPublicRetrievables, o as defaultRenderChatCompletionsSystemPrompt, p as defaultRenderThirdPartyPrivateRetrievables, r as defaultDescriptionToChatCompletionsJsonSchema, s as defaultRenderFirstPartyRetrievables, u as defaultRenderRetrievableSafetyDirective, v as defaultToolsToChatCompletionsTools } from "../../../helpers-C1T0DV8Q.mjs";
+import { t as deCollideToolCallIds } from "../../../chat_common-CeoHwSsz.mjs";
+import { E_CLAUDE_CODE_CLI_CONTEXT_OVERFLOW, E_CLAUDE_CODE_CLI_MCP_BRIDGE_STARTUP_FAILED, E_CLAUDE_CODE_CLI_PROCESS_EXITED_NONZERO, E_CLAUDE_CODE_CLI_STARTUP_TIMEOUT, E_CLAUDE_CODE_CLI_STREAM_ERROR, E_CLAUDE_CODE_CLI_STREAM_STALLED, E_CLAUDE_CODE_CLI_TURN_FAILED, E_CLAUDE_CODE_CLI_WRAPPER_CRASHED, E_CLAUDE_CODE_CLI_WRAPPER_NOT_FOUND, E_CLAUDE_CODE_CLI_WRAPPER_SPAWN_ERROR, E_INVALID_CLAUDE_CODE_CLI_OPTIONS } from "./exceptions.mjs";
 import { validateOptions } from "./validation.mjs";
 import { createNdjsonLineReader, encodeWrapperCommand } from "./wire.mjs";
 import { defaultBuildClaudeCodeCliPrompt, defaultRenderClaudeCodeCliTimelineMessage, defaultRenderClaudeCodeCliToolCallResult } from "./helpers.mjs";
@@ -44,6 +45,157 @@ var resolveDefaultWrapperPath = () => {
 	if (typeof __require === "function" && typeof __require.resolve === "function") return __require.resolve("../../../claude-code-cli-wrapper.cjs");
 	return decodeURIComponent(new URL("../../../claude-code-cli-wrapper.mjs", "" + import.meta.url).pathname);
 };
+/**
+* Existence-check a candidate wrapper path, lazily acquiring `node:fs`'s `existsSync` — never
+* imported at module scope for the same reason `resolveDefaultWrapperPath` avoids `node:url`
+* above: this file is transitively pulled into the browser test project via `src/batteries`'s
+* barrel, and a module-scope Node-builtin import would throw at import time there. Any failure to
+* even acquire `node:fs` (e.g. a hostile/exotic runtime) is treated as "does not exist" rather
+* than propagating, since this is only ever used to pick between fallback candidates.
+*/
+var existsOnDisk = async (path) => {
+	try {
+		const fs = await import("node:fs");
+		return typeof fs.existsSync === "function" && fs.existsSync(path);
+	} catch {
+		return false;
+	}
+};
+/**
+* Resolve the wrapper asset's sibling path relative to THIS PACKAGE's own already-published main
+* entry, rather than relative to the (possibly relocated-by-bundling) adapter module. Node's
+* package self-reference feature — a package resolving its own name as a bare specifier — is
+* depth-independent within `@nhtio/adk`'s own tree, so this survives the adapter code being moved
+* around WITHIN the package by a bundler. It only breaks once the calling code has been physically
+* bundled OUTSIDE `@nhtio/adk`'s own directory tree (e.g. into a consumer's Electron main-process
+* bundle) — at that point self-reference falls back to ordinary node_modules bare-specifier
+* resolution, which succeeds exactly when `@nhtio/adk` is still installed as a resolvable
+* dependency from the bundled code's new location. That is the same "normal case" the published
+* `wrapperPath` override already exists for, so this fallback is a strict improvement with no new
+* failure mode: when it can't resolve, behavior degrades to the pre-existing "throw a clear error"
+* path below rather than a worse outcome.
+*
+* Deliberately resolves this package's `exports['.']` main entry (already published, no `exports`
+* map change needed) and derives the wrapper's path as a sibling of that entry's directory — every
+* `vite.config.mts` `build.lib.entry` key (including the un-tagged wrapper) emits to a flat
+* `dist/` directory, so `dirname(mainEntry) === dirname(wrapperAsset)`.
+*
+* Two independent ways to reach a `require`-like resolver are tried, in this order, because a
+* bundled consumer may land in either shape and each leaves the OTHER unusable:
+*
+* 1. A real ambient `require` — present when THIS MODULE has itself been bundled into a CJS
+*    output (e.g. `esbuild --platform=node --format=cjs`, which is common for an Electron
+*    main-process bundle, the issue's reported scenario). Reused verbatim is the exact same
+*    discriminator `resolveDefaultWrapperPath` above already documents:
+*    `typeof require === 'function' && typeof require.resolve === 'function'` — because a bundled
+*    ESM output can ALSO leave a truthy `require` behind as a dynamic-require shim/Proxy (rolldown
+*    and esbuild both do this) whose `.resolve` is not itself a function, and calling it would
+*    throw rather than genuinely resolving anything. In a genuine CJS bundle this ambient
+*    `require.resolve('@nhtio/adk')` works directly with no `createRequire` bridge needed.
+* 2. `createRequire(import.meta.url)` — the ESM path, used only when step 1 didn't yield a usable
+*    resolver. Verified empirically that esbuild's `--format=cjs` output rewrites every
+*    `import.meta` reference in bundled source to a plain `var import_meta = {}`, so
+*    `import.meta.url` is `undefined` there — `createRequire(undefined)` throws
+*    `ERR_INVALID_ARG_VALUE` outright, so this branch is skipped by checking
+*    `typeof import.meta.url === 'string'` first rather than letting that throw surface as an
+*    opaque, unrelated-looking error. `createRequire` (rather than `import.meta.resolve`) is used
+*    here because — unlike `import.meta.resolve` — its `.resolve` performs a real filesystem
+*    existence check (verified directly: `import.meta.resolve` happily returns a URL for a target
+*    file that does not exist, since it only resolves the `exports` map syntactically;
+*    `require.resolve`, including through `createRequire`, throws `MODULE_NOT_FOUND` for a missing
+*    target), so a resolved path here is already known to exist and only the derived wrapper
+*    sibling still needs its own explicit check below.
+*
+* `tried` always accounts for BOTH routes once step 1 has not already produced a `mainEntry`: step
+* 2 either resolves, records its own failure, or — when `import.meta.url` isn't even a string —
+* records an explicit "skipped: import.meta.url unavailable" entry, so the thrown error's "Tried:"
+* list never silently omits a route just because it was never attempted.
+*
+* A `process.cwd()`-anchored resolution attempt is deliberately NOT included as a further
+* fallback: resolution should stay anchored to the bundle's own module identity, not to a mutable,
+* launch-directory-dependent value that has no necessary relationship to where the bundle — or
+* `@nhtio/adk` — actually live. Failing clearly and pointing at `wrapperPath` is a better outcome
+* than a resolution that silently varies with the process's current working directory.
+*/
+var resolveWrapperPathViaSelfReference = async (wrapperBasename, seams = {}) => {
+	const tried = [];
+	let mainEntry;
+	if (seams.ambientRequireResolve !== void 0 || typeof __require === "function" && typeof __require.resolve === "function") try {
+		mainEntry = (seams.ambientRequireResolve ?? __require.resolve)("@nhtio/adk");
+	} catch (err) {
+		tried.push(`self-reference via ambient require('@nhtio/adk') failed: ${isError(err) ? err.message : String(err)}`);
+	}
+	if (mainEntry === void 0) {
+		const importMetaUrl = "importMetaUrl" in seams ? seams.importMetaUrl : import.meta.url;
+		if (typeof importMetaUrl === "string") try {
+			const { createRequire } = await import("node:module");
+			mainEntry = createRequire(importMetaUrl).resolve("@nhtio/adk");
+		} catch (err) {
+			tried.push(`self-reference via createRequire(import.meta.url).resolve('@nhtio/adk') failed: ${isError(err) ? err.message : String(err)}`);
+		}
+		else tried.push("self-reference via createRequire(import.meta.url) skipped: import.meta.url unavailable in this module context");
+	}
+	if (mainEntry === void 0) return { tried };
+	const lastSlash = mainEntry.lastIndexOf("/");
+	if (lastSlash < 0) {
+		tried.push(`self-reference resolved '@nhtio/adk' to an unexpected path with no directory separator: ${mainEntry}`);
+		return { tried };
+	}
+	const candidate = `${mainEntry.slice(0, lastSlash + 1)}${wrapperBasename}`;
+	tried.push(candidate);
+	return await existsOnDisk(candidate) ? {
+		path: candidate,
+		tried
+	} : { tried };
+};
+/**
+* Internal, non-public resolver used by the executor call site (never `resolveDefaultWrapperPath`
+* itself, which stays synchronous and unchanged for backwards compatibility with any caller that
+* already imports it directly). Tries the existing relative-to-module resolution FIRST — zero
+* behavior change for the common unbundled case — and only falls back to the self-reference
+* lookup when that candidate does not exist on disk (bundling relocated the adapter). Throws
+* {@link E_CLAUDE_CODE_CLI_WRAPPER_NOT_FOUND} naming every path tried — the relative candidate (or
+* its resolution error) AND every self-reference candidate/reason from
+* {@link resolveWrapperPathViaSelfReference} — when neither resolves, rather than letting a bundled
+* consumer hit an opaque `MODULE_NOT_FOUND`/ENOENT deep inside `execa`, or a truncated error that
+* hides what the self-reference fallback actually attempted.
+*
+* @remarks
+* Electron/asar note: an app packaged into an `asar` archive can still `readFileSync`/`existsSync`
+* transparently-unpacked paths through Electron's patched `fs`, so this existence-check strategy
+* keeps working there without special-casing — but a wrapper asset that ships unpacked (outside
+* `asar`) is still the consumer's responsibility to arrange, same as any other spawned-executable
+* asset; `wrapperPath` remains the escape hatch when that layout doesn't line up.
+*
+* @remarks
+* Coverage note — deployment shapes: this resolver (both branches) only ever finds the wrapper
+* asset when `@nhtio/adk` itself (with `dist/claude-code-cli-wrapper.{cjs,mjs}` inside it) remains
+* an ordinarily-resolvable dependency from wherever the bundle ends up running — the bundle never
+* carries the wrapper asset itself. A bundle relocated outside its original project (so
+* `node_modules/@nhtio/adk` is no longer reachable), or an Electron app that prunes/asar-packs
+* `@nhtio/adk` out of its final package, is NOT covered by either branch and needs the explicit
+* `wrapperPath` option — which is exactly what the thrown error's message directs the caller to.
+*/
+var resolveWrapperPathWithFallback = async (seams = {}) => {
+	const resolveRelative = seams.resolveRelative ?? resolveDefaultWrapperPath;
+	const resolveSelfRef = seams.resolveSelfRef ?? resolveWrapperPathViaSelfReference;
+	const checkExists = seams.checkExists ?? existsOnDisk;
+	const tried = [];
+	let relative;
+	try {
+		relative = resolveRelative();
+	} catch (err) {
+		tried.push(isError(err) ? err.message : String(err));
+	}
+	if (relative !== void 0) {
+		tried.push(relative);
+		if (await checkExists(relative)) return relative;
+	}
+	const selfRef = await resolveSelfRef(relative !== void 0 && relative.endsWith(".cjs") ? "claude-code-cli-wrapper.cjs" : "claude-code-cli-wrapper.mjs");
+	tried.push(...selfRef.tried);
+	if (selfRef.path !== void 0) return selfRef.path;
+	throw new E_CLAUDE_CODE_CLI_WRAPPER_NOT_FOUND([tried.join(", ") || "(no candidates)"]);
+};
 var resolveExeca = async (supplied) => {
 	let value = supplied ?? (() => import("execa"));
 	if (typeof value === "function" && !("exec" in value)) try {
@@ -108,6 +260,36 @@ var resolveHelpers = (overrides) => {
 var estimateTokensOf = async (value, encoding) => Promise.resolve(value.estimateTokens(encoding));
 var nowIso = () => (/* @__PURE__ */ new Date()).toISOString();
 /**
+* Normalise a thrown/rejected value into a real `Error` suitable as an exception `.cause`. Mirrors
+* `dispatch_runner.ts`'s internal (non-exported) `toErrorCause` convention: a genuine `Error` (per
+* the cross-realm-safe {@link isError} guard) passes through unchanged; anything else — a string,
+* a plain object, a cross-realm error whose `instanceof Error` is false — is wrapped in a real
+* `Error` whose message is the value's best string form, with the original preserved on `.cause`.
+*
+* Never throws. It runs inside the adapter's last-line-of-defence catch handlers (the `onEvent`
+* rejection handler, the stdout `'data'` listener, the background-shutdown rejection handler), so a
+* throw here would recreate the exact unhandled-rejection / uncaught-exception class it exists to
+* prevent. A hostile thrown value can defeat BOTH `JSON.stringify` and `String` (a `Proxy` with a
+* throwing trap, or an object whose `toJSON` and `toString` both throw) and can even make the
+* `isError` guard itself throw, so each step is guarded and the last resort is a fixed string.
+*/
+var toErrorCause = (value) => {
+	try {
+		if (isError(value)) return value;
+	} catch {}
+	let text;
+	try {
+		text = typeof value === "string" ? value : value === void 0 ? "undefined" : JSON.stringify(value) ?? String(value);
+	} catch {
+		try {
+			text = String(value);
+		} catch {
+			text = "[unserialisable thrown value]";
+		}
+	}
+	return new Error(`non-Error thrown while handling a wrapper event: ${text}`, { cause: value });
+};
+/**
 * Integrity checksum over `tool`/`args` — matches every other LLM battery's convention
 * (`sha256(canonicalStringify({tool, args}))`, see `ollama/adapter.ts`'s `computeChecksum`), NOT
 * the per-call `requestId`. Identical repeat calls must share this checksum: it feeds
@@ -263,7 +445,13 @@ var ClaudeCodeCliAdapter = class ClaudeCodeCliAdapter {
 				ctx.nack(isError(err) ? err : new Error(String(err)));
 				return;
 			}
-			const wrapperPath = merged.wrapperPath ?? resolveDefaultWrapperPath();
+			let wrapperPath;
+			try {
+				wrapperPath = merged.wrapperPath ?? await resolveWrapperPathWithFallback();
+			} catch (err) {
+				ctx.nack(isError(err) ? err : new Error(String(err)));
+				return;
+			}
 			const claudeBin = merged.claudeBin ?? "claude";
 			const renderedToolCallResults = /* @__PURE__ */ new Map();
 			for (const tc of ctx.turnToolCalls) {
@@ -400,6 +588,7 @@ var ClaudeCodeCliAdapter = class ClaudeCodeCliAdapter {
 			let currentMessageId;
 			let currentMessageBuffer = "";
 			let sealedMessage = false;
+			let inFlightToolCalls = 0;
 			const clearStartupTimer = () => {
 				if (startupTimer) clearTimeout(startupTimer);
 				startupTimer = void 0;
@@ -423,14 +612,26 @@ var ClaudeCodeCliAdapter = class ClaudeCodeCliAdapter {
 					Promise.resolve(child).finally(() => {
 						clearTimeout(timer);
 						resolve();
-					});
+					}).catch(() => {});
 				});
 				try {
 					child.kill("SIGTERM");
 				} catch {}
 			};
+			const shutdownInBackground = () => {
+				gracefulShutdown().catch((err) => {
+					const cause = toErrorCause(err);
+					try {
+						helpers.log.debug({
+							kind: "graceful-shutdown-rejected",
+							message: `Best-effort wrapper shutdown failed; ignoring (the turn has already settled or is settling independently): ${cause.message}`,
+							payload: { cause: cause.message }
+						});
+					} catch {}
+				});
+			};
 			const abortListener = () => {
-				gracefulShutdown();
+				shutdownInBackground();
 			};
 			ctx.abortSignal.addEventListener("abort", abortListener, { once: true });
 			const detachAbortListener = () => ctx.abortSignal.removeEventListener("abort", abortListener);
@@ -440,22 +641,50 @@ var ClaudeCodeCliAdapter = class ClaudeCodeCliAdapter {
 				clearStartupTimer();
 				clearIdleTimer();
 				detachAbortListener();
-				fn();
+				let threw = false;
+				try {
+					fn();
+				} catch (err) {
+					threw = true;
+					try {
+						const cause = toErrorCause(err);
+						try {
+							helpers.log.error({
+								kind: "settlement-handler-threw",
+								message: `A dispatch settlement handler threw while finalising the turn; nacking (if not already signalled) instead of leaving the executor hung: ${cause.message}`,
+								payload: { cause: cause.message }
+							});
+						} catch {}
+						if (!ctx.isSignalled) try {
+							ctx.nack(new E_CLAUDE_CODE_CLI_STREAM_ERROR([cause.message], { cause }));
+						} catch {}
+					} catch {}
+				} finally {
+					if (threw) {
+						try {
+							shutdownInBackground();
+						} catch {}
+						try {
+							resolveIteration?.();
+						} catch {}
+					}
+				}
 			};
 			startupTimer = setTimeout(() => {
 				settleOnce(() => {
 					resolveIteration?.();
-					gracefulShutdown();
+					shutdownInBackground();
 					ctx.nack(new E_CLAUDE_CODE_CLI_STARTUP_TIMEOUT([startupTimeoutMs]));
 				});
 			}, startupTimeoutMs);
 			const armIdleTimer = () => {
 				if (!sawReady || !sawInit) return;
+				if (inFlightToolCalls > 0) return;
 				clearIdleTimer();
 				idleTimer = setTimeout(() => {
 					settleOnce(() => {
 						resolveIteration?.();
-						gracefulShutdown();
+						shutdownInBackground();
 						ctx.nack(new E_CLAUDE_CODE_CLI_STREAM_STALLED([streamIdleTimeoutMs]));
 					});
 				}, streamIdleTimeoutMs);
@@ -489,7 +718,8 @@ var ClaudeCodeCliAdapter = class ClaudeCodeCliAdapter {
 					return;
 				}
 				const args = isObject(rawArgs) ? rawArgs : {};
-				helpers.reportToolCall(requestId, {
+				const callId = (merged.toolCallIdFilter ?? deCollideToolCallIds)(requestId, ctx);
+				helpers.reportToolCall(callId, {
 					tool: tool.name,
 					args
 				});
@@ -505,24 +735,24 @@ var ClaudeCodeCliAdapter = class ClaudeCodeCliAdapter {
 					else if (Array.isArray(raw) && raw.length > 0 && raw.every((m) => Media.isMedia(m))) results = raw;
 					else if (looksLikeSpooledArtifact(raw)) results = raw;
 					else if (typeof raw === "string" || isInstanceOf(raw, "Uint8Array", Uint8Array)) {
-						const reader = await spoolStore.write(requestId, raw);
+						const reader = await spoolStore.write(callId, raw);
 						results = new ((tool.artifactConstructor?.()) ?? SpooledArtifact)(reader);
 					} else {
-						const reader = await spoolStore.write(requestId, String(raw));
+						const reader = await spoolStore.write(callId, String(raw));
 						results = new ((tool.artifactConstructor?.()) ?? SpooledArtifact)(reader);
 					}
 				} catch (err) {
 					toolHadError = true;
 					results = new Tokenizable(isError(err) ? err.message : String(err));
 				}
-				helpers.reportToolCall(requestId, {
+				helpers.reportToolCall(callId, {
 					results,
 					isError: toolHadError,
 					isComplete: true
 				});
 				const completedAt = nowIso();
 				await ctx.storeToolCall(new ToolCall({
-					id: requestId,
+					id: callId,
 					tool: tool.name,
 					args,
 					checksum: computeChecksum(tool.name, args),
@@ -539,7 +769,7 @@ var ClaudeCodeCliAdapter = class ClaudeCodeCliAdapter {
 				try {
 					rendered = await renderOutboundResult({
 						raw: results,
-						callId: requestId,
+						callId,
 						inline: isArtifactTool,
 						spoolStore,
 						unsupportedResultMediaPolicy: merged.unsupportedResultMediaPolicy ?? merged.unsupportedMediaPolicy ?? "throw"
@@ -594,7 +824,6 @@ var ClaudeCodeCliAdapter = class ClaudeCodeCliAdapter {
 							bridgedTools,
 							extraArgs: merged.extraArgs
 						});
-						armIdleTimer();
 						return;
 					}
 					if (event.type === "init") {
@@ -605,11 +834,15 @@ var ClaudeCodeCliAdapter = class ClaudeCodeCliAdapter {
 							message: "Claude Code CLI initialized.",
 							payload: event
 						});
-						if (event.mcpServerErrors && event.mcpServerErrors.length > 0) settleOnce(() => {
-							finish();
-							gracefulShutdown();
-							ctx.nack(new E_CLAUDE_CODE_CLI_MCP_BRIDGE_STARTUP_FAILED([event.mcpServerErrors.join(", ")]));
-						});
+						if (event.mcpServerErrors && event.mcpServerErrors.length > 0) {
+							settleOnce(() => {
+								finish();
+								shutdownInBackground();
+								ctx.nack(new E_CLAUDE_CODE_CLI_MCP_BRIDGE_STARTUP_FAILED([event.mcpServerErrors.join(", ")]));
+							});
+							return;
+						}
+						armIdleTimer();
 						return;
 					}
 					if (event.type === "retry") {
@@ -625,14 +858,23 @@ var ClaudeCodeCliAdapter = class ClaudeCodeCliAdapter {
 						currentMessageBuffer += event.delta;
 						helpers.reportMessage(event.id, event.delta, { isComplete: event.isComplete });
 						if (event.isComplete) await sealCurrentMessage();
+						armIdleTimer();
 						return;
 					}
 					if (event.type === "thought_delta") {
 						helpers.reportThought(event.id, event.delta, { isComplete: event.isComplete });
+						armIdleTimer();
 						return;
 					}
 					if (event.type === "tool_call_request") {
-						await handleToolCallRequest(event.requestId, event.tool, event.args);
+						inFlightToolCalls += 1;
+						clearIdleTimer();
+						try {
+							await handleToolCallRequest(event.requestId, event.tool, event.args);
+						} finally {
+							inFlightToolCalls = Math.max(0, inFlightToolCalls - 1);
+						}
+						armIdleTimer();
 						return;
 					}
 					if (event.type === "result") {
@@ -662,7 +904,7 @@ var ClaudeCodeCliAdapter = class ClaudeCodeCliAdapter {
 					if (event.type === "error") {
 						settleOnce(() => {
 							finish();
-							gracefulShutdown();
+							shutdownInBackground();
 							ctx.nack(new E_CLAUDE_CODE_CLI_WRAPPER_CRASHED([event.message]));
 						});
 						return;
@@ -688,12 +930,27 @@ var ClaudeCodeCliAdapter = class ClaudeCodeCliAdapter {
 						});
 						return;
 					}
-					onEvent(event);
+					onEvent(event).catch((err) => {
+						const cause = toErrorCause(err);
+						settleOnce(() => {
+							resolveIteration?.();
+							shutdownInBackground();
+							ctx.nack(new E_CLAUDE_CODE_CLI_STREAM_ERROR([cause.message], { cause }));
+						});
+					});
 					return event;
 				});
 				child.stdout?.on("data", (chunk) => {
-					eventReader.push(chunk);
-					armIdleTimer();
+					try {
+						eventReader.push(chunk);
+					} catch (err) {
+						const cause = toErrorCause(err);
+						settleOnce(() => {
+							resolveIteration?.();
+							shutdownInBackground();
+							ctx.nack(new E_CLAUDE_CODE_CLI_STREAM_ERROR([cause.message], { cause }));
+						});
+					}
 				});
 				child.stdout?.on("end", () => {
 					if (sawTerminalEvent) return;
@@ -727,6 +984,6 @@ var ClaudeCodeCliAdapter = class ClaudeCodeCliAdapter {
 	}
 };
 //#endregion
-export { ClaudeCodeCliAdapter, resolveDefaultWrapperPath };
+export { ClaudeCodeCliAdapter, resolveWrapperPathViaSelfReference as __resolveWrapperPathViaSelfReference, resolveWrapperPathWithFallback as __resolveWrapperPathWithFallback, resolveDefaultWrapperPath };
 
 //# sourceMappingURL=adapter.mjs.map