doer-agent 0.9.9 → 0.9.10

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,22 @@ async function handleCodexAppRpcMessage(args) {
     }
 }
 export function subscribeToCodexAppRpc(args) {
+    const handoffJobs = new CodexThreadHandoffJobManager(async (input, onProgress) => {
+        try {
+            const result = await createCodexThreadHandoff({
+                manager: args.manager,
+                ...input,
+                onProgress,
+                onLog: args.onInfo,
+            });
+            args.onInfo(`thread handoff completed sourceThreadId=${input.sourceThreadId} targetThreadId=${result.threadId}`);
+            return result;
+        }
+        catch (error) {
+            args.onError(`thread handoff failed sourceThreadId=${input.sourceThreadId} error=${error instanceof Error ? error.message : String(error)}`);
+            throw error;
+        }
+    });
     args.nc.closed().finally(() => {
         void args.manager.stop().catch(() => undefined);
     });
@@ -174,6 +220,7 @@ export function subscribeToCodexAppRpc(args) {
                 nc: args.nc,
                 agentId: args.agentId,
                 manager: args.manager,
+                handoffJobs,
                 onInfo: args.onInfo,
                 onError: args.onError,
             });

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

@@ -0,0 +1,102 @@
+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;
+    terminalTtlMs;
+    maxJobs;
+    jobs = new Map();
+    activeJobBySourceThreadId = new Map();
+    constructor(run, terminalTtlMs = 30 * 60_000, maxJobs = 100) {
+        this.run = run;
+        this.terminalTtlMs = terminalTtlMs;
+        this.maxJobs = maxJobs;
+    }
+    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);
+        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();
+        };
+        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();
+            }
+        }
+        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();
+            }
+        }
+        finally {
+            if (this.activeJobBySourceThreadId.get(input.sourceThreadId) === jobId) {
+                this.activeJobBySourceThreadId.delete(input.sourceThreadId);
+            }
+        }
+    }
+    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,56 @@
+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 manager = new CodexThreadHandoffJobManager(async (input, onProgress) => {
+        onProgress("collecting");
+        return await new Promise((resolve) => {
+            finish = resolve;
+        });
+    });
+    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");
+});
+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 manager = new CodexThreadHandoffJobManager(async () => {
+        throw new Error("summary failed");
+    });
+    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");
+});

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,
@@ -321,6 +324,7 @@ export async function createCodexThreadHandoff(args) {
     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 +337,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 +354,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.10",
   "description": "Reverse-polling agent runtime for doer",
   "type": "module",
   "main": "dist/agent.js",