@dynamicagents/plugins 0.12.0 → 0.13.0

package/dist/claude-code/model.js

@@ -0,0 +1,342 @@
+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 }
+};
+export function claudeCodeModel(options) {
+    requireCredentials(options.config);
+    const { storage, runId } = options;
+    const session = claudeCodeSession(options.config);
+    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")
+    };
+    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;
+                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)
+                    });
+                }
+            };
+            /**
+             * 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 } : {})
+            };
+            /**
+             * 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);
+                    try {
+                        outcome =
+                            cursor?.execId === execId
+                                ? await session.resume(workspace.runtime, cursor, sinks)
+                                : await begin(workspace.runtime);
+                    }
+                    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;
+                    }
+                }
+                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");
+                }
+                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 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);
+            }
+            // 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);
+                }
+            }
+            const text = await options.report({
+                session: ended,
+                ...(followUpEnd ? { followUp: followUpEnd } : {})
+            });
+            await storage.put(KEYS.report, text);
+            return text;
+        }
+        catch (e_1) {
+            env_1.error = e_1;
+            env_1.hasError = true;
+        }
+        finally {
+            __disposeResources(env_1);
+        }
+    };
+    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: []
+            };
+        }
+    };
+}
+/**
+ * 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;
+}
+/**
+ * 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");
+}