@vidit19sharma/opencode-cursor-auth 0.1.0 → 0.3.1

package/dist/bridge.js

@@ -8,12 +8,13 @@
  * next HTTP request (role:"tool" messages) resolves the parked promises and
  * the SAME run continues — one metered Cursor run per opencode tool loop.
  */
-import { Agent } from "@cursor/sdk";
+import { Agent, AuthenticationError, ConfigurationError, NetworkError, RateLimitError } from "@cursor/sdk";
 import { createHash, randomUUID } from "node:crypto";
 import { existsSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
 import { mkdtemp, readFile, writeFile } from "node:fs/promises";
 import { homedir, tmpdir } from "node:os";
 import { join } from "node:path";
+import { markBlocked, resolveVariant } from "./models.js";
 // @cursor/sdk's internal logger writes "HH:MM:SS.mmm INFO ..." lines via
 // console.log unconditionally (no config/env to silence it, verified against
 // the esm bundle). Filter exactly those lines, pass everything else through.
@@ -31,6 +32,111 @@ function textOf(content) {
         return "";
     return content.map((p) => p.text ?? "").join("");
 }
+function statusFor(err) {
+    const e = (typeof err === "object" && err !== null ? err : {});
+    const msg = String(e.message ?? err ?? "");
+    const code = typeof e.code === "string" ? e.code : "";
+    if (err instanceof AuthenticationError || e.status === 401 || code === "unauthenticated" || /invalid user api key/i.test(msg))
+        return 401;
+    if (err instanceof RateLimitError || e.status === 429 || code === "resource_exhausted" || /rate limit/i.test(msg))
+        return 429;
+    if (code === "permission_denied" || /model blocked|permission denied|forbidden/i.test(msg))
+        return 403;
+    if (err instanceof ConfigurationError || code === "invalid_argument" || code === "not_found" || /cannot use this model|unknown model/i.test(msg))
+        return 400;
+    return 502;
+}
+const ERROR_TYPE = {
+    400: "invalid_request_error",
+    401: "authentication_error",
+    403: "permission_error",
+    429: "rate_limit_error",
+};
+function errorBody(err, status = statusFor(err)) {
+    const e = (typeof err === "object" && err !== null ? err : {});
+    return {
+        error: {
+            message: String(e.message ?? err ?? "unknown error"),
+            type: ERROR_TYPE[status] ?? "api_error",
+            ...(typeof e.code === "string" ? { code: e.code } : {}),
+        },
+    };
+}
+const abortError = () => new DOMException("aborted", "AbortError");
+export function isTransient(err) {
+    const e = (typeof err === "object" && err !== null ? err : {});
+    if (e.name === "AbortError")
+        return false;
+    const status = statusFor(err);
+    if (status === 429)
+        return true;
+    if (status === 400 || status === 401 || status === 403 || e.status === 404)
+        return false;
+    if (err instanceof NetworkError || (typeof e.status === "number" && e.status >= 500))
+        return true;
+    return /unavailable|deadline_exceeded|ECONNRESET|ETIMEDOUT|fetch failed/i.test(`${e.code ?? ""} ${e.message ?? ""}`);
+}
+export async function withRetry(fn, signal, baseDelayMs = 1000, retryable = isTransient) {
+    for (let attempt = 0;; attempt++) {
+        if (signal?.aborted)
+            throw abortError();
+        try {
+            return await fn();
+        }
+        catch (err) {
+            if (attempt >= 2 || signal?.aborted || !retryable(err))
+                throw err;
+            const delay = Math.min(baseDelayMs * 2 ** attempt * (0.75 + Math.random() * 0.5), 30_000);
+            await new Promise((r) => {
+                const t = setTimeout(r, delay);
+                signal?.addEventListener("abort", () => (clearTimeout(t), r(undefined)), { once: true });
+            });
+        }
+    }
+}
+// ponytail: global semaphore, slot held across parked tool loops; per-session fairness if it ever matters
+let maxActive = Number(process.env.OPENCODE_CURSOR_MAX_ACTIVE) || 4;
+let active = 0;
+const waiters = [];
+function pump() {
+    while (active < maxActive && waiters.length) {
+        active++;
+        waiters.shift()();
+    }
+}
+function acquireSlot(signal) {
+    if (signal?.aborted)
+        return Promise.reject(abortError());
+    if (active < maxActive && !waiters.length) {
+        active++;
+        return Promise.resolve();
+    }
+    return new Promise((resolve, reject) => {
+        const onAbort = () => {
+            const i = waiters.indexOf(go);
+            if (i >= 0)
+                waiters.splice(i, 1);
+            reject(abortError());
+        };
+        const go = () => {
+            signal?.removeEventListener("abort", onAbort);
+            resolve();
+        };
+        signal?.addEventListener("abort", onAbort, { once: true });
+        waiters.push(go);
+    });
+}
+function releaseSlot() {
+    active--;
+    pump();
+}
+export function _setMaxActive(n) {
+    maxActive = n;
+    pump();
+}
+export function errorResponse(err, status = statusFor(err)) {
+    return Response.json(errorBody(err, status), { status });
+}
 function chunk(id, model, delta, finish, usage) {
     return {
         id,
@@ -41,7 +147,7 @@ function chunk(id, model, delta, finish, usage) {
         ...(usage ? { usage } : {}),
     };
 }
-function sseResponse(model) {
+function sseResponse(model, onCancel) {
     const id = `chatcmpl-${randomUUID()}`;
     const enc = new TextEncoder();
     let controller;
@@ -53,19 +159,31 @@ function sseResponse(model) {
         },
         cancel() {
             closed = true;
+            onCancel();
         },
     });
+    function frame(payload) {
+        if (closed)
+            return;
+        controller.enqueue(enc.encode(`data: ${JSON.stringify(payload)}\n\n`));
+    }
     function send(delta, finish = null, usage) {
+        frame(chunk(id, model, delta, finish, usage));
+    }
+    function close() {
         if (closed)
             return;
-        controller.enqueue(enc.encode(`data: ${JSON.stringify(chunk(id, model, delta, finish, usage))}\n\n`));
+        closed = true;
+        try {
+            controller.close();
+        }
+        catch { }
     }
     function end() {
         if (closed)
             return;
         controller.enqueue(enc.encode("data: [DONE]\n\n"));
-        controller.close();
-        closed = true;
+        close();
     }
     const sink = {
         text: (t) => send({ content: t }),
@@ -83,10 +201,10 @@ function sseResponse(model) {
             end();
         },
         fail: (err) => {
-            send({ content: `\n\n[cursor error] ${err instanceof Error ? err.message : String(err)}` });
-            send({}, "stop");
-            end();
+            frame(errorBody(err));
+            close();
         },
+        close,
     };
     return {
         response: new Response(stream, {
@@ -96,13 +214,11 @@ function sseResponse(model) {
         sink,
     };
 }
-function jsonCollector(model) {
+function jsonCollector(model, resolve) {
     const id = `chatcmpl-${randomUUID()}`;
     let content = "";
     let calls = [];
-    let resolve;
-    const promise = new Promise((r) => (resolve = r));
-    const sink = {
+    return {
         text: (t) => (content += t),
         reasoning: () => { },
         toolCalls: (c) => (calls = calls.concat(c)),
@@ -132,9 +248,18 @@ function jsonCollector(model) {
             ],
             usage: usage ?? { prompt_tokens: 0, completion_tokens: 0, total_tokens: 0 },
         })),
-        fail: (err) => resolve(Response.json({ error: { message: err instanceof Error ? err.message : String(err), type: "cursor_error" } }, { status: 500 })),
+        fail: (err) => resolve(errorResponse(err)),
+        close: () => { },
     };
-    return { promise, sink };
+}
+function deferred() {
+    let resolve;
+    let reject;
+    const promise = new Promise((res, rej) => {
+        resolve = res;
+        reject = rej;
+    });
+    return { promise, resolve, reject };
 }
 const BATCH_SETTLE_MS = 300;
 const TOOL_RESULT_TIMEOUT_MS = 10 * 60 * 1000;
@@ -144,13 +269,33 @@ const DISK_SESSION_TTL_MS = 7 * 24 * 60 * 60 * 1000;
 const MAX_SESSIONS = 8;
 const SESSION_STORE_DIR = join(homedir(), ".cache", "opencode-cursor-auth");
 const SESSION_STORE_PATH = join(SESSION_STORE_DIR, "sessions.json");
+const TMP_CWD_PREFIX = join(tmpdir(), "opencode-cursor-");
 const sessions = new Map();
 const heldByAgent = new Map();
 const agentByToolCallId = new Map();
 let diskSessions = new Map();
 let sessionsLoaded = false;
-function hashMessages(messages) {
+// ponytail: no orphan sweep, other opencode instances may own those dirs
+function releaseCwd(cwd) {
+    if (!cwd.startsWith(TMP_CWD_PREFIX))
+        return;
+    for (const v of sessions.values())
+        if (v.cwd === cwd)
+            return;
+    for (const v of diskSessions.values())
+        if (v.cwd === cwd)
+            return;
+    for (const h of heldByAgent.values())
+        if (h.cwd === cwd)
+            return;
+    rmSync(cwd, { recursive: true, force: true });
+}
+// scope (opencode session id) is folded in so identical histories from
+// different sessions (e.g. parallel sub-agents) never share a Cursor agent
+function hashMessages(messages, scope) {
     const norm = messages.map((m) => [m.role, textOf(m.content), m.tool_call_id ?? "", JSON.stringify(m.tool_calls ?? null)]);
+    if (scope)
+        norm.unshift(["scope", scope]);
     return createHash("sha256").update(JSON.stringify(norm)).digest("hex");
 }
 function collectDiskEntries() {
@@ -176,6 +321,9 @@ async function loadSessions() {
             if (now - v.lastUsedAt <= DISK_SESSION_TTL_MS)
                 diskSessions.set(k, v);
         }
+        for (const v of Object.values(raw.entries))
+            if (now - v.lastUsedAt > DISK_SESSION_TTL_MS)
+                releaseCwd(v.cwd);
     }
     catch { }
 }
@@ -185,9 +333,17 @@ function saveSessions() {
 }
 function sweepSessions(save = true) {
     const now = Date.now();
+    const evicted = [];
+    for (const [k, v] of diskSessions)
+        if (now - v.lastUsedAt > DISK_SESSION_TTL_MS) {
+            diskSessions.delete(k);
+            evicted.push(v.cwd);
+        }
     for (const [k, v] of sessions)
-        if (now - v.lastUsedAt > SESSION_TTL_MS)
+        if (now - v.lastUsedAt > SESSION_TTL_MS) {
             sessions.delete(k);
+            evicted.push(v.cwd);
+        }
     while (sessions.size > MAX_SESSIONS) {
         let oldestKey = "";
         let oldest = Infinity;
@@ -196,8 +352,11 @@ function sweepSessions(save = true) {
                 oldest = v.lastUsedAt;
                 oldestKey = k;
             }
+        evicted.push(sessions.get(oldestKey).cwd);
         sessions.delete(oldestKey);
     }
+    for (const cwd of evicted)
+        releaseCwd(cwd);
     if (save)
         saveSessions();
 }
@@ -214,15 +373,18 @@ function rememberSession(held, toolCalls) {
             ? { tool_calls: toolCalls.map((c) => ({ id: c.id, function: { name: c.name, arguments: c.argumentsJson } })) }
             : {}),
     };
-    const key = hashMessages(held.messages.concat(assistant));
+    const key = hashMessages(held.messages.concat(assistant), held.scope);
     const entry = {
         agentId: held.agent.agentId,
         cwd: held.cwd,
         lastUsedAt: Date.now(),
     };
+    const displaced = sessions.get(key) ?? diskSessions.get(key);
     sessions.set(key, entry);
     diskSessions.set(key, entry);
     sweepSessions();
+    if (displaced && displaced.cwd !== entry.cwd)
+        releaseCwd(displaced.cwd);
 }
 async function syncAgentsMd(cwd, messages) {
     mkdirSync(cwd, { recursive: true });
@@ -242,7 +404,12 @@ function mapUsage(u) {
         return undefined;
     const prompt = u.inputTokens ?? 0;
     const completion = u.outputTokens ?? 0;
-    return { prompt_tokens: prompt, completion_tokens: completion, total_tokens: prompt + completion };
+    const usage = { prompt_tokens: prompt, completion_tokens: completion, total_tokens: prompt + completion };
+    if (u.cacheReadTokens)
+        usage.prompt_tokens_details = { cached_tokens: u.cacheReadTokens };
+    if (u.reasoningTokens)
+        usage.completion_tokens_details = { reasoning_tokens: u.reasoningTokens };
+    return usage;
 }
 // deltas arriving between tool flush and the continuation request get buffered
 function emit(held, kind, t) {
@@ -251,73 +418,124 @@ function emit(held, kind, t) {
     else
         held.buffer.push({ kind, t });
 }
+function openReply(held) {
+    if (held.opened)
+        return;
+    held.opened = true;
+    if (held.response)
+        held.reply.resolve(held.response);
+}
 function attachSink(held, sink) {
     held.sink = sink;
+    if (held.buffer.length)
+        openReply(held);
     for (const b of held.buffer)
         (b.kind === "text" ? sink.text : sink.reasoning)(b.t);
     held.buffer = [];
 }
-function teardownHeld(agentId, held) {
+function attachSignal(held, signal) {
+    held.detachSignal?.();
+    held.detachSignal = null;
+    if (!signal)
+        return;
+    const onAbort = () => abortHeld(held);
+    signal.addEventListener("abort", onAbort, { once: true });
+    held.detachSignal = () => signal.removeEventListener("abort", onAbort);
+}
+function closeAgent(held) {
+    try {
+        held.agent.close();
+    }
+    catch { }
+}
+function teardownHeld(held) {
     held.done = true;
+    if (held.slot) {
+        held.slot = false;
+        releaseSlot();
+    }
+    held.detachSignal?.();
+    held.detachSignal = null;
     if (held.flushTimer)
         clearTimeout(held.flushTimer);
     if (held.idleTimer)
         clearTimeout(held.idleTimer);
     for (const id of held.parked.keys())
         agentByToolCallId.delete(id);
-    heldByAgent.delete(agentId);
+    heldByAgent.delete(held.agent.agentId);
+}
+function failHeld(held, err) {
+    teardownHeld(held);
+    if (statusFor(err) === 403)
+        markBlocked(held.model);
+    if (held.response && !held.opened) {
+        held.opened = true;
+        held.reply.resolve(errorResponse(err));
+        held.sink?.close();
+    }
+    else {
+        held.sink?.fail(err);
+    }
+    closeAgent(held);
+    releaseCwd(held.cwd);
+}
+function abortHeld(held) {
+    if (held.done)
+        return;
+    teardownHeld(held);
+    held.run?.cancel().catch(() => { });
+    closeAgent(held);
+    held.sink?.close();
+    held.reply.reject(new DOMException("aborted", "AbortError"));
+    releaseCwd(held.cwd);
 }
 /** Model requested tools: emit tool_calls, end this HTTP segment, park the run. */
-function flushToolCalls(agentId, held) {
+function flushToolCalls(held) {
     held.flushTimer = null;
     if (held.done || !held.pendingCalls.length)
         return;
     const calls = held.pendingCalls;
     held.pendingCalls = [];
     for (const c of calls)
-        agentByToolCallId.set(c.id, agentId);
+        agentByToolCallId.set(c.id, held.agent.agentId);
     const sink = held.sink;
     held.sink = null;
+    // the parked run outlives this HTTP segment, so its abort signal must not
+    // reach it; the continuation request attaches its own
+    held.detachSignal?.();
+    held.detachSignal = null;
+    openReply(held);
     sink?.toolCalls(calls);
     sink?.finish("tool_calls");
     rememberSession(held, calls);
-    held.idleTimer = setTimeout(() => {
-        teardownHeld(agentId, held);
-        held.run.cancel().catch(() => { });
-        try {
-            held.agent.close();
-        }
-        catch { }
-    }, TOOL_RESULT_TIMEOUT_MS);
+    held.idleTimer = setTimeout(() => abortHeld(held), TOOL_RESULT_TIMEOUT_MS);
     held.idleTimer.unref?.();
 }
-async function wireRunCompletion(agentId, held) {
-    if (held.wired)
+async function wireRunCompletion(held) {
+    if (held.wired || !held.run)
         return;
     held.wired = true;
+    let result;
     try {
-        const result = await held.run.wait();
-        if (held.done)
-            return;
-        const usage = mapUsage(result.usage) ?? held.usage;
-        teardownHeld(agentId, held);
-        rememberSession(held, []);
-        held.sink?.finish("stop", usage);
-        try {
-            held.agent.close();
-        }
-        catch { }
+        result = await held.run.wait();
     }
     catch (err) {
-        if (held.done)
-            return;
-        teardownHeld(agentId, held);
-        held.sink?.fail(err);
-        try {
-            held.agent.close();
-        }
-        catch { }
+        if (!held.done)
+            failHeld(held, err);
+        return;
     }
+    if (held.done)
+        return;
+    if (result.status === "cancelled")
+        return abortHeld(held);
+    if (result.status === "error")
+        return failHeld(held, result.error ?? new Error("cursor run failed"));
+    const usage = mapUsage(result.usage) ?? held.usage;
+    teardownHeld(held);
+    rememberSession(held, []);
+    openReply(held);
+    held.sink?.finish("stop", usage);
+    closeAgent(held);
 }
 export function _resetForTest() {
     sessions.clear();
@@ -326,79 +544,110 @@ export function _resetForTest() {
     agentByToolCallId.clear();
     sessionsLoaded = false;
 }
-export async function handleChatCompletion(body, apiKey) {
+export function _stats() {
+    return {
+        held: heldByAgent.size,
+        sessions: sessions.size,
+        disk: diskSessions.size,
+        agentIds: [...sessions.values()].map((v) => v.agentId).sort(),
+        active,
+        waiting: waiters.length,
+    };
+}
+export async function handleChatCompletion(body, apiKey, signal, scope) {
+    if (signal?.aborted)
+        throw new DOMException("aborted", "AbortError");
     await loadSessions();
     const streaming = body.stream !== false;
-    const sse = streaming ? sseResponse(body.model) : undefined;
-    const collected = streaming ? undefined : jsonCollector(body.model);
-    const sink = (sse?.sink ?? collected?.sink);
-    const reply = () => sse?.response ?? collected.promise;
+    const reply = deferred();
+    let held;
+    const sse = streaming ? sseResponse(body.model, () => held && abortHeld(held)) : undefined;
+    const sink = sse?.sink ?? jsonCollector(body.model, reply.resolve);
     // continuation: trailing tool results for a parked run
     const lastMsg = body.messages[body.messages.length - 1];
-    if (lastMsg?.role === "tool" && lastMsg.tool_call_id && agentByToolCallId.has(lastMsg.tool_call_id)) {
+    if (lastMsg?.role === "tool" && lastMsg.tool_call_id) {
         const agentId = agentByToolCallId.get(lastMsg.tool_call_id);
-        const held = heldByAgent.get(agentId);
-        if (held && !held.done) {
-            if (held.idleTimer)
-                clearTimeout(held.idleTimer);
-            held.messages = body.messages;
-            held.textAcc = "";
-            attachSink(held, sink);
-            for (const m of body.messages) {
-                if (m.role !== "tool" || !m.tool_call_id)
-                    continue;
-                const resolve = held.parked.get(m.tool_call_id);
-                if (resolve) {
-                    held.parked.delete(m.tool_call_id);
-                    agentByToolCallId.delete(m.tool_call_id);
-                    resolve(textOf(m.content));
-                }
+        held = agentId ? heldByAgent.get(agentId) : undefined;
+        if (!held || held.done) {
+            return Response.json({ error: { message: "cursor run for this tool call expired — please retry", type: "invalid_request_error", code: "tool_call_expired" } }, { status: 400 });
+        }
+        if (held.idleTimer)
+            clearTimeout(held.idleTimer);
+        held.messages = body.messages;
+        held.textAcc = "";
+        held.reply = reply;
+        held.response = sse?.response ?? null;
+        held.opened = false;
+        attachSignal(held, signal);
+        attachSink(held, sink);
+        for (const m of body.messages) {
+            if (m.role !== "tool" || !m.tool_call_id)
+                continue;
+            const resolve = held.parked.get(m.tool_call_id);
+            if (resolve) {
+                held.parked.delete(m.tool_call_id);
+                agentByToolCallId.delete(m.tool_call_id);
+                resolve(textOf(m.content));
             }
-            return reply();
         }
-        sink.fail(new Error("cursor run for this tool call expired — please retry"));
-        return reply();
+        return reply.promise;
     }
+    // opencode wraps variant options as providerOptions.cursor; @ai-sdk/openai-compatible (name "cursor") spreads them into the body top level
+    const model = resolveVariant(body.model, body.cursor_params) ?? { id: body.model };
+    if (typeof model === "string")
+        return errorResponse(model, 400);
     // new turn: reuse the agent whose last-seen conversation matches our prefix
     const prefix = body.messages.slice(0, -1);
-    const key = hashMessages(prefix);
+    const key = hashMessages(prefix, scope);
+    await acquireSlot(signal);
     const entry = sessions.get(key) ?? diskSessions.get(key);
     let agent;
     let cwd;
     let newSuffix = body.messages;
+    const agentOptions = (cwd) => ({
+        model,
+        tools: ["mcp"],
+        ...(apiKey ? { apiKey } : {}),
+        local: { cwd, settingSources: ["project"], enableAgentRetries: true },
+    });
     if (entry) {
         sessions.delete(key);
+        diskSessions.delete(key);
         cwd = entry.cwd;
-        agent = await Agent.resume(entry.agentId, {
-            model: { id: body.model },
-            tools: ["mcp"],
-            ...(apiKey ? { apiKey } : {}),
-            local: { cwd, settingSources: ["project"], enableAgentRetries: true },
-        }).catch(() => {
-            sessions.delete(key);
-            diskSessions.delete(key);
+        agent = await withRetry(() => Agent.resume(entry.agentId, agentOptions(cwd)), signal).catch(() => {
             saveSessions();
+            releaseCwd(entry.cwd);
             return undefined;
         });
         if (agent)
             newSuffix = body.messages.slice(-1);
     }
     if (!agent) {
-        cwd = await mkdtemp(join(tmpdir(), "opencode-cursor-"));
-        agent = await Agent.create({
-            model: { id: body.model },
-            tools: ["mcp"],
-            ...(apiKey ? { apiKey } : {}),
-            local: { cwd, settingSources: ["project"], enableAgentRetries: true },
-        });
+        cwd = await mkdtemp(TMP_CWD_PREFIX);
+        try {
+            agent = await withRetry(() => Agent.create(agentOptions(cwd)), signal);
+        }
+        catch (err) {
+            releaseSlot();
+            releaseCwd(cwd);
+            if (signal?.aborted)
+                throw abortError();
+            return errorResponse(err);
+        }
     }
-    const held = {
+    held = {
         agent,
         cwd: cwd,
-        run: undefined,
+        model: body.model,
+        run: null,
         messages: body.messages,
+        scope,
         textAcc: "",
         sink: null,
+        reply,
+        response: sse?.response ?? null,
+        opened: false,
+        detachSignal: null,
         buffer: [],
         pendingCalls: [],
         parked: new Map(),
@@ -406,9 +655,12 @@ export async function handleChatCompletion(body, apiKey) {
         idleTimer: null,
         wired: false,
         done: false,
+        slot: true,
     };
+    const self = held;
+    heldByAgent.set(agent.agentId, held);
+    attachSignal(held, signal);
     attachSink(held, sink);
-    const agentIdRef = { id: "" };
     const customTools = {};
     for (const t of body.tools ?? []) {
         customTools[t.function.name] = {
@@ -416,11 +668,11 @@ export async function handleChatCompletion(body, apiKey) {
             inputSchema: t.function.parameters ?? { type: "object", properties: {} },
             execute: (args, ctx) => {
                 const id = (ctx.toolCallId ?? `call_${randomUUID()}`).replace(/\s+/g, "_");
-                held.pendingCalls.push({ id, name: t.function.name, argumentsJson: JSON.stringify(args ?? {}) });
-                if (held.flushTimer)
-                    clearTimeout(held.flushTimer);
-                held.flushTimer = setTimeout(() => flushToolCalls(agentIdRef.id, held), BATCH_SETTLE_MS);
-                return new Promise((resolve) => held.parked.set(id, resolve));
+                self.pendingCalls.push({ id, name: t.function.name, argumentsJson: JSON.stringify(args ?? {}) });
+                if (self.flushTimer)
+                    clearTimeout(self.flushTimer);
+                self.flushTimer = setTimeout(() => flushToolCalls(self), BATCH_SETTLE_MS);
+                return new Promise((resolve) => self.parked.set(id, resolve));
             },
         };
     }
@@ -430,29 +682,40 @@ export async function handleChatCompletion(body, apiKey) {
         .map((m) => (m.role === "user" ? textOf(m.content) : `${m.role.toUpperCase()}: ${textOf(m.content)}`))
         .filter(Boolean)
         .join("\n\n") || "(empty message)";
+    let run;
     try {
-        held.run = await held.agent.send(prompt, {
+        run = await withRetry(() => agent.send(prompt, {
             onDelta: ({ update }) => {
+                if (self.done)
+                    return;
                 if (update.type === "text-delta" && update.text) {
-                    held.textAcc += update.text;
-                    emit(held, "text", update.text);
+                    openReply(self);
+                    self.textAcc += update.text;
+                    emit(self, "text", update.text);
                 }
                 else if (update.type === "thinking-delta" && update.text) {
-                    emit(held, "reasoning", update.text);
+                    openReply(self);
+                    emit(self, "reasoning", update.text);
                 }
                 else if (update.type === "turn-ended") {
-                    held.usage = mapUsage(update.usage);
+                    self.usage = mapUsage(update.usage);
                 }
             },
             local: { customTools: customTools },
-        });
+        }), signal, 1000, (err) => !self.opened && !self.done && isTransient(err));
     }
     catch (err) {
-        sink.fail(err);
-        return reply();
+        if (!self.done)
+            failHeld(self, err);
+        return reply.promise;
+    }
+    if (self.done) {
+        run.cancel().catch(() => { });
+        return reply.promise;
     }
-    agentIdRef.id = held.run.agentId;
-    heldByAgent.set(held.run.agentId, held);
-    void wireRunCompletion(held.run.agentId, held);
-    return reply();
+    if (run.agentId !== agent.agentId)
+        console.error(`[opencode-cursor-auth] run.agentId ${run.agentId} != agent.agentId ${agent.agentId}`);
+    self.run = run;
+    void wireRunCompletion(self);
+    return reply.promise;
 }