doer-agent 0.9.9 → 0.9.11

package/dist/agent-codex-app-rpc.js

@@ -1,5 +1,6 @@
 import { StringCodec } from "nats";
 import { createCodexThreadHandoff, } from "./codex-thread-handoff.js";
+import { CodexThreadHandoffJobManager } from "./codex-thread-handoff-jobs.js";
 const codexAppRpcCodec = StringCodec();
 const codexAppRpcOmitRules = [
     {
@@ -84,7 +85,7 @@ function normalizeCodexAppRpcRequest(args) {
         }
         return { requestId, action: "mcp-oauth-logout", name };
     }
-    if (actionRaw === "thread-handoff") {
+    if (actionRaw === "thread-handoff" || actionRaw === "thread-handoff-start") {
         const sourceThreadId = typeof args.request.sourceThreadId === "string" ? args.request.sourceThreadId.trim() : "";
         const targetName = typeof args.request.targetName === "string" ? args.request.targetName.trim() : "";
         const activeTurnId = typeof args.request.activeTurnId === "string" ? args.request.activeTurnId.trim() : "";
@@ -102,7 +103,7 @@ function normalizeCodexAppRpcRequest(args) {
         }
         return {
             requestId,
-            action: "thread-handoff",
+            action: actionRaw,
             sourceThreadId,
             targetName,
             activeTurnId,
@@ -110,6 +111,13 @@ function normalizeCodexAppRpcRequest(args) {
             sourceGoal,
         };
     }
+    if (actionRaw === "thread-handoff-status") {
+        const jobId = typeof args.request.jobId === "string" ? args.request.jobId.trim() : "";
+        if (!jobId) {
+            throw new Error("invalid thread handoff status request");
+        }
+        return { requestId, action: "thread-handoff-status", jobId };
+    }
     if (actionRaw !== "request" || !method) {
         throw new Error("invalid codex app rpc request");
     }
@@ -127,21 +135,43 @@ async function handleCodexAppRpcMessage(args) {
         const payload = JSON.parse(codexAppRpcCodec.decode(args.msg.data));
         const request = normalizeCodexAppRpcRequest({ request: payload, agentId: args.agentId });
         requestId = request.requestId;
-        const result = request.action === "request"
-            ? applyCodexAppRpcOmitRules(request.method, await args.manager.request(request.method, request.params, request.timeoutMs))
-            : request.action === "mcp-oauth-callback"
-                ? await args.manager.relayMcpOauthCallback(request.path, request.search)
-                : request.action === "mcp-oauth-logout"
-                    ? await args.manager.logoutMcpServer(request.name)
-                    : await createCodexThreadHandoff({
-                        manager: args.manager,
-                        sourceThreadId: request.sourceThreadId,
-                        targetName: request.targetName,
-                        activeTurnId: request.activeTurnId,
-                        latestUserText: request.latestUserText,
-                        sourceGoal: request.sourceGoal,
-                        onLog: args.onInfo,
-                    });
+        let result;
+        if (request.action === "request") {
+            result = applyCodexAppRpcOmitRules(request.method, await args.manager.request(request.method, request.params, request.timeoutMs));
+        }
+        else if (request.action === "mcp-oauth-callback") {
+            result = await args.manager.relayMcpOauthCallback(request.path, request.search);
+        }
+        else if (request.action === "mcp-oauth-logout") {
+            result = await args.manager.logoutMcpServer(request.name);
+        }
+        else if (request.action === "thread-handoff-status") {
+            const job = args.handoffJobs.get(request.jobId);
+            if (!job) {
+                throw new Error("thread handoff job not found");
+            }
+            result = job;
+        }
+        else if (request.action === "thread-handoff-start") {
+            result = args.handoffJobs.start({
+                sourceThreadId: request.sourceThreadId,
+                targetName: request.targetName,
+                activeTurnId: request.activeTurnId,
+                latestUserText: request.latestUserText,
+                sourceGoal: request.sourceGoal,
+            });
+        }
+        else {
+            result = await createCodexThreadHandoff({
+                manager: args.manager,
+                sourceThreadId: request.sourceThreadId,
+                targetName: request.targetName,
+                activeTurnId: request.activeTurnId,
+                latestUserText: request.latestUserText,
+                sourceGoal: request.sourceGoal,
+                onLog: args.onInfo,
+            });
+        }
         args.msg.respond(codexAppRpcCodec.encode(JSON.stringify({
             requestId,
             ok: true,
@@ -159,6 +189,29 @@ async function handleCodexAppRpcMessage(args) {
     }
 }
 export function subscribeToCodexAppRpc(args) {
+    const handoffJobs = new CodexThreadHandoffJobManager(async (input, onProgress) => {
+        return await createCodexThreadHandoff({
+            manager: args.manager,
+            ...input,
+            onProgress,
+            onLog: args.onInfo,
+        });
+    }, {
+        onStatus: (job) => {
+            const elapsedMs = Math.max(0, Date.parse(job.updatedAt) - Date.parse(job.createdAt));
+            const target = job.result?.threadId ? ` targetThreadId=${job.result.threadId}` : "";
+            const error = job.error
+                ? ` error=${JSON.stringify(job.error.replace(/\s+/g, " ").slice(0, 500))}`
+                : "";
+            const message = `thread handoff job status jobId=${job.jobId} sourceThreadId=${job.sourceThreadId} phase=${job.phase} elapsedMs=${elapsedMs}${target}${error}`;
+            if (job.phase === "failed") {
+                args.onError(message);
+            }
+            else {
+                args.onInfo(message);
+            }
+        },
+    });
     args.nc.closed().finally(() => {
         void args.manager.stop().catch(() => undefined);
     });
@@ -174,6 +227,7 @@ export function subscribeToCodexAppRpc(args) {
                 nc: args.nc,
                 agentId: args.agentId,
                 manager: args.manager,
+                handoffJobs,
                 onInfo: args.onInfo,
                 onError: args.onError,
             });

package/dist/codex-text-task.js

@@ -37,14 +37,17 @@ function buildCodexUserInput(prompt) {
         }];
 }
 export async function runCodexTextTask(args) {
+    const startedAt = Date.now();
     let threadId = "";
     let turnId = "";
     let output = "";
+    let outputStarted = false;
     let settled = false;
     let cleanupNotification = () => { };
     let settle = (_callback) => { };
     const completed = new Promise((resolve, reject) => {
         const timeout = setTimeout(() => {
+            args.onLog?.(`codex text task status phase=timed_out threadId=${threadId || "pending"} turnId=${turnId || "pending"} elapsedMs=${Date.now() - startedAt} outputChars=${output.length}`);
             settle(() => reject(new Error("Timed out while waiting for Codex text task")));
         }, args.timeoutMs ?? DEFAULT_TIMEOUT_MS);
         settle = (callback) => {
@@ -69,11 +72,16 @@ export async function runCodexTextTask(args) {
             if (method === "item/agentMessage/delta") {
                 const record = recordValue(params);
                 output += stringValue(record?.delta) || stringValue(record?.text);
+                if (!outputStarted && output) {
+                    outputStarted = true;
+                    args.onLog?.(`codex text task status phase=responding threadId=${threadId} turnId=${turnId || eventTurnId || "pending"} elapsedMs=${Date.now() - startedAt}`);
+                }
                 return;
             }
             if (!isTerminalTurnMethod(method)) {
                 return;
             }
+            args.onLog?.(`codex text task status phase=terminal_notification method=${method} threadId=${threadId} turnId=${turnId || eventTurnId || "pending"} elapsedMs=${Date.now() - startedAt} outputChars=${output.length}`);
             if (method === "turn/completed") {
                 settle(resolve);
                 return;
@@ -92,6 +100,7 @@ export async function runCodexTextTask(args) {
         if (!threadId) {
             throw new Error("Codex app-server did not return a text task thread id");
         }
+        args.onLog?.(`codex text task status phase=thread_started threadId=${threadId} elapsedMs=${Date.now() - startedAt}`);
         const turnResult = recordValue(await args.manager.request("turn/start", {
             threadId,
             input: buildCodexUserInput(args.prompt),
@@ -100,16 +109,25 @@ export async function runCodexTextTask(args) {
         if (!turnId) {
             throw new Error("Codex app-server did not return a text task turn id");
         }
+        args.onLog?.(`codex text task status phase=turn_started threadId=${threadId} turnId=${turnId} elapsedMs=${Date.now() - startedAt}`);
         await completed.finally(() => cleanupNotification());
+        args.onLog?.(`codex text task status phase=completed threadId=${threadId} turnId=${turnId} elapsedMs=${Date.now() - startedAt} outputChars=${output.length}`);
         return output;
     }
     catch (error) {
         settle(() => { });
+        args.onLog?.(`codex text task status phase=failed threadId=${threadId || "pending"} turnId=${turnId || "pending"} elapsedMs=${Date.now() - startedAt} error=${JSON.stringify((error instanceof Error ? error.message : String(error)).replace(/\s+/g, " ").slice(0, 500))}`);
         throw error;
     }
     finally {
         if (threadId) {
-            await args.manager.request("thread/unsubscribe", { threadId }, 30_000).catch(() => undefined);
+            await args.manager.request("thread/unsubscribe", { threadId }, 30_000)
+                .then(() => {
+                args.onLog?.(`codex text task status phase=unsubscribed threadId=${threadId} turnId=${turnId || "pending"} elapsedMs=${Date.now() - startedAt}`);
+            })
+                .catch((error) => {
+                args.onLog?.(`codex text task status phase=unsubscribe_failed threadId=${threadId} turnId=${turnId || "pending"} elapsedMs=${Date.now() - startedAt} error=${JSON.stringify((error instanceof Error ? error.message : String(error)).replace(/\s+/g, " ").slice(0, 500))}`);
+            });
         }
     }
 }

package/dist/codex-thread-handoff-jobs.js

@@ -0,0 +1,111 @@
+import { randomUUID } from "node:crypto";
+const TERMINAL_PHASES = new Set(["completed", "failed"]);
+function copySnapshot(job) {
+    return {
+        ...job,
+        ...(job.result ? { result: { ...job.result } } : {}),
+    };
+}
+export class CodexThreadHandoffJobManager {
+    run;
+    jobs = new Map();
+    activeJobBySourceThreadId = new Map();
+    terminalTtlMs;
+    maxJobs;
+    onStatus;
+    constructor(run, options = {}) {
+        this.run = run;
+        this.terminalTtlMs = options.terminalTtlMs ?? 30 * 60_000;
+        this.maxJobs = options.maxJobs ?? 100;
+        this.onStatus = options.onStatus;
+    }
+    start(input) {
+        this.cleanup();
+        const existingJobId = this.activeJobBySourceThreadId.get(input.sourceThreadId);
+        const existing = existingJobId ? this.jobs.get(existingJobId) : undefined;
+        if (existing && !TERMINAL_PHASES.has(existing.phase)) {
+            return { job: copySnapshot(existing), deduplicated: true };
+        }
+        if (this.jobs.size >= this.maxJobs) {
+            throw new Error("too many thread handoff jobs");
+        }
+        const now = new Date().toISOString();
+        const job = {
+            jobId: randomUUID(),
+            sourceThreadId: input.sourceThreadId,
+            phase: "queued",
+            createdAt: now,
+            updatedAt: now,
+        };
+        this.jobs.set(job.jobId, job);
+        this.activeJobBySourceThreadId.set(input.sourceThreadId, job.jobId);
+        this.emitStatus(job);
+        setImmediate(() => {
+            void this.execute(job.jobId, input);
+        });
+        return { job: copySnapshot(job), deduplicated: false };
+    }
+    get(jobId) {
+        this.cleanup();
+        const job = this.jobs.get(jobId);
+        return job ? copySnapshot(job) : null;
+    }
+    async execute(jobId, input) {
+        const updatePhase = (phase) => {
+            const current = this.jobs.get(jobId);
+            if (!current || TERMINAL_PHASES.has(current.phase)) {
+                return;
+            }
+            current.phase = phase;
+            current.updatedAt = new Date().toISOString();
+            this.emitStatus(current);
+        };
+        try {
+            const result = await this.run(input, updatePhase);
+            const current = this.jobs.get(jobId);
+            if (current) {
+                current.phase = "completed";
+                current.result = result;
+                current.updatedAt = new Date().toISOString();
+                this.emitStatus(current);
+            }
+        }
+        catch (error) {
+            const current = this.jobs.get(jobId);
+            if (current) {
+                current.phase = "failed";
+                current.error = error instanceof Error ? error.message : String(error);
+                current.updatedAt = new Date().toISOString();
+                this.emitStatus(current);
+            }
+        }
+        finally {
+            if (this.activeJobBySourceThreadId.get(input.sourceThreadId) === jobId) {
+                this.activeJobBySourceThreadId.delete(input.sourceThreadId);
+            }
+        }
+    }
+    emitStatus(job) {
+        this.onStatus?.(copySnapshot(job));
+    }
+    cleanup() {
+        const cutoff = Date.now() - this.terminalTtlMs;
+        for (const [jobId, job] of this.jobs) {
+            if (TERMINAL_PHASES.has(job.phase) && Date.parse(job.updatedAt) < cutoff) {
+                this.jobs.delete(jobId);
+            }
+        }
+        if (this.jobs.size < this.maxJobs) {
+            return;
+        }
+        const terminalJobs = [...this.jobs.values()]
+            .filter((job) => TERMINAL_PHASES.has(job.phase))
+            .sort((left, right) => Date.parse(left.updatedAt) - Date.parse(right.updatedAt));
+        while (this.jobs.size >= this.maxJobs && terminalJobs.length > 0) {
+            const oldest = terminalJobs.shift();
+            if (oldest) {
+                this.jobs.delete(oldest.jobId);
+            }
+        }
+    }
+}

package/dist/codex-thread-handoff-jobs.test.js

@@ -0,0 +1,67 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { CodexThreadHandoffJobManager } from "./codex-thread-handoff-jobs.js";
+function handoffResult(sourceThreadId) {
+    return {
+        sourceThreadId,
+        thread: { id: "target-thread" },
+        threadId: "target-thread",
+        handoff: "summary",
+        turnsCollected: 2,
+        turnsOmitted: 0,
+        warnings: [],
+    };
+}
+async function nextTick() {
+    await new Promise((resolve) => setImmediate(resolve));
+}
+test("starts handoff work asynchronously and reports progress", async () => {
+    let finish;
+    const statuses = [];
+    const manager = new CodexThreadHandoffJobManager(async (input, onProgress) => {
+        onProgress("collecting");
+        return await new Promise((resolve) => {
+            finish = resolve;
+        });
+    }, {
+        onStatus: (job) => statuses.push(job.phase),
+    });
+    const started = manager.start({ sourceThreadId: "source-thread" });
+    assert.equal(started.job.phase, "queued");
+    assert.equal(started.deduplicated, false);
+    await nextTick();
+    assert.equal(manager.get(started.job.jobId)?.phase, "collecting");
+    finish?.(handoffResult("source-thread"));
+    await nextTick();
+    const completed = manager.get(started.job.jobId);
+    assert.equal(completed?.phase, "completed");
+    assert.equal(completed?.result?.threadId, "target-thread");
+    assert.deepEqual(statuses, ["queued", "collecting", "completed"]);
+});
+test("deduplicates active jobs for the same source thread", () => {
+    const manager = new CodexThreadHandoffJobManager(async () => {
+        return await new Promise(() => undefined);
+    });
+    const first = manager.start({ sourceThreadId: "source-thread" });
+    const second = manager.start({ sourceThreadId: "source-thread" });
+    assert.equal(second.deduplicated, true);
+    assert.equal(second.job.jobId, first.job.jobId);
+});
+test("keeps a failed job status for polling", async () => {
+    const statuses = [];
+    const manager = new CodexThreadHandoffJobManager(async () => {
+        throw new Error("summary failed");
+    }, {
+        onStatus: (job) => statuses.push({ phase: job.phase, error: job.error }),
+    });
+    const started = manager.start({ sourceThreadId: "source-thread" });
+    await nextTick();
+    await nextTick();
+    const failed = manager.get(started.job.jobId);
+    assert.equal(failed?.phase, "failed");
+    assert.equal(failed?.error, "summary failed");
+    assert.deepEqual(statuses, [
+        { phase: "queued", error: undefined },
+        { phase: "failed", error: "summary failed" },
+    ]);
+});

package/dist/codex-thread-handoff.js

@@ -265,6 +265,7 @@ export async function createCodexThreadHandoff(args) {
     }
     const warnings = [];
     const sourceGoal = normalizeGoal(args.sourceGoal);
+    args.onProgress?.("preparing");
     if (sourceGoal?.status === "active") {
         await args.manager.request("thread/goal/set", {
             threadId: sourceThreadId,
@@ -282,6 +283,7 @@ export async function createCodexThreadHandoff(args) {
             warnings.push(`Could not interrupt source turn: ${error instanceof Error ? error.message : String(error)}`);
         });
     }
+    args.onProgress?.("collecting");
     args.onLog?.(`collecting handoff history sourceThreadId=${sourceThreadId}`);
     const sourceRead = recordValue(await args.manager.request("thread/read", {
         threadId: sourceThreadId,
@@ -304,6 +306,7 @@ export async function createCodexThreadHandoff(args) {
     }
     const turnsOmitted = Math.max(0, collected.turnCount - bounded.includedTurns)
         + (collected.truncated ? 1 : 0);
+    args.onProgress?.("summarizing");
     args.onLog?.(`summarizing handoff sourceThreadId=${sourceThreadId} turns=${collected.turnCount}`);
     const handoffRaw = await runCodexTextTask({
         manager: args.manager,
@@ -316,11 +319,13 @@ export async function createCodexThreadHandoff(args) {
             turnsCollected: collected.turnCount,
             turnsOmitted,
         }),
+        onLog: args.onLog,
     });
     const handoff = boundedText(handoffRaw, MAX_HANDOFF_CHARS);
     if (!handoff) {
         throw new Error("Codex did not return a thread handoff summary");
     }
+    args.onProgress?.("creating");
     args.onLog?.(`creating handoff target sourceThreadId=${sourceThreadId}`);
     const startResult = recordValue(await args.manager.request("thread/start", {
         cwd: sourceCwd || null,
@@ -333,6 +338,7 @@ export async function createCodexThreadHandoff(args) {
         throw new Error("Codex app-server did not return a handoff target thread");
     }
     try {
+        args.onProgress?.("injecting");
         await args.manager.request("thread/inject_items", {
             threadId,
             items: [{
@@ -349,6 +355,7 @@ export async function createCodexThreadHandoff(args) {
         await args.manager.request("thread/delete", { threadId }, 30_000).catch(() => undefined);
         throw error;
     }
+    args.onProgress?.("finalizing");
     const targetName = stringValue(args.targetName).slice(0, 200);
     if (targetName) {
         await args.manager.request("thread/name/set", {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "doer-agent",
-  "version": "0.9.9",
+  "version": "0.9.11",
   "description": "Reverse-polling agent runtime for doer",
   "type": "module",
   "main": "dist/agent.js",