@dynamicagents/plugins 0.13.0 → 0.15.0

package/dist/claude-code/model.js

@@ -1,342 +1,366 @@
-var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
-    if (value !== null && value !== void 0) {
-        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
-        var dispose, inner;
-        if (async) {
-            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
-            dispose = value[Symbol.asyncDispose];
-        }
-        if (dispose === void 0) {
-            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
-            dispose = value[Symbol.dispose];
-            if (async) inner = dispose;
-        }
-        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
-        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
-        env.stack.push({ value: value, dispose: dispose, async: async });
-    }
-    else if (async) {
-        env.stack.push({ async: true });
-    }
-    return value;
-};
-var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
-    return function (env) {
-        function fail(e) {
-            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
-            env.hasError = true;
-        }
-        var r, s = 0;
-        function next() {
-            while (r = env.stack.pop()) {
-                try {
-                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
-                    if (r.dispose) {
-                        var result = r.dispose.call(r.value);
-                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
-                    }
-                    else s |= 1;
-                }
-                catch (e) {
-                    fail(e);
-                }
-            }
-            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
-            if (env.hasError) throw env.error;
-        }
-        return next();
-    };
-})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
-    var e = new Error(message);
-    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
-});
 import { isPlatformTransientError } from "agents";
-import { claudeCodeSession, requireCredentials } from "./session.js";
-import { execIdFor, followUpExecIdFor } from "./run.js";
-/** Zeroed: the session's tokens are the CLI's context, not this conversation's. */
-const USAGE = {
-    inputTokens: {
-        total: 0,
-        noCache: 0,
-        cacheRead: 0,
-        cacheWrite: 0
-    },
-    outputTokens: { total: 0, text: 0, reasoning: 0 }
-};
+import { SANDBOX_CONTRACT } from "../sandbox/constants.js";
+import { withRunHeader } from "../sandbox/header.js";
+import { containerLostCard, lostCard } from "./cards.js";
+import { decodeNote, decodeRunEnd, decodeSessionId } from "./harness-wire.js";
+import { lastUserText, reportingModel } from "./language-model.js";
+/**
+ * Three hours: a ceiling on a session that has stopped making progress, not a
+ * budget for one that is. No timer in the sandbox races it, since the
+ * container's idle stop never fires while an operation is open.
+ */
+export const DEFAULT_TIMEOUT_MS = 3 * 60 * 60_000;
+/** What a session is told when it resumes in a new container. */
+export const CONTAINER_LOST_PROMPT = "The container this session was running in was lost, and the session has " +
+    "resumed in a new one. Its disk is as of the sandbox's last snapshot, so " +
+    "files written since may be gone, and nothing you started is still running. " +
+    "Check the checkout's state before carrying on with the task.";
+/**
+ * Attempts after the first. A turn that kills its container every time — an
+ * install that runs it out of memory — would otherwise be resubmitted forever.
+ */
+const LOST_RESUBMITS = 3;
+/** Why an operation settled that a new attempt may get past. */
+const LOST_REASONS = new Set(["container_lost", "container_unavailable"]);
+/** Polls in a row a note may fail to file before it is given up on. */
+const NOTE_TRIES = 3;
+/** The sandbox's own ceiling on one poll's wait. */
+const POLL_WAIT_MS = 20_000;
+/**
+ * Failed calls in a row before one is thrown. A sandbox reset costs one call;
+ * an isolate this run's object has been replaced on fails every call, and is
+ * left to the restart's recovery of the turn.
+ */
+const TRANSIENT_TRIES = 8;
+const TRANSIENT_BACKOFF_MS = 1_000;
 export function claudeCodeModel(options) {
-    requireCredentials(options.config);
     const { storage, runId } = options;
-    const session = claudeCodeSession(options.config);
+    const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
     const key = (name) => `claude-code:${runId}:${name}`;
     const KEYS = {
         brief: key("brief"),
-        cursor: key("cursor"),
         session: key("session"),
         followUp: key("follow-up"),
         followUpEnd: key("follow-up-end"),
-        report: key("report")
+        report: key("report"),
+        turn: (step) => key(`turn:${step}`),
+        /**
+         * Where a run that started in a workspace container kept its place. Such a
+         * run can still be resumed by a task waiting on input, and the guard below
+         * is what stops it being briefed again.
+         */
+        cursor: key("cursor")
     };
     const run = async (call) => {
-        const env_1 = { stack: [], error: void 0, hasError: false };
-        try {
-            // The once-guarantee: a run that already reported says so again.
-            const reported = await storage.get(KEYS.report);
-            if (reported !== undefined)
-                return reported;
-            const signal = call.abortSignal;
-            // Opened again after a cut stream — see `drain`. Whichever is current is
-            // released when the run ends.
-            let workspace = await options.workspace();
-            const _release = __addDisposableResource(env_1, { [Symbol.dispose]: () => workspace[Symbol.dispose]() }, false);
-            /** The exec being drained, which leads each note's key. */
-            let current = "";
-            /**
-             * The handle already recorded, so one id is not announced twice over — and
-             * set only once the host has taken it, so a record that failed is tried
-             * again at the next checkpoint rather than given up on.
-             */
-            let announced = "";
-            /**
-             * Tell the host the session's handle, and never fail the run over it.
-             *
-             * Not on the note chain: a note is one line of a transcript, and this is the
-             * only way back to the conversation. It is awaited where it is called so a
-             * handle is recorded before whatever comes next can lose it.
-             */
-            const announce = async (record) => {
-                const sink = options.onSession;
-                if (!sink)
-                    return;
+        const reported = await storage.get(KEYS.report);
+        if (reported !== undefined)
+            return reported;
+        if ((await storage.get(KEYS.cursor)) !== undefined &&
+            (await storage.get(KEYS.turn("session"))) === undefined) {
+            throw new Error("claude-code: this run's session started in a workspace container, " +
+                "which a sandbox cannot attach to, so it ended when the deployment moved to sandboxes");
+        }
+        const signal = call.abortSignal;
+        /** Set only once the host has taken the handle, so a failed record is tried again. */
+        let announced = "";
+        const announce = async (record) => {
+            const sink = options.onSession;
+            if (!sink || (record.end === undefined && announced === record.sessionId))
+                return;
+            try {
+                await sink(record);
+                announced = record.sessionId;
+            }
+            catch (err) {
+                console.warn("[claude-code] the session's handle was not recorded", {
+                    runId,
+                    sessionId: record.sessionId,
+                    err: String(err)
+                });
+            }
+        };
+        const file = async (noteKey, text, detail) => {
+            await options.note(noteKey, text, detail).catch((err) => console.warn("[claude-code] a note was not filed", {
+                runId,
+                key: noteKey,
+                err: String(err)
+            }));
+        };
+        /**
+         * One sandbox call, through a new stub after each transient failure. The
+         * abort ends the wait, not the call: an RPC cannot be taken back.
+         */
+        const rpc = async (fn) => {
+            for (let tries = 1;; tries++) {
                 try {
-                    await sink(record);
-                    announced = record.sessionId;
+                    return await untilAborted(fn(options.sandbox()), signal);
                 }
                 catch (err) {
-                    console.warn("[claude-code] the session's handle was not recorded", {
+                    if (signal?.aborted ||
+                        !isPlatformTransientError(err) ||
+                        tries >= TRANSIENT_TRIES)
+                        throw err;
+                    console.warn("[claude-code] a sandbox call failed — retrying", {
                         runId,
-                        sessionId: record.sessionId,
+                        tries,
                         err: String(err)
                     });
+                    await untilAborted(sleep(TRANSIENT_BACKOFF_MS * tries), signal);
                 }
+            }
+        };
+        /** Stop the session, file its end, and end the run with `reason`. */
+        const stop = async (operationId, reason) => {
+            await options
+                .sandbox()
+                .stopRun(runId)
+                .catch((err) => console.warn("[claude-code] could not stop the session", {
+                runId,
+                err: String(err)
+            }));
+            const card = lostCard(reason instanceof Error ? reason.message : String(reason));
+            await file(`${operationId}:lost`, card.text, card.detail);
+            throw reason;
+        };
+        /**
+         * One step of the run, to its end: the brief's session, or the follow-up.
+         * Both count against one limit, from the session's first submission.
+         */
+        const turn = async (step, prompt, header) => {
+            const origin = step === "session"
+                ? undefined
+                : (await storage.get(KEYS.turn("session")))?.startedAt;
+            const stored = await storage.get(KEYS.turn(step));
+            let state = stored ?? {
+                attempt: 0,
+                startedAt: origin ?? Date.now(),
+                from: 0
             };
-            /**
-             * Each note, filed as it is parsed, then the cursor behind it. Keyed on the
-             * exec as well as the position: the parent's transcript is one per task and
-             * dedupes on the key, so a run's notes must not collide with another run's
-             * — or with its own follow-up's, which counts from zero again.
-             */
-            const sinks = {
-                onProgress: (note) => options.note(`${current}:${note.key}`, note.text, note.detail),
-                // The drain offers a cursor the moment the session id appears, which is
-                // what makes this the earliest the handle can be recorded — seconds in,
-                // rather than at the end a killed session never reaches.
-                onCheckpoint: async (cursor) => {
-                    await storage.put(KEYS.cursor, cursor);
-                    if (cursor.sessionId && cursor.sessionId !== announced) {
-                        await announce({ sessionId: cursor.sessionId });
-                    }
-                },
-                ...(signal ? { signal } : {})
+            const save = async (next) => {
+                state = next;
+                await storage.put(KEYS.turn(step), state);
             };
-            /**
-             * Drain one exec to its end, starting it or re-attaching from the cursor.
-             *
-             * **A cut stream is re-attached here, not failed.** The session is still
-             * running, and a failed run is stopped — the one outcome that loses it. The
-             * retry opens the workspace afresh, since the stub the stream came over may
-             * not survive the cut. Two attempts in a row that end in a cut with no
-             * checkpoint stored fail the run as before: a stream that breaks every time
-             * it opens is not a blip.
-             */
-            const drain = async (execId, begin) => {
-                current = execId;
-                let outcome;
-                let stalled = false;
-                while (!outcome) {
-                    const cursor = await storage.get(KEYS.cursor);
+            await save(state);
+            const resume = options.resume;
+            try {
+                await rpc((sandbox) => sandbox.createRun(runId, {
+                    cwd: options.dir,
+                    ...(resume
+                        ? resume.fork
+                            ? { forkOf: resume.run }
+                            : { continues: resume.run }
+                        : {})
+                }));
+            }
+            catch (err) {
+                // Recovering, the last invocation's turn may still be running: an
+                // abort stops it. A step that never began has nothing to stop.
+                if (signal?.aborted && stored)
+                    await stop(`${runId}:${step}:a${state.attempt}`, signal.reason ?? err);
+                throw err;
+            }
+            for (;;) {
+                const operationId = `${runId}:${step}:a${state.attempt}`;
+                // A resubmission that reached the CLI is told what happened, in the
+                // conversation it already had; one that never did is the step again.
+                const { fork: _fork, ...resumed } = header;
+                const text = state.attempt > 0 && state.sessionId
+                    ? withRunHeader(resumed, CONTAINER_LOST_PROMPT)
+                    : withRunHeader(header, prompt);
+                try {
+                    await rpc((sandbox) => sandbox.submit(runId, text, operationId));
+                }
+                catch (err) {
+                    // The submission may have landed: an abort stops what it started.
+                    if (signal?.aborted)
+                        await stop(operationId, signal.reason ?? err);
+                    throw err;
+                }
+                let result;
+                /** Polls in a row that stopped at one unfiled note. */
+                let stuck = 0;
+                while (!result) {
+                    if (signal?.aborted)
+                        await stop(operationId, signal.reason ?? new Error("the session was stopped"));
+                    if (Date.now() - state.startedAt > timeoutMs) {
+                        await stop(operationId, new Error(`the session ran past its limit of ${Math.round(timeoutMs / 60_000)} minutes`));
+                    }
+                    let polled;
                     try {
-                        outcome =
-                            cursor?.execId === execId
-                                ? await session.resume(workspace.runtime, cursor, sinks)
-                                : await begin(workspace.runtime);
+                        polled = await rpc((sandbox) => sandbox.poll(runId, operationId, POLL_WAIT_MS, state.from));
                     }
                     catch (err) {
-                        const after = await storage.get(KEYS.cursor);
-                        const moved = after?.execId === execId &&
-                            (cursor?.execId !== execId || after.seq > cursor.seq);
-                        if (!isStreamCut(err) || signal?.aborted || (stalled && !moved))
-                            throw err;
-                        stalled = !moved;
-                        console.warn("[claude-code] the session's stream was cut — re-attaching", {
-                            execId,
-                            err: String(err)
-                        });
-                        const fresh = await options.workspace();
-                        workspace[Symbol.dispose]();
-                        workspace = fresh;
+                        if (signal?.aborted)
+                            continue;
+                        throw err;
                     }
+                    if (polled.contract !== SANDBOX_CONTRACT) {
+                        throw new Error(`claude-code: the sandbox answered with contract ${polled.contract} and this run expects ${SANDBOX_CONTRACT}: ` +
+                            "a sandbox kept busy on older code through a deploy answered it");
+                    }
+                    // In order, and the position never past a note that was not filed:
+                    // the next poll sends it again. One that never files is given up on
+                    // after a few polls, so the session's end still arrives.
+                    let filedTo = polled.next;
+                    for (const [i, message] of polled.messages.entries()) {
+                        const taken = await take(message);
+                        if (taken.failed && stuck < NOTE_TRIES) {
+                            stuck += 1;
+                            filedTo = state.from + i;
+                            break;
+                        }
+                        if (taken.failed) {
+                            console.warn("[claude-code] a note was given up on", {
+                                runId,
+                                key: message.id
+                            });
+                        }
+                        stuck = 0;
+                        if (taken.sessionId !== undefined) {
+                            if (taken.sessionId !== state.sessionId)
+                                await save({ ...state, sessionId: taken.sessionId });
+                            await announce({ sessionId: taken.sessionId });
+                        }
+                    }
+                    if (filedTo !== state.from)
+                        await save({ ...state, from: filedTo });
+                    if (filedTo === polled.next)
+                        result = polled.result;
                 }
-                await storage.put(KEYS.cursor, outcome.cursor);
-                if (!outcome.done) {
-                    // Only the signal stops a drain short of the end: the turn was
-                    // cancelled, so the session goes with it.
-                    await session.stop(workspace.runtime, runId).catch((err) => console.warn("[claude-code] could not stop a cancelled session", {
-                        runId,
-                        err: String(err)
-                    }));
-                    throw signal?.reason ?? new Error("the session was stopped");
+                if (result.status === "done") {
+                    const end = decodeRunEnd(result.text);
+                    if (!end?.result) {
+                        throw new Error(`claude-code: the sandbox settled the session with no end it could read: ${String(result.text).slice(0, 200)}`);
+                    }
+                    // No code is a process a signal ended.
+                    return sessionEnd(end, end.exitCode ?? -1, state.sessionId);
                 }
-                return {
-                    exitCode: outcome.exitCode,
-                    ...(outcome.result ? { result: outcome.result } : {}),
-                    ...(outcome.stderr ? { stderr: outcome.stderr } : {}),
-                    ...(outcome.rateLimit ? { rateLimit: outcome.rateLimit } : {}),
-                    ...(outcome.cursor.sessionId
-                        ? { sessionId: outcome.cursor.sessionId }
-                        : {})
-                };
-            };
-            let ended = await storage.get(KEYS.session);
-            if (!ended) {
-                let prompt = await storage.get(KEYS.brief);
-                if (prompt === undefined) {
-                    const task = lastUserText(call.prompt);
-                    prompt = options.brief ? await options.brief(task) : task;
-                    await storage.put(KEYS.brief, prompt);
+                const reason = result.reason ?? "";
+                const end = decodeRunEnd(reason);
+                if (end)
+                    return sessionEnd(end, end.exitCode ?? 1, state.sessionId);
+                if (signal?.aborted)
+                    await stop(operationId, signal.reason ?? new Error("the session was stopped"));
+                if (!LOST_REASONS.has(reason) || state.attempt >= LOST_RESUBMITS) {
+                    const card = lostCard(reason || "the sandbox gave no reason");
+                    await file(`${operationId}:lost`, card.text, card.detail);
+                    throw new Error(`claude-code: the sandbox ended the session: ${reason || "no reason given"}`);
                 }
-                const brief = prompt;
-                ended = await drain(execIdFor(runId), (runtime) => session.start(runtime, runId, {
-                    prompt: brief,
-                    dir: options.dir,
-                    ...(options.jsonSchema ? { jsonSchema: options.jsonSchema } : {}),
-                    ...(options.permissionMode
-                        ? { permissionMode: options.permissionMode }
-                        : {}),
-                    ...(options.resume ? { resume: options.resume } : {})
-                }, sinks));
-                await storage.put(KEYS.session, ended);
+                console.warn("[claude-code] the session's container was lost — resuming", {
+                    runId,
+                    operationId,
+                    reason
+                });
+                const card = containerLostCard(reason);
+                await file(`${operationId}:container-lost`, card.text, card.detail);
+                await save({ ...state, attempt: state.attempt + 1, from: 0 });
             }
-            // After the end is stored, so a turn that dies here does not report an end
-            // the run has not kept — and outside the guard above, so a turn cut between
-            // storing the end and telling the host tells it on the next attempt. Telling
-            // it twice is harmless: its record is keyed on the id, see `SessionRecord`.
-            if (ended.sessionId)
-                await announce({ sessionId: ended.sessionId, end: ended });
-            let followUpEnd = await storage.get(KEYS.followUpEnd);
-            if (!followUpEnd && options.followUp) {
-                let asked = await storage.get(KEYS.followUp);
-                if (!asked) {
-                    const prompt = await options.followUp(ended);
-                    asked = prompt ? { prompt } : {};
-                    await storage.put(KEYS.followUp, asked);
-                }
-                // The cursor's id as well as the result's: a session that was stopped
-                // before it reported still has a conversation worth one more turn.
-                const sessionId = ended.result?.sessionId ?? ended.sessionId;
-                if (asked.prompt && sessionId) {
-                    const prompt = asked.prompt;
-                    followUpEnd = await drain(followUpExecIdFor(runId), (runtime) => session.followUp(runtime, runId, {
-                        sessionId,
-                        prompt,
-                        dir: options.dir,
-                        ...(options.permissionMode
-                            ? { permissionMode: options.permissionMode }
-                            : {})
-                    }, sinks));
-                    await storage.put(KEYS.followUpEnd, followUpEnd);
-                }
+        };
+        /** File one polled message's note, or read the session id it carries. */
+        const take = async (message) => {
+            const part = message.message.parts[0];
+            if (part?.type !== "text")
+                return {};
+            const sessionId = decodeSessionId(part.text);
+            if (sessionId !== undefined)
+                return { sessionId };
+            const note = decodeNote(part.text);
+            if (!note)
+                return {};
+            // Keyed on the message, which is the operation and the note's position:
+            // the parent's transcript dedupes on the key, so a refiled poll is free.
+            try {
+                const at = message.message.createdAt;
+                await options.note(message.id, note.text, note.detail, at > 0 ? at : undefined);
+                return {};
+            }
+            catch (err) {
+                console.warn("[claude-code] a note was not filed — polling it again", {
+                    runId,
+                    key: message.id,
+                    err: String(err)
+                });
+                return { failed: true };
+            }
+        };
+        const header = {
+            cwd: options.dir,
+            ...(options.permissionMode === "plan"
+                ? { mode: "plan" }
+                : { mode: "build" }),
+            ...(options.schema !== undefined ? { schema: options.schema } : {}),
+            ...(options.effort !== undefined ? { effort: options.effort } : {}),
+            ...(options.model !== undefined ? { model: options.model } : {})
+        };
+        let ended = await storage.get(KEYS.session);
+        if (!ended) {
+            let prompt = await storage.get(KEYS.brief);
+            if (prompt === undefined) {
+                const task = lastUserText(call.prompt);
+                prompt = options.brief ? await options.brief(task) : task;
+                await storage.put(KEYS.brief, prompt);
             }
-            const text = await options.report({
-                session: ended,
-                ...(followUpEnd ? { followUp: followUpEnd } : {})
+            ended = await turn("session", prompt, {
+                ...header,
+                ...(options.resume?.fork ? { fork: true } : {})
             });
-            await storage.put(KEYS.report, text);
-            return text;
+            await storage.put(KEYS.session, ended);
         }
-        catch (e_1) {
-            env_1.error = e_1;
-            env_1.hasError = true;
-        }
-        finally {
-            __disposeResources(env_1);
+        if (ended.sessionId)
+            await announce({ sessionId: ended.sessionId, end: ended });
+        let followUpEnd = await storage.get(KEYS.followUpEnd);
+        if (!followUpEnd && options.followUp) {
+            let asked = await storage.get(KEYS.followUp);
+            if (!asked) {
+                const prompt = await options.followUp(ended);
+                asked = prompt ? { prompt } : {};
+                await storage.put(KEYS.followUp, asked);
+            }
+            // A session with no conversation has nothing to follow up. Its schema
+            // was the session's answer, not the follow-up's — except a plan's, which
+            // answers to one every turn.
+            if (asked.prompt && (ended.result?.sessionId ?? ended.sessionId)) {
+                const { schema: _schema, ...unbound } = header;
+                const followUpHeader = header.mode === "plan" ? header : unbound;
+                followUpEnd = await turn("follow-up", asked.prompt, followUpHeader);
+                await storage.put(KEYS.followUpEnd, followUpEnd);
+            }
         }
+        const text = await options.report({
+            session: ended,
+            ...(followUpEnd ? { followUp: followUpEnd } : {})
+        });
+        await storage.put(KEYS.report, text);
+        return text;
     };
+    return reportingModel(options.model ?? "claude-code", run);
+}
+function sessionEnd(end, exitCode, seen) {
+    const sessionId = end.sessionId ?? seen;
     return {
-        specificationVersion: "v3",
-        provider: "claude-code",
-        modelId: options.config.model ?? "claude-code",
-        supportedUrls: {},
-        async doStream(call) {
-            // The stream is returned at once and the session runs inside it, so
-            // nothing waits on a promise for the length of a session.
-            const stream = new ReadableStream({
-                async start(controller) {
-                    controller.enqueue({ type: "stream-start", warnings: [] });
-                    try {
-                        const text = await run(call);
-                        controller.enqueue({ type: "text-start", id: "report" });
-                        controller.enqueue({
-                            type: "text-delta",
-                            id: "report",
-                            delta: text
-                        });
-                        controller.enqueue({ type: "text-end", id: "report" });
-                        controller.enqueue({
-                            type: "finish",
-                            usage: USAGE,
-                            finishReason: { unified: "stop", raw: undefined }
-                        });
-                        controller.close();
-                    }
-                    catch (err) {
-                        controller.error(err);
-                    }
-                }
-            });
-            return { stream };
-        },
-        async doGenerate(call) {
-            const text = await run(call);
-            return {
-                content: [{ type: "text", text }],
-                finishReason: { unified: "stop", raw: undefined },
-                usage: USAGE,
-                warnings: []
-            };
-        }
+        exitCode,
+        ...(end.result ? { result: end.result } : {}),
+        ...(end.stderr ? { stderr: end.stderr } : {}),
+        ...(end.rateLimit ? { rateLimit: end.rateLimit } : {}),
+        ...(sessionId ? { sessionId } : {})
     };
 }
-/**
- * Whether a drain failed because the transport under a live session gave way.
- *
- * An exec's events reach the sub-agent as a stream over RPC, relayed by the
- * workspace object from the container's own RPC session — so a drop anywhere on
- * that path cuts the stream while the session runs on. Measured: a container's
- * session dropped after 21 minutes and was attached again within a second, the
- * process untouched. The message is workerd's for a stream whose far side went
- * away, and it carries no code.
- */
-function isStreamCut(err) {
-    if (isPlatformTransientError(err))
-        return true;
-    for (let e = err; e instanceof Error; e = e.cause) {
-        if (e.message.includes("ReadableStream received over RPC disconnected"))
-            return true;
-    }
-    return false;
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
 }
-/**
- * The task: the last user message's text. On a continued turn the prompt ends
- * with the interrupted assistant message, so the last message is not it.
- */
-function lastUserText(prompt) {
-    for (let i = prompt.length - 1; i >= 0; i--) {
-        const message = prompt[i];
-        if (message.role !== "user")
-            continue;
-        return message.content
-            .map((part) => (part.type === "text" ? part.text : ""))
-            .join("");
-    }
-    throw new Error("claude-code: the run has no task — no user message");
+/** `promise`, or the abort's reason as soon as `signal` fires. */
+function untilAborted(promise, signal) {
+    if (!signal)
+        return promise;
+    return new Promise((resolve, reject) => {
+        const onAbort = () => reject(signal.reason);
+        if (signal.aborted) {
+            onAbort();
+            return;
+        }
+        signal.addEventListener("abort", onAbort, { once: true });
+        promise
+            .then(resolve, reject)
+            .finally(() => signal.removeEventListener("abort", onAbort));
+    });
 }