doer-agent 0.8.1 → 0.8.2

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

@@ -0,0 +1,286 @@
+import { StringCodec } from "nats";
+const codec = StringCodec();
+const SESSION_TIMEOUT_MS = 180_000;
+const activeSessions = new Map();
+function stringValue(value) {
+    return typeof value === "string" ? value : "";
+}
+function recordValue(value) {
+    return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function publishEvent(args) {
+    args.nc.publish(args.subject, codec.encode(JSON.stringify(args.payload)));
+}
+function respond(msg, payload) {
+    msg.respond(codec.encode(JSON.stringify(payload)));
+}
+function buildCodexUserInput(prompt) {
+    return [{
+            type: "text",
+            text: prompt,
+            text_elements: [],
+        }];
+}
+function buildNotesAiPrompt(request) {
+    const document = stringValue(request.document);
+    const selection = stringValue(request.selection);
+    const instruction = stringValue(request.instruction);
+    const parts = [
+        "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.",
+        "",
+        `<instruction>\n${instruction}\n</instruction>`,
+        `<document>\n${document}\n</document>`,
+    ];
+    if (selection) {
+        parts.push(`<selection>\n${selection}\n</selection>`);
+    }
+    return parts.join("\n\n");
+}
+function isTerminalTurnMethod(method) {
+    return method === "turn/completed" ||
+        method === "turn/failed" ||
+        method === "turn/error" ||
+        method === "turn/cancelled" ||
+        method === "turn/canceled" ||
+        method === "turn/interrupted" ||
+        method === "turn/aborted";
+}
+function threadIdFromParams(params) {
+    const record = recordValue(params);
+    const thread = recordValue(record?.thread);
+    return stringValue(record?.threadId) || stringValue(thread?.id);
+}
+function turnIdFromParams(params) {
+    const record = recordValue(params);
+    const turn = recordValue(record?.turn);
+    return stringValue(record?.turnId) || stringValue(turn?.id);
+}
+function agentMessageDeltaFromParams(params) {
+    const record = recordValue(params);
+    if (!record) {
+        return "";
+    }
+    return stringValue(record.delta) || stringValue(record.text);
+}
+function terminalErrorFromParams(params) {
+    const record = recordValue(params);
+    const error = recordValue(record?.error);
+    return stringValue(record?.message) ||
+        stringValue(error?.message) ||
+        stringValue(record?.reason);
+}
+async function archiveThread(args) {
+    try {
+        await args.manager.request("thread/archive", { threadId: args.threadId }, 30_000);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        args.onError(`notes ai thread archive failed threadId=${args.threadId} error=${message}`);
+    }
+}
+async function runNotesAiSession(args) {
+    const instruction = stringValue(args.request.instruction);
+    if (!instruction) {
+        throw new Error("instruction is required");
+    }
+    if (args.abortController.signal.aborted) {
+        return;
+    }
+    let threadId = "";
+    let turnId = "";
+    let settled = false;
+    let cleanupNotification = () => { };
+    let settleCompleted = (_callback) => { };
+    const completed = new Promise((resolve, reject) => {
+        const timeout = setTimeout(() => {
+            if (!settled) {
+                reject(new Error("Timed out while waiting for Codex notes AI result"));
+            }
+        }, SESSION_TIMEOUT_MS);
+        settleCompleted = (callback) => {
+            if (settled) {
+                return;
+            }
+            settled = true;
+            clearTimeout(timeout);
+            cleanupNotification();
+            callback();
+        };
+        args.abortController.signal.addEventListener("abort", () => {
+            settleCompleted(() => resolve());
+        }, { once: true });
+        cleanupNotification = args.manager.onNotification((method, params) => {
+            const eventThreadId = threadIdFromParams(params);
+            const eventTurnId = turnIdFromParams(params);
+            const isSessionEvent = (threadId && eventThreadId === threadId) ||
+                (turnId && eventTurnId === turnId);
+            if (!isSessionEvent) {
+                return;
+            }
+            if (turnId && eventTurnId && eventTurnId !== turnId) {
+                return;
+            }
+            if (method === "item/agentMessage/delta") {
+                const text = agentMessageDeltaFromParams(params);
+                if (!text) {
+                    return;
+                }
+                publishEvent({
+                    nc: args.nc,
+                    subject: args.eventsSubject,
+                    payload: { type: "delta", sessionId: args.sessionId, text },
+                });
+                return;
+            }
+            if (!isTerminalTurnMethod(method)) {
+                return;
+            }
+            if (method === "turn/completed") {
+                settleCompleted(() => {
+                    publishEvent({
+                        nc: args.nc,
+                        subject: args.eventsSubject,
+                        payload: { type: "done", sessionId: args.sessionId },
+                    });
+                    resolve();
+                });
+                return;
+            }
+            const message = terminalErrorFromParams(params) || `Codex notes AI turn ended with ${method}`;
+            settleCompleted(() => reject(new Error(message)));
+        });
+    });
+    try {
+        const threadResult = recordValue(await args.manager.request("thread/start", {
+            cwd: null,
+            sessionStartSource: "clear",
+        }, 30_000));
+        const thread = recordValue(threadResult?.thread);
+        threadId = stringValue(thread?.id);
+        if (!threadId) {
+            throw new Error("Codex app-server did not return a thread id");
+        }
+        if (args.abortController.signal.aborted) {
+            return;
+        }
+        const turnResult = recordValue(await args.manager.request("turn/start", {
+            threadId,
+            input: buildCodexUserInput(buildNotesAiPrompt(args.request)),
+        }, 30_000));
+        const turn = recordValue(turnResult?.turn);
+        turnId = stringValue(turn?.id);
+        if (!turnId) {
+            throw new Error("Codex app-server did not return a turn id");
+        }
+        if (args.abortController.signal.aborted) {
+            return;
+        }
+        await completed.finally(() => cleanupNotification());
+    }
+    catch (error) {
+        settleCompleted(() => { });
+        throw error;
+    }
+    finally {
+        if (threadId) {
+            await archiveThread({
+                manager: args.manager,
+                threadId,
+                onError: args.onError,
+            });
+        }
+    }
+}
+async function handleStart(args) {
+    const sessionId = stringValue(args.request.sessionId);
+    const eventsSubject = stringValue(args.request.eventsSubject);
+    if (!sessionId || !eventsSubject) {
+        throw new Error("sessionId and eventsSubject are required");
+    }
+    if (stringValue(args.request.agentId) && stringValue(args.request.agentId) !== args.agentId) {
+        throw new Error("agent id mismatch");
+    }
+    activeSessions.get(sessionId)?.abortController.abort();
+    const abortController = new AbortController();
+    activeSessions.set(sessionId, { abortController });
+    respond(args.msg, { requestId: args.request.requestId, ok: true, action: "start", sessionId });
+    void runNotesAiSession({
+        nc: args.nc,
+        manager: args.manager,
+        request: args.request,
+        sessionId,
+        eventsSubject,
+        abortController,
+        onError: args.onError,
+    }).catch((error) => {
+        const message = error instanceof Error ? error.message : String(error);
+        if (!abortController.signal.aborted) {
+            publishEvent({
+                nc: args.nc,
+                subject: eventsSubject,
+                payload: { type: "error", sessionId, error: message },
+            });
+            args.onError(`notes ai session failed sessionId=${sessionId} error=${message}`);
+        }
+    }).finally(() => {
+        if (activeSessions.get(sessionId)?.abortController === abortController) {
+            activeSessions.delete(sessionId);
+        }
+    });
+}
+export async function handleNotesAiRpcMessage(args) {
+    let payload = {};
+    try {
+        payload = JSON.parse(codec.decode(args.msg.data));
+        const action = stringValue(payload.action);
+        if (action === "cancel") {
+            const sessionId = stringValue(payload.sessionId);
+            activeSessions.get(sessionId)?.abortController.abort();
+            activeSessions.delete(sessionId);
+            respond(args.msg, { requestId: payload.requestId, ok: true, action, sessionId });
+            return;
+        }
+        if (action !== "start") {
+            throw new Error("unsupported notes ai action");
+        }
+        await handleStart({
+            msg: args.msg,
+            nc: args.nc,
+            manager: args.manager,
+            request: payload,
+            agentId: args.agentId,
+            onError: args.onError,
+        });
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : "unknown error";
+        respond(args.msg, {
+            requestId: payload.requestId,
+            ok: false,
+            action: stringValue(payload.action),
+            error: message,
+        });
+        args.onError(`notes ai rpc failed action=${stringValue(payload.action) || "unknown"} error=${message}`);
+    }
+}
+export function subscribeToNotesAiRpc(args) {
+    args.nc.subscribe(args.subject, {
+        callback: (error, msg) => {
+            if (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                args.onError(`notes ai rpc subscription error: ${message}`);
+                return;
+            }
+            void handleNotesAiRpcMessage({
+                msg,
+                nc: args.nc,
+                manager: args.manager,
+                agentId: args.agentId,
+                onError: args.onError,
+            });
+        },
+    });
+    args.onInfo(`notes ai rpc subscribed subject=${args.subject}`);
+}

package/dist/agent-runtime-utils.js

@@ -25,6 +25,9 @@ export function buildAgentFsRpcSubject(userId, agentId) {
 export function buildAgentNotesRpcSubject(userId, agentId) {
     return `doer.agent.notes.rpc.${sanitizeUserId(userId)}.${agentId.trim()}`;
 }
+export function buildAgentNotesAiRpcSubject(userId, agentId) {
+    return `doer.agent.notes.ai.rpc.${sanitizeUserId(userId)}.${agentId.trim()}`;
+}
 export function buildAgentDaemonRpcSubject(userId, agentId) {
     return `doer.agent.daemon.rpc.${sanitizeUserId(userId)}.${agentId.trim()}`;
 }

package/dist/agent.js

@@ -6,6 +6,7 @@ import { buildAgentSettingsEnvPatch, readAgentSettingsConfig, } from "./agent-se
 import { handleFsRpcMessage } from "./agent-fs-rpc.js";
 import { handleGitRpcMessage } from "./agent-git-rpc.js";
 import { handleNotesRpcMessage } from "./agent-notes-rpc.js";
+import { subscribeToNotesAiRpc } from "./agent-notes-ai-rpc.js";
 import { ensureBundledDoerSkills } from "./agent-bundled-skills.js";
 import { subscribeToCodexAppRpc } from "./agent-codex-app-rpc.js";
 import { createCodexAppServerManager } from "./codex-app-server-manager.js";
@@ -17,7 +18,7 @@ import { subscribeToSkillRpc } from "./agent-skill-rpc.js";
 import { subscribeToMaintenanceRpc } from "./agent-maintenance-rpc.js";
 import { subscribeToHttpProxyRpc } from "./agent-http-proxy-rpc.js";
 import { sendSignalToTaskProcess } from "./agent-task-execution.js";
-import { buildAgentCodexAppEventsSubject, buildAgentCodexAppRpcSubject, buildAgentDaemonRpcSubject, buildAgentFsRpcSubject, buildAgentGitRpcSubject, buildAgentHttpProxyRpcSubject, buildAgentMaintenanceRpcSubject, buildAgentNotesRpcSubject, buildAgentSettingsRpcSubject, buildAgentSkillRpcSubject, formatLocalTimestamp, parseArgs, resolveAgentVersion, resolveArgOrEnv, resolveContainerReachableServerBaseUrl, sanitizeUserId, sleep, } from "./agent-runtime-utils.js";
+import { buildAgentCodexAppEventsSubject, buildAgentCodexAppRpcSubject, buildAgentDaemonRpcSubject, buildAgentFsRpcSubject, buildAgentGitRpcSubject, buildAgentHttpProxyRpcSubject, buildAgentMaintenanceRpcSubject, buildAgentNotesRpcSubject, buildAgentNotesAiRpcSubject, buildAgentSettingsRpcSubject, buildAgentSkillRpcSubject, formatLocalTimestamp, parseArgs, resolveAgentVersion, resolveArgOrEnv, resolveContainerReachableServerBaseUrl, sanitizeUserId, sleep, } from "./agent-runtime-utils.js";
 import { createRuntimeEnvHelpers } from "./agent-runtime-env.js";
 import { createEventPersistenceHelpers, heartbeatAgentSession, postJson, } from "./agent-runtime-io.js";
 import { handleSettingsRpcMessage } from "./agent-settings-rpc.js";
@@ -131,6 +132,16 @@ function subscribeToNotesRpc(args) {
     });
     writeAgentInfo(`notes rpc subscribed subject=${subject}`);
 }
+function subscribeToNotesAiRpcSession(args) {
+    subscribeToNotesAiRpc({
+        nc: args.jetstream.nc,
+        subject: buildAgentNotesAiRpcSubject(args.userId, args.agentId),
+        manager: args.codexAppServerManager,
+        agentId: args.agentId,
+        onInfo: writeAgentInfo,
+        onError: writeAgentError,
+    });
+}
 function formatCodexAppNotificationParams(params) {
     if (params === undefined) {
         return "undefined";
@@ -290,6 +301,12 @@ async function main() {
                     userId,
                     agentId: initialAgentId,
                 });
+                subscribeToNotesAiRpcSession({
+                    jetstream,
+                    userId,
+                    agentId: initialAgentId,
+                    codexAppServerManager,
+                });
                 subscribeToDaemonRpc({
                     nc: jetstream.nc,
                     subject: buildAgentDaemonRpcSubject(userId, initialAgentId),

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

@@ -63,6 +63,7 @@ export function createCodexAppServerManager(args) {
     let client = null;
     let createPromise = null;
     let generation = 0;
+    const notificationListeners = new Set();
     const createClient = async () => {
         const settings = await args.readAgentSettingsConfig({ workspaceRoot: args.workspaceRoot });
         const appServerArgs = await buildCodexAppServerArgs({
@@ -89,7 +90,12 @@ export function createCodexAppServerManager(args) {
             args: appServerArgs,
             env,
             onLog: args.onLog,
-            onNotification: args.onNotification,
+            onNotification: (method, params) => {
+                for (const listener of notificationListeners) {
+                    listener(method, params);
+                }
+                args.onNotification?.(method, params);
+            },
         });
     };
     const getClient = async () => {
@@ -117,6 +123,12 @@ export function createCodexAppServerManager(args) {
         }
     };
     return {
+        onNotification(listener) {
+            notificationListeners.add(listener);
+            return () => {
+                notificationListeners.delete(listener);
+            };
+        },
         async request(method, params, timeoutMs) {
             const activeClient = await getClient();
             return await activeClient.request(method, params, timeoutMs);

package/package.json

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