@pivanov/claude-wire 0.0.2 → 0.0.4

package/dist/session.js

@@ -1,41 +1,90 @@
-import { LIMITS, TIMEOUTS } from "./constants.js";
+import { withTimeout } from "./async.js";
+import { LIMITS, MAX_BACKOFF_INDEX, RESPAWN_BACKOFF_MS, TIMEOUTS } from "./constants.js";
 import { createCostTracker } from "./cost.js";
-import { AbortError, BudgetExceededError, ClaudeError, isTransientError, KnownError, ProcessError, TimeoutError } from "./errors.js";
+import { AbortError, BudgetExceededError, ClaudeError, isTransientError, KnownError, processExitedEarly, TimeoutError } from "./errors.js";
 import { createTranslator } from "./parser/translator.js";
-import { buildResult } from "./pipeline.js";
-import { spawnClaude } from "./process.js";
+import { applyTurnComplete, buildResult, startPipeline } from "./pipeline.js";
+import { safeKill, safeWrite } from "./process.js";
 import { readNdjsonEvents } from "./reader.js";
 import { createToolHandler } from "./tools/handler.js";
 import { writer } from "./writer.js";
-const gracefulKill = async (p) => {
-    p.kill();
-    let timer;
-    let timedOut = false;
+// Two-stage termination: SIGTERM first, escalate to SIGKILL after the
+// graceful-exit timeout. A stuck child (e.g. blocked on a syscall that
+// ignores SIGTERM) would otherwise survive the "graceful" path and leak.
+// The sentinel value distinguishes "exited on time" from "timeout fired"
+// without a side-channel boolean.
+// Compose two optional AbortSignals into one. If either fires, the
+// returned signal aborts. Returns undefined when both inputs are undefined.
+const composeSignals = (a, b) => {
+    if (!a && !b) {
+        return undefined;
+    }
+    if (!a) {
+        return b;
+    }
+    if (!b) {
+        return a;
+    }
+    const ctrl = new AbortController();
+    const abort = () => ctrl.abort();
+    a.addEventListener("abort", abort, { once: true });
+    b.addEventListener("abort", abort, { once: true });
+    if (a.aborted || b.aborted) {
+        ctrl.abort();
+    }
+    return ctrl.signal;
+};
+// Fire both session-level and per-ask onRetry, swallowing throws from either.
+const fireRetry = (attempt, error, sessionLevel, askLevel) => {
     try {
-        await Promise.race([
-            p.exited,
-            new Promise((r) => {
-                timer = setTimeout(() => {
-                    timedOut = true;
-                    r();
-                }, TIMEOUTS.gracefulExitMs);
-            }),
-        ]);
+        sessionLevel?.(attempt, error);
     }
-    finally {
-        if (timer) {
-            clearTimeout(timer);
-        }
+    catch {
+        // observer threw -- retry still happens
     }
-    if (timedOut) {
-        try {
-            p.kill();
-        }
-        catch {
-            // already dead
-        }
+    try {
+        askLevel?.(attempt, error);
+    }
+    catch {
+        // observer threw -- retry still happens
     }
 };
+const KILL_TIMED_OUT = Symbol("kill-timed-out");
+const gracefulKill = async (p) => {
+    safeKill(p, "SIGTERM");
+    const outcome = await withTimeout(p.exited, TIMEOUTS.gracefulExitMs, () => KILL_TIMED_OUT);
+    if (outcome === KILL_TIMED_OUT) {
+        safeKill(p, "SIGKILL");
+    }
+};
+/**
+ * Creates a multi-turn Claude session backed by a single long-lived CLI
+ * process. Each `ask()` sends a user prompt and resolves with `TAskResult`
+ * for that turn. Calls are serialized -- a second `ask()` waits for the
+ * first to complete. Use `close()` (or `await using`) to free the process.
+ *
+ * ### Retry behavior
+ * Each `ask()` automatically retries transient failures -- process crashes
+ * matching SIGKILL/SIGTERM/SIGPIPE exit codes, `ECONNRESET`, `ECONNREFUSED`,
+ * `ETIMEDOUT`, `EHOSTUNREACH`, `ENETUNREACH`, `EAI_AGAIN`, Anthropic
+ * `overloaded_error` / 529s, broken-pipe / "socket hang up" messages, etc.
+ * (see `isTransientError`). Backoff is `500ms → 1s → 2s`; the budget is
+ * `LIMITS.maxRespawnAttempts` (currently 3) and is shared across a single
+ * `ask()`. When the budget is exhausted the session throws
+ * `KnownError("retry-exhausted")` and marks itself closed.
+ *
+ * Fatal errors -- `KnownError` and `BudgetExceededError` -- also close the
+ * session. Any subsequent `ask()` on a closed session rejects with
+ * `ClaudeError("Session is closed")`. All other errors (abort, timeout,
+ * non-transient `ProcessError`) propagate without closing, and the caller
+ * may decide whether to retry at a higher level.
+ *
+ * ### Observability
+ * - `onCostUpdate(snapshot)` -- fires after every `turn_complete`.
+ * - `onRetry(attempt, error)` -- fires each time a transient failure triggers
+ *   a respawn inside one `ask()`. Attempt is 1-indexed.
+ * - `onWarning(message, cause)` -- routes all library-emitted warnings.
+ */
 export const createSession = (options = {}) => {
     let proc;
     let currentSessionId;
@@ -46,6 +95,7 @@ export const createSession = (options = {}) => {
     const costTracker = createCostTracker({
         maxCostUsd: options.maxCostUsd,
         onCostUpdate: options.onCostUpdate,
+        onWarning: options.onWarning,
     });
     const toolHandler = options.tools ? createToolHandler(options.tools) : undefined;
     let inFlight;
@@ -61,31 +111,11 @@ export const createSession = (options = {}) => {
         }
         reader = undefined;
     };
-    let lastStderrChunks = [];
-    const drainStderr = (p) => {
-        const chunks = [];
-        lastStderrChunks = chunks;
-        const stderrReader = p.stderr.getReader();
-        const decoder = new TextDecoder();
-        (async () => {
-            try {
-                while (true) {
-                    const { done, value } = await stderrReader.read();
-                    if (done) {
-                        break;
-                    }
-                    chunks.push(decoder.decode(value, { stream: true }));
-                }
-            }
-            catch {
-                // process exited
-            }
-            finally {
-                stderrReader.releaseLock();
-            }
-        })().catch(() => { });
-    };
-    const getStderrText = () => lastStderrChunks.join("").trim();
+    // Drain handle from the most recent spawn. Stored as a whole so we
+    // can call `.text()` (shared helper on IStderrDrain) instead of
+    // reimplementing chunks.join/trim at every use site.
+    let lastStderrDrain;
+    const getStderrText = () => lastStderrDrain?.text() ?? "";
     const killProc = () => {
         if (proc) {
             proc.kill();
@@ -97,15 +127,31 @@ export const createSession = (options = {}) => {
     const spawnFresh = (prompt, resumeId) => {
         if (consecutiveCrashes >= LIMITS.maxRespawnAttempts) {
             killProc();
-            throw new ProcessError(`Process crashed ${consecutiveCrashes} times, giving up`);
+            // Typed code so consumers can pattern-match on
+            // `KnownError && err.code === "retry-exhausted"` without parsing strings.
+            throw new KnownError("retry-exhausted", `Process crashed ${consecutiveCrashes} times, giving up`);
         }
         costOffsets = costTracker.snapshot();
         killProc();
         translator.reset();
+        // Respawn always overrides caller-supplied options.resume with the live
+        // session id when one is available: mid-session recovery must resume the
+        // same conversation, not whatever static id was passed at construction.
         const spawnOpts = resumeId ? { prompt, ...options, resume: resumeId } : { prompt, ...options };
-        proc = spawnClaude(spawnOpts);
-        reader = proc.stdout.getReader();
-        drainStderr(proc);
+        const pipeline = startPipeline(spawnOpts);
+        proc = pipeline.proc;
+        reader = pipeline.reader;
+        lastStderrDrain = pipeline.stderr;
+    };
+    const respawnBackoff = async () => {
+        // consecutiveCrashes starts at 1 for the first retry; idx points
+        // into RESPAWN_BACKOFF_MS and clamps to the last defined entry for
+        // any crash count beyond the table length.
+        const idx = Math.min(consecutiveCrashes, MAX_BACKOFF_INDEX) - 1;
+        const delay = idx >= 0 ? RESPAWN_BACKOFF_MS[idx] : 0;
+        if (delay) {
+            await new Promise((r) => setTimeout(r, delay));
+        }
     };
     const readUntilTurnComplete = async (signal) => {
         if (!proc || !reader) {
@@ -119,14 +165,14 @@ export const createSession = (options = {}) => {
             toolHandler,
             proc,
             signal,
+            onWarning: options.onWarning,
         })) {
             if (event.type === "session_meta") {
                 currentSessionId = event.sessionId;
             }
             events.push(event);
             if (event.type === "turn_complete") {
-                costTracker.update(costOffsets.totalUsd + (event.costUsd ?? 0), costOffsets.inputTokens + (event.inputTokens ?? 0), costOffsets.outputTokens + (event.outputTokens ?? 0));
-                costTracker.checkBudget();
+                applyTurnComplete(event, costTracker, costOffsets);
                 gotTurnComplete = true;
                 break;
             }
@@ -135,50 +181,68 @@ export const createSession = (options = {}) => {
             if (signal?.aborted) {
                 throw new AbortError();
             }
-            const stderrMsg = getStderrText();
-            throw new ProcessError(stderrMsg || "Process exited without completing the turn");
+            // stdout closed → process is dying. Wait briefly for exited so we
+            // can attach an exit code to the error; if it doesn't resolve in
+            // time, force-kill and leave exitCode undefined (→ non-transient).
+            let exitCode;
+            if (proc) {
+                const live = proc;
+                exitCode = await withTimeout(live.exited, TIMEOUTS.gracefulExitMs);
+                if (exitCode === undefined) {
+                    live.kill();
+                }
+            }
+            if (lastStderrDrain) {
+                await withTimeout(lastStderrDrain.done, TIMEOUTS.stderrDrainGraceMs);
+            }
+            throw processExitedEarly(getStderrText(), exitCode);
         }
         return events;
     };
-    const doAsk = async (prompt) => {
+    const doAsk = async (prompt, askOpts) => {
         if (!proc) {
             spawnFresh(prompt, currentSessionId);
         }
-        else {
+        else if (!safeWrite(proc, writer.user(prompt))) {
+            // stdin write failed -- process probably died. Try to respawn.
+            // spawnFresh can itself throw ProcessError synchronously when the
+            // respawn cap is already hit; surface as an Error like the retry
+            // loop below would, instead of a raw synchronous throw.
+            consecutiveCrashes++;
+            translator.reset();
             try {
-                proc.write(writer.user(prompt));
-            }
-            catch {
-                consecutiveCrashes++;
-                translator.reset();
                 spawnFresh(prompt, currentSessionId);
             }
+            catch (respawnError) {
+                killProc();
+                throw respawnError;
+            }
         }
+        // Compose per-ask signal with session-level signal: either firing aborts.
+        const effectiveSignal = composeSignals(options.signal, askOpts?.signal);
         let events;
-        try {
-            events = await readUntilTurnComplete(options.signal);
-        }
-        catch (error) {
-            if (error instanceof AbortError || error instanceof TimeoutError) {
-                killProc();
-                throw error;
+        while (true) {
+            try {
+                events = await readUntilTurnComplete(effectiveSignal);
+                break;
             }
-            if (isTransientError(error) && consecutiveCrashes < LIMITS.maxRespawnAttempts) {
-                consecutiveCrashes++;
-                spawnFresh(prompt, currentSessionId);
-                try {
-                    events = await readUntilTurnComplete(options.signal);
+            catch (error) {
+                if (error instanceof AbortError || error instanceof TimeoutError) {
+                    killProc();
+                    throw error;
                 }
-                catch (retryError) {
+                if (!isTransientError(error) || consecutiveCrashes >= LIMITS.maxRespawnAttempts) {
                     killProc();
                     translator.reset();
-                    throw retryError;
+                    throw error;
                 }
-            }
-            else {
-                killProc();
-                translator.reset();
-                throw error;
+                consecutiveCrashes++;
+                // Fire both session-level and per-ask onRetry. Both are safe-invoked
+                // so a throwing observer doesn't prevent the retry.
+                fireRetry(consecutiveCrashes, error, options.onRetry, askOpts?.onRetry);
+                await respawnBackoff();
+                spawnFresh(prompt, currentSessionId);
+                // Loop to retry; stops when budget exhausted or turn completes.
             }
         }
         consecutiveCrashes = 0;
@@ -195,34 +259,42 @@ export const createSession = (options = {}) => {
         return buildResult(events, costTracker, currentSessionId);
     };
     let closed = false;
-    const ask = (prompt) => {
+    const ask = (prompt, askOpts) => {
         if (closed) {
             return Promise.reject(new ClaudeError("Session is closed"));
         }
         const prev = inFlight ?? Promise.resolve();
         const run = prev
-            .catch((prevError) => {
-            if (prevError instanceof KnownError || prevError instanceof BudgetExceededError) {
-                throw prevError;
+            .catch(() => {
+            // Prior ask failure shouldn't prevent this one from running. Fatal
+            // errors (KnownError/BudgetExceededError) set `closed` in the .catch
+            // below, which the sync check above picks up on the NEXT ask.
+        })
+            .then(() => {
+            if (closed) {
+                throw new ClaudeError("Session is closed");
             }
+            return doAsk(prompt, askOpts);
         })
-            .then(() => doAsk(prompt));
+            .catch((error) => {
+            if (error instanceof KnownError || error instanceof BudgetExceededError) {
+                closed = true;
+            }
+            throw error;
+        });
         inFlight = run;
         return run;
     };
     const close = async () => {
         closed = true;
         if (inFlight) {
-            await inFlight.catch(() => { });
+            // Cap the wait: a stuck reader.read() inside the queued ask would
+            // otherwise hang close() forever before gracefulKill gets a chance.
+            await withTimeout(inFlight.catch(() => { }), TIMEOUTS.gracefulExitMs);
             inFlight = undefined;
         }
         if (proc) {
-            try {
-                proc.write(writer.abort());
-            }
-            catch {
-                // stdin may already be closed
-            }
+            safeWrite(proc, writer.abort());
             await gracefulKill(proc);
             proc = undefined;
         }

package/dist/stream.js

@@ -1,81 +1,99 @@
+import { withTimeout } from "./async.js";
+import { TIMEOUTS } from "./constants.js";
 import { createCostTracker } from "./cost.js";
-import { AbortError, ClaudeError, ProcessError } from "./errors.js";
+import { AbortError, ClaudeError, ProcessError, processExitedEarly } from "./errors.js";
 import { createTranslator } from "./parser/translator.js";
-import { buildResult, extractText } from "./pipeline.js";
-import { spawnClaude } from "./process.js";
+import { applyTurnComplete, buildResult, extractText, startPipeline } from "./pipeline.js";
 import { readNdjsonEvents } from "./reader.js";
 import { createToolHandler } from "./tools/handler.js";
-const drainStderr = (proc) => {
-    const chunks = [];
-    const stderrReader = proc.stderr.getReader();
-    const decoder = new TextDecoder();
-    const done = (async () => {
-        try {
-            while (true) {
-                const { done: isDone, value } = await stderrReader.read();
-                if (isDone) {
-                    break;
-                }
-                chunks.push(decoder.decode(value, { stream: true }));
-            }
-        }
-        catch {
-            // process exited
-        }
-        finally {
-            stderrReader.releaseLock();
-        }
-    })().catch(() => { });
-    return { chunks, done };
-};
+// Enforced exclusivity between iterating the stream and consuming via
+// text()/cost()/result(). Sharing the base message keeps the two throw
+// sites from drifting apart over time.
+const MIX_ITER_CONSUME = "Cannot mix for-await iteration with text()/cost()/result() on the same stream -- use one or the other.";
 export const createStream = (prompt, options = {}) => {
-    if (options.signal?.aborted) {
-        throw new AbortError();
-    }
-    const proc = spawnClaude({ prompt, ...options });
-    const stderr = drainStderr(proc);
+    // Abort check happens inside `ensureSpawned` -- at factory time we only
+    // capture config. A pre-aborted signal surfaces on the first access
+    // (iterate / text / cost / result), which is when spawn would happen.
     const translator = createTranslator();
     const toolHandler = options.tools ? createToolHandler(options.tools) : undefined;
     const costTracker = createCostTracker({
         maxCostUsd: options.maxCostUsd,
         onCostUpdate: options.onCostUpdate,
+        onWarning: options.onWarning,
     });
+    let proc;
+    let stderr;
+    let stdoutReader;
     let cachedGenerator;
+    const ensureSpawned = () => {
+        if (!proc) {
+            if (options.signal?.aborted) {
+                throw new AbortError();
+            }
+            // Shared boot: spawnClaude → getReader → drainStderr in one call.
+            // Matches session.ts so future refactors can't let the two drift.
+            const pipeline = startPipeline({ prompt, ...options });
+            proc = pipeline.proc;
+            stdoutReader = pipeline.reader;
+            stderr = pipeline.stderr;
+        }
+        return proc;
+    };
     const generate = async function* () {
-        const stdoutReader = proc.stdout.getReader();
+        const p = ensureSpawned();
+        // ensureSpawned always populates stdoutReader alongside proc. Typed
+        // assertion so consumers can treat it as non-null below.
+        const currentReader = stdoutReader;
         let turnComplete = false;
         try {
             for await (const event of readNdjsonEvents({
-                reader: stdoutReader,
+                reader: currentReader,
                 translator,
                 toolHandler,
-                proc,
+                proc: p,
                 signal: options.signal,
+                onWarning: options.onWarning,
             })) {
                 if (event.type === "turn_complete") {
-                    costTracker.update(event.costUsd ?? 0, event.inputTokens ?? 0, event.outputTokens ?? 0);
-                    costTracker.checkBudget();
+                    applyTurnComplete(event, costTracker);
                     turnComplete = true;
                 }
                 yield event;
             }
             if (!turnComplete) {
-                const exitCode = await proc.exited;
+                // Don't wait forever on p.exited -- a stuck child that never closes
+                // stdout would hang the generator. Cap at gracefulExitMs, then
+                // force-kill so cleanup() isn't left waiting too.
+                const exitCode = await withTimeout(p.exited, TIMEOUTS.gracefulExitMs);
+                if (exitCode === undefined) {
+                    p.kill();
+                }
+                // Give stderr a brief chance to drain so the thrown error carries
+                // the CLI's actual complaint instead of an empty string. Uniform
+                // across all three branches below so users never get "no context".
+                if (stderr) {
+                    await withTimeout(stderr.done, TIMEOUTS.stderrDrainGraceMs);
+                }
+                const stderrText = stderr ? stderr.text() : "";
+                if (exitCode === undefined) {
+                    throw processExitedEarly(stderrText);
+                }
                 if (exitCode !== 0) {
-                    let errorMessage = `Claude process exited with code ${exitCode}`;
-                    await stderr.done;
-                    const stderrText = stderr.chunks.join("").trim();
-                    if (stderrText) {
-                        errorMessage = stderrText;
-                    }
-                    throw new ProcessError(errorMessage, exitCode);
+                    const exitMsg = stderrText || `Claude process exited with code ${exitCode}`;
+                    throw new ProcessError(exitMsg, exitCode);
                 }
-                throw new ProcessError("Process exited without completing the turn");
+                throw processExitedEarly(stderrText);
             }
         }
         finally {
-            stdoutReader.releaseLock();
-            proc.kill();
+            currentReader.releaseLock();
+            p.kill();
+            // Let stderr catch up so any trailing lines aren't silently dropped --
+            // session's error path does the same via withTimeout. Capped so a
+            // stuck drain can't hold up consumer cleanup.
+            if (stderr) {
+                await withTimeout(stderr.done, TIMEOUTS.stderrDrainGraceMs);
+            }
         }
     };
     const bufferedEvents = [];
@@ -83,11 +101,12 @@ export const createStream = (prompt, options = {}) => {
     const ensureConsumed = () => {
         if (!consumePromise) {
             if (cachedGenerator) {
-                throw new ClaudeError("Cannot call text()/cost()/result() after iterating with for-await. Use one or the other.");
+                throw new ClaudeError(MIX_ITER_CONSUME);
             }
+            const gen = generate();
+            cachedGenerator = gen;
             consumePromise = (async () => {
-                cachedGenerator = generate();
-                for await (const event of { [Symbol.asyncIterator]: () => cachedGenerator }) {
+                for await (const event of gen) {
                     bufferedEvents.push(event);
                 }
             })();
@@ -108,14 +127,21 @@ export const createStream = (prompt, options = {}) => {
         return buildResult(bufferedEvents, costTracker, sessionId);
     };
     const cleanup = () => {
-        if (!cachedGenerator) {
+        // One-shot kill: streams are single-turn, so unlike session.gracefulKill
+        // there's no second ask() to worry about leaving the child stranded for.
+        // SIGTERM is sufficient -- a stuck child would be the CLI's bug, and we
+        // wouldn't gain anything by blocking cleanup() on a SIGKILL escalation.
+        // Always kill if a proc was ever spawned -- the generator's finally may
+        // not have run yet (e.g., iterator created but never ticked). Redundant
+        // kill on an already-exited process is a harmless ESRCH.
+        if (proc) {
             proc.kill();
         }
     };
     return {
         [Symbol.asyncIterator]: () => {
             if (consumePromise) {
-                throw new ClaudeError("Cannot iterate after calling text()/cost()/result(). Use one or the other.");
+                throw new ClaudeError(MIX_ITER_CONSUME);
             }
             cachedGenerator ??= generate();
             return cachedGenerator;

package/dist/tools/handler.d.ts

@@ -2,6 +2,7 @@ import type { TToolUseEvent } from "../types/events.js";
 import type { IToolHandler } from "../types/options.js";
 export type TToolDecision = "approve" | "deny" | {
     result: string;
+    isError?: boolean;
 };
 export interface IToolHandlerInstance {
     decide: (tool: TToolUseEvent) => Promise<TToolDecision>;

package/dist/tools/handler.js

@@ -1,5 +1,5 @@
 export const createToolHandler = (options = {}) => {
-    const { allowed, blocked, onToolUse } = options;
+    const { allowed, blocked, onToolUse, onError } = options;
     const allowedSet = allowed ? new Set(allowed) : undefined;
     const blockedSet = blocked ? new Set(blocked) : undefined;
     const decide = async (tool) => {
@@ -9,10 +9,18 @@ export const createToolHandler = (options = {}) => {
         if (allowedSet && !allowedSet.has(tool.toolName)) {
             return "deny";
         }
-        if (onToolUse) {
-            return onToolUse(tool);
+        if (!onToolUse) {
+            return "approve";
+        }
+        try {
+            return await onToolUse(tool);
+        }
+        catch (error) {
+            if (!onError) {
+                throw error;
+            }
+            return onError(error, tool);
         }
-        return "approve";
     };
     return { decide };
 };

package/dist/tools/registry.d.ts

@@ -1,2 +1,4 @@
-export declare const BUILT_IN_TOOLS: Set<string>;
-export declare const isBuiltInTool: (name: string) => boolean;
+export declare const BUILT_IN_TOOL_NAMES: readonly ["Read", "Write", "Edit", "Bash", "Glob", "Grep", "Agent", "NotebookEdit", "WebFetch", "WebSearch", "TaskCreate", "TaskUpdate", "TaskGet", "TaskList", "TaskStop", "TaskOutput", "ToolSearch", "Monitor", "EnterPlanMode", "ExitPlanMode", "SendMessage", "LSP", "AskUserQuestion", "Skill", "CronCreate", "CronDelete", "CronList", "RemoteTrigger", "TeamCreate", "TeamDelete", "EnterWorktree", "ExitWorktree", "ScheduleWakeup"];
+export type TBuiltInToolName = (typeof BUILT_IN_TOOL_NAMES)[number];
+export declare const BUILT_IN_TOOLS: ReadonlySet<TBuiltInToolName>;
+export declare const isBuiltInTool: (name: string) => name is TBuiltInToolName;

package/dist/tools/registry.js

@@ -1,6 +1,10 @@
 // Best-effort snapshot of known Claude Code tools. May not be exhaustive.
 // For the authoritative list, check session_meta.tools from a live session.
-export const BUILT_IN_TOOLS = new Set([
+//
+// Declared as a literal tuple so `TBuiltInToolName` is the exact union of
+// known names -- lets callers narrow `allowedTools` / `disallowedTools`
+// arrays at compile time instead of accepting any string[].
+export const BUILT_IN_TOOL_NAMES = [
     "Read",
     "Write",
     "Edit",
@@ -11,8 +15,6 @@ export const BUILT_IN_TOOLS = new Set([
     "NotebookEdit",
     "WebFetch",
     "WebSearch",
-    "TodoRead",
-    "TodoWrite",
     "TaskCreate",
     "TaskUpdate",
     "TaskGet",
@@ -36,7 +38,8 @@ export const BUILT_IN_TOOLS = new Set([
     "EnterWorktree",
     "ExitWorktree",
     "ScheduleWakeup",
-]);
+];
+export const BUILT_IN_TOOLS = new Set(BUILT_IN_TOOL_NAMES);
 export const isBuiltInTool = (name) => {
     return BUILT_IN_TOOLS.has(name);
 };