doer-agent 0.8.2 → 0.8.4

package/dist/agent-codex-cli.js

@@ -70,6 +70,22 @@ export function buildDaemonMcpConfigArgs(args) {
         workspaceRootEnvName: "DOER_DAEMON_WORKSPACE_ROOT",
     });
 }
+export function buildThreadsMcpConfigArgs(args) {
+    return buildWorkspaceMcpConfigArgs({
+        agentProjectDir: args.agentProjectDir,
+        workspaceRoot: args.workspaceRoot,
+        serverName: args.serverName?.trim() || "doer_threads",
+        distEntryRelativePath: path.join("dist", "threads-mcp-server.js"),
+        srcEntryRelativePath: path.join("src", "threads-mcp-server.ts"),
+        workspaceRootEnvName: "DOER_THREADS_WORKSPACE_ROOT",
+        env: {
+            DOER_THREADS_AGENT_ID: args.agentId,
+            DOER_AGENT_TOKEN: args.agentToken,
+            DOER_THREADS_SERVER_BASE_URL: args.serverBaseUrl,
+            DOER_THREADS_USER_ID: args.userId,
+        },
+    });
+}
 export function buildMobileMcpConfigArgs(args) {
     return buildWorkspaceMcpConfigArgs({
         agentProjectDir: args.agentProjectDir,
@@ -88,7 +104,7 @@ export function buildMobileMcpConfigArgs(args) {
 }
 export function buildCustomMcpConfigArgs(servers) {
     const configArgs = [];
-    const reservedNames = new Set(["doer_daemon", "doer_mobile"]);
+    const reservedNames = new Set(["doer_daemon", "doer_mobile", "doer_threads"]);
     const seenNames = new Set();
     for (const server of servers) {
         const serverName = server.name.trim();

package/dist/agent-notes-ai-rpc.js

@@ -29,6 +29,7 @@ function buildNotesAiPrompt(request) {
         "You are editing a Markdown note inside Doer.",
         "Return only Markdown content. Do not include explanations, preambles, or code fences unless the requested content itself needs them.",
         "If a selection is provided, return only the replacement for that selection. If no selection is provided, return content to insert at the cursor.",
+        "When you generate an image, do not write attachment:image links. The generated image will be inserted into the note automatically.",
         "",
         `<instruction>\n${instruction}\n</instruction>`,
         `<document>\n${document}\n</document>`,
@@ -64,6 +65,18 @@ function agentMessageDeltaFromParams(params) {
     }
     return stringValue(record.delta) || stringValue(record.text);
 }
+function generatedImageMarkdownFromParams(params, threadId) {
+    const record = recordValue(params);
+    const item = recordValue(record?.item);
+    if (!record || !item || stringValue(item.type) !== "imageGeneration") {
+        return "";
+    }
+    const imageId = stringValue(item.id);
+    if (!threadId || !imageId) {
+        return "";
+    }
+    return `\n\n![generated image](.codex/generated_images/${threadId}/${imageId}.png)\n\n`;
+}
 function terminalErrorFromParams(params) {
     const record = recordValue(params);
     const error = recordValue(record?.error);
@@ -71,7 +84,7 @@ function terminalErrorFromParams(params) {
         stringValue(error?.message) ||
         stringValue(record?.reason);
 }
-async function archiveThread(args) {
+async function archiveCompletedThread(args) {
     try {
         await args.manager.request("thread/archive", { threadId: args.threadId }, 30_000);
     }
@@ -109,7 +122,7 @@ async function runNotesAiSession(args) {
             callback();
         };
         args.abortController.signal.addEventListener("abort", () => {
-            settleCompleted(() => resolve());
+            settleCompleted(() => resolve("aborted"));
         }, { once: true });
         cleanupNotification = args.manager.onNotification((method, params) => {
             const eventThreadId = threadIdFromParams(params);
@@ -134,6 +147,18 @@ async function runNotesAiSession(args) {
                 });
                 return;
             }
+            if (method === "item/completed") {
+                const markdown = generatedImageMarkdownFromParams(params, threadId);
+                if (!markdown) {
+                    return;
+                }
+                publishEvent({
+                    nc: args.nc,
+                    subject: args.eventsSubject,
+                    payload: { type: "delta", sessionId: args.sessionId, text: markdown },
+                });
+                return;
+            }
             if (!isTerminalTurnMethod(method)) {
                 return;
             }
@@ -144,7 +169,7 @@ async function runNotesAiSession(args) {
                         subject: args.eventsSubject,
                         payload: { type: "done", sessionId: args.sessionId },
                     });
-                    resolve();
+                    resolve("completed");
                 });
                 return;
             }
@@ -177,21 +202,19 @@ async function runNotesAiSession(args) {
         if (args.abortController.signal.aborted) {
             return;
         }
-        await completed.finally(() => cleanupNotification());
-    }
-    catch (error) {
-        settleCompleted(() => { });
-        throw error;
-    }
-    finally {
-        if (threadId) {
-            await archiveThread({
+        const completion = await completed.finally(() => cleanupNotification());
+        if (completion === "completed") {
+            await archiveCompletedThread({
                 manager: args.manager,
                 threadId,
                 onError: args.onError,
             });
         }
     }
+    catch (error) {
+        settleCompleted(() => { });
+        throw error;
+    }
 }
 async function handleStart(args) {
     const sessionId = stringValue(args.request.sessionId);

package/dist/codex-app-server-manager.js

@@ -1,5 +1,5 @@
 import { buildAgentSettingsEnvPatch, readAgentModelInstructions, resolveAgentModelInstructionsFilePath, } from "./agent-settings.js";
-import { buildCustomMcpConfigArgs, buildDaemonMcpConfigArgs, buildMobileMcpConfigArgs } from "./agent-codex-cli.js";
+import { buildCustomMcpConfigArgs, buildDaemonMcpConfigArgs, buildMobileMcpConfigArgs, buildThreadsMcpConfigArgs } from "./agent-codex-cli.js";
 import { CodexAppServerClient } from "./codex-app-server-client.js";
 function toTomlStringLiteral(value) {
     return `"${value.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
@@ -32,6 +32,14 @@ async function buildCodexAppServerArgs(args) {
             agentProjectDir: args.agentProjectDir,
             workspaceRoot: args.workspaceRoot,
         }),
+        ...buildThreadsMcpConfigArgs({
+            agentId: args.agentId,
+            agentProjectDir: args.agentProjectDir,
+            agentToken: args.agentToken,
+            serverBaseUrl: args.serverBaseUrl,
+            userId: args.userId,
+            workspaceRoot: args.workspaceRoot,
+        }),
         ...buildMobileMcpConfigArgs({
             agentId: args.agentId,
             agentProjectDir: args.agentProjectDir,

package/dist/threads-mcp-server.js

@@ -0,0 +1,170 @@
+import path from "node:path";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import * as z from "zod/v4";
+function parseWorkspaceRoot(argv) {
+    const flagIndex = argv.findIndex((token) => token === "--workspace-root");
+    const flagValue = flagIndex >= 0 ? argv[flagIndex + 1] : "";
+    const envValue = process.env.DOER_THREADS_WORKSPACE_ROOT?.trim() || process.env.WORKSPACE?.trim() || process.cwd();
+    return path.resolve((flagValue || envValue || process.cwd()).trim());
+}
+function formatJson(value) {
+    return JSON.stringify(value, null, 2);
+}
+function optionalEnv(name) {
+    return process.env[name]?.trim() || "";
+}
+function getThreadApiConfig() {
+    const agentId = optionalEnv("DOER_THREADS_AGENT_ID");
+    const agentToken = optionalEnv("DOER_AGENT_TOKEN");
+    const serverBaseUrl = optionalEnv("DOER_THREADS_SERVER_BASE_URL").replace(/\/$/, "");
+    const userId = optionalEnv("DOER_THREADS_USER_ID");
+    const missing = [
+        agentId ? null : "DOER_THREADS_AGENT_ID",
+        agentToken ? null : "DOER_AGENT_TOKEN",
+        serverBaseUrl ? null : "DOER_THREADS_SERVER_BASE_URL",
+        userId ? null : "DOER_THREADS_USER_ID",
+    ].filter((item) => Boolean(item));
+    if (missing.length > 0) {
+        throw new Error(`thread tools are unavailable; missing ${missing.join(", ")}`);
+    }
+    return { agentId, agentToken, serverBaseUrl, userId };
+}
+function codexThreadPath(config, method) {
+    return `/api/users/${encodeURIComponent(config.userId)}/agents/${encodeURIComponent(config.agentId)}/codex/${method}`;
+}
+async function postDoerJson(pathValue, body, timeoutMs) {
+    const config = getThreadApiConfig();
+    const response = await fetch(`${config.serverBaseUrl}${pathValue}`, {
+        method: "POST",
+        headers: {
+            Authorization: `Bearer ${config.agentToken}`,
+            Accept: "application/json",
+            "Content-Type": "application/json",
+            ...(timeoutMs ? { "x-doer-rpc-timeout-ms": String(timeoutMs) } : {}),
+        },
+        body: JSON.stringify(body),
+    });
+    const data = await response.json().catch(() => ({}));
+    if (!response.ok) {
+        throw new Error(typeof data.error === "string" ? data.error : `Doer server returned ${response.status}`);
+    }
+    return data;
+}
+function jsonToolResult(result) {
+    return {
+        content: [{ type: "text", text: formatJson(result) }],
+        structuredContent: result && typeof result === "object" && !Array.isArray(result)
+            ? result
+            : { result },
+    };
+}
+function threadListParams(args) {
+    const limit = Number.isFinite(args.limit) && args.limit
+        ? Math.min(100, Math.max(1, Math.trunc(args.limit)))
+        : 50;
+    return {
+        cursor: args.cursor?.trim() || null,
+        limit,
+        sortKey: "updated_at",
+        sortDirection: "desc",
+        sourceKinds: [
+            "cli",
+            "vscode",
+            "exec",
+            "appServer",
+            "subAgent",
+            "subAgentReview",
+            "subAgentCompact",
+            "subAgentThreadSpawn",
+            "subAgentOther",
+            "unknown",
+        ],
+        archived: args.archived ?? false,
+        searchTerm: args.searchTerm?.trim() || null,
+    };
+}
+async function archiveThread(threadId) {
+    const config = getThreadApiConfig();
+    return postDoerJson(codexThreadPath(config, "thread/archive"), { threadId: threadId.trim() }, 180_000);
+}
+async function main() {
+    parseWorkspaceRoot(process.argv.slice(2));
+    const server = new McpServer({
+        name: "doer-threads",
+        version: "0.1.0",
+    }, {
+        capabilities: {
+            tools: {},
+        },
+        instructions: "Start, list, read, close, and archive Codex threads for the current Doer agent.",
+    });
+    server.registerTool("threads_list", {
+        description: "List Codex threads for this Doer agent using the same API as the Doer thread list.",
+        inputSchema: {
+            archived: z.boolean().optional().describe("Whether to list archived threads. Defaults to false."),
+            cursor: z.string().optional().describe("Optional pagination cursor returned by the thread list API."),
+            limit: z.number().int().min(1).max(100).optional().describe("Maximum number of threads to return. Defaults to 50."),
+            searchTerm: z.string().optional().describe("Optional text search term."),
+        },
+    }, async ({ archived, cursor, limit, searchTerm }) => {
+        const config = getThreadApiConfig();
+        const result = await postDoerJson(codexThreadPath(config, "thread/list"), threadListParams({ archived, cursor, limit, searchTerm }), 180_000);
+        return jsonToolResult(result);
+    });
+    server.registerTool("threads_start", {
+        description: "Create a new Codex thread for this Doer agent and start its first turn.",
+        inputSchema: {
+            prompt: z.string().min(1).describe("User prompt for the first turn in the new thread."),
+        },
+    }, async ({ prompt }) => {
+        const config = getThreadApiConfig();
+        const result = await postDoerJson(codexThreadPath(config, "thread/send"), { prompt }, 180_000);
+        return jsonToolResult(result);
+    });
+    server.registerTool("threads_read", {
+        description: "Read a Codex thread and its recent turn contents for this Doer agent.",
+        inputSchema: {
+            threadId: z.string().min(1).describe("Codex thread id to read."),
+            cursor: z.string().optional().describe("Optional pagination cursor for turns."),
+            limit: z.number().int().min(1).max(100).optional().describe("Maximum number of turns to return. Defaults to 50."),
+        },
+    }, async ({ threadId, cursor, limit }) => {
+        const config = getThreadApiConfig();
+        const normalizedThreadId = threadId.trim();
+        const turnsLimit = Number.isFinite(limit) && limit ? Math.min(100, Math.max(1, Math.trunc(limit))) : 50;
+        const [thread, turns] = await Promise.all([
+            postDoerJson(codexThreadPath(config, "thread/read"), { threadId: normalizedThreadId }, 180_000),
+            postDoerJson(codexThreadPath(config, "thread/turns/list"), {
+                threadId: normalizedThreadId,
+                cursor: cursor?.trim() || null,
+                limit: turnsLimit,
+                sortDirection: "desc",
+            }, 180_000),
+        ]);
+        return jsonToolResult({ thread, turns });
+    });
+    server.registerTool("threads_close", {
+        description: "Close a Codex thread for this Doer agent by archiving it with the same API as Doer thread delete.",
+        inputSchema: {
+            threadId: z.string().min(1).describe("Codex thread id to close."),
+        },
+    }, async ({ threadId }) => {
+        return jsonToolResult(await archiveThread(threadId) ?? { ok: true });
+    });
+    server.registerTool("threads_archive", {
+        description: "Archive a Codex thread for this Doer agent using the same API as Doer thread delete.",
+        inputSchema: {
+            threadId: z.string().min(1).describe("Codex thread id to archive."),
+        },
+    }, async ({ threadId }) => {
+        return jsonToolResult(await archiveThread(threadId) ?? { ok: true });
+    });
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+}
+main().catch((error) => {
+    const message = error instanceof Error ? error.stack || error.message : String(error);
+    process.stderr.write(`${message}\n`);
+    process.exit(1);
+});

package/package.json

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