@moxt-ai/mobius 0.0.5 → 0.0.7

package/dist/acp/session-manager.js

@@ -1,10 +1,12 @@
 import { spawn } from "node:child_process";
 import { methods, ndJsonStream, PROTOCOL_VERSION, } from "@agentclientprotocol/sdk";
-import { AGENT_CONTENT_KIND, MOBIUS_PROTOCOL_VERSION, SESSION_COMMANDS_UPDATED_KIND, SESSION_CONFIG_UPDATED_KIND, SESSION_ELICITATION_REQUESTED_KIND, SESSION_ELICITATION_RESOLVED_KIND, SESSION_INFO_UPDATED_KIND, SESSION_PERMISSION_REQUESTED_KIND, SESSION_PERMISSION_RESOLVED_KIND, SESSION_USAGE_UPDATED_KIND, } from "@moxt-ai/mobius-protocol";
+import { AGENT_CONTENT_KIND, decodeAgentPromptResponse, SESSION_COMMANDS_UPDATED_KIND, SESSION_CONFIG_UPDATED_KIND, SESSION_ELICITATION_REQUESTED_KIND, SESSION_ELICITATION_RESOLVED_KIND, SESSION_INFO_UPDATED_KIND, SESSION_PERMISSION_REQUESTED_KIND, SESSION_PERMISSION_RESOLVED_KIND, SESSION_USAGE_UPDATED_KIND, } from "@moxt-ai/mobius-protocol";
 import { revalidateExecutable, stopProcessTree, } from "../process/executable.js";
 import { AcpActivityTracker, isProgressMessage, normalizeContentBlock, } from "./activity.js";
 import { createAcpClient } from "./create-client.js";
-import { AcpStoredSession, FoundAcpStoredSession, MemoryAcpSessionStore, } from "./session-store.js";
+import { nativeSessionIdSchema, nativeSessionPageSchema, } from "./native-session.js";
+import { AcpHistoryReplay } from "./session-history.js";
+import { AcpStoredSession, DeletedAcpStoredSession, FoundAcpStoredSession, MemoryAcpSessionStore, } from "./session-store.js";
 const PROCESS_STOP_TIMEOUT_MILLISECONDS = 1_000;
 const SESSION_CONTROL_COMMAND_ID = "session-control";
 export class NullAcpSessionObserver {
@@ -274,6 +276,7 @@ function normalizeCapabilities(capabilities) {
         listSessions: session?.list != null,
         loadSession: capabilities.loadSession === true,
         resumeSession: session?.resume != null,
+        unstableForkSession: session?.fork != null,
     };
 }
 function elicitationFieldType(value) {
@@ -582,14 +585,17 @@ class AcpProcessSession {
         listSessions: false,
         loadSession: false,
         resumeSession: false,
+        unstableForkSession: false,
     };
     #commands = [];
     #configOptions = [];
     #nativeSessionId = "";
     #prompted = false;
-    #replaying = false;
+    #replay = {
+        kind: "idle",
+    };
     #restored = false;
-    #sessionTitle = "";
+    #sessionTitle = null;
     #sessionUpdatedAt = "";
     #turn = new IdleAcpTurn();
     #updateTail = Promise.resolve();
@@ -637,11 +643,12 @@ class AcpProcessSession {
         }
         const runtime = new AcpProcessSession(options.agent, options.cwd, options.additionalDirectories, options.sessionId, getObserver, store);
         try {
-            await runtime.initialize(options.signal);
+            await runtime.initialize(options.signal, options.origin);
             return runtime;
         }
         catch (error) {
             await runtime.closeProcess();
+            options.signal.throwIfAborted();
             if (error instanceof AcpExecutionError) {
                 throw error;
             }
@@ -655,7 +662,27 @@ class AcpProcessSession {
         arraysEqual(this.#additionalDirectories, additionalDirectories);
     canRebind = () => !this.#prompted && !this.#turn.running;
     prepared = () => new AcpPreparedSession(this.#agentName, this.#agentVersion, this.#capabilities, this.#commands, this.#configOptions, this.#restored);
-    initialize = async (signal) => {
+    loadHistory = async (signal) => {
+        if (!this.#capabilities.loadSession)
+            return { status: "unavailable" };
+        const history = new AcpHistoryReplay();
+        this.#replay = { kind: "capture", history };
+        try {
+            await this.race(this.#connection.agent.request(methods.agent.session.load, {
+                additionalDirectories: [...this.#additionalDirectories],
+                cwd: this.#cwd,
+                mcpServers: [],
+                sessionId: this.#nativeSessionId,
+            }, { cancellationSignal: signal }), "ACP agent exited while loading history", signal);
+            await this.#updateTail;
+            signal.throwIfAborted();
+            return history.snapshot();
+        }
+        finally {
+            this.#replay = { kind: "idle" };
+        }
+    };
+    initialize = async (signal, origin) => {
         const initialized = await this.race(this.#connection.agent.request(methods.agent.initialize, {
             clientCapabilities: {
                 elicitation: { form: {}, url: {} },
@@ -674,9 +701,31 @@ class AcpProcessSession {
             initialized.agentInfo?.name ??
             this.#agentId, 255);
         this.#agentVersion = truncate(initialized.agentInfo?.version ?? "", 128);
-        const stored = this.#store.read(this.#mobiusSessionId);
+        const stored = origin?.kind === "import"
+            ? new FoundAcpStoredSession(new AcpStoredSession(this.#mobiusSessionId, this.#agentId, nativeSessionIdSchema.parse(origin.nativeSessionId), this.#cwd, this.#additionalDirectories, true))
+            : this.#store.read(this.#mobiusSessionId);
+        if (stored instanceof DeletedAcpStoredSession)
+            throw new AcpExecutionError("The native Agent session was deleted. Start a new chat.", {}, "native_session_deleted");
         let lifecycleResponse;
-        if (stored instanceof FoundAcpStoredSession &&
+        if (origin?.kind === "fork") {
+            if (!this.#capabilities.unstableForkSession)
+                throw new AcpExecutionError("This Agent does not support session forking", {}, "native_session_unsupported");
+            const forked = await this.race(this.#connection.agent.request(methods.agent.session.fork, {
+                sessionId: nativeSessionIdSchema.parse(origin.nativeSessionId),
+                cwd: this.#cwd,
+                additionalDirectories: [...this.#additionalDirectories],
+                mcpServers: [],
+            }, { cancellationSignal: signal }), "ACP agent exited while forking a session", signal);
+            this.#nativeSessionId = nativeSessionIdSchema.parse(forked.sessionId);
+            if (this.#nativeSessionId === origin.nativeSessionId ||
+                this.#store.findNative(this.#agentId, this.#nativeSessionId).length > 0) {
+                throw new AcpExecutionError("The Agent did not create an independent fork", {}, "invalid_native_session_response");
+            }
+            this.#prompted = true;
+            this.#restored = true;
+            lifecycleResponse = forked;
+        }
+        else if (stored instanceof FoundAcpStoredSession &&
             stored.session.agentId === this.#agentId &&
             stored.session.cwd === this.#cwd &&
             arraysEqual(stored.session.additionalDirectories, this.#additionalDirectories)) {
@@ -692,7 +741,7 @@ class AcpProcessSession {
                 }, { cancellationSignal: signal }), "ACP agent exited while resuming a session", signal);
             }
             else if (this.#capabilities.loadSession) {
-                this.#replaying = true;
+                this.#replay = { kind: "discard" };
                 try {
                     lifecycleResponse = await this.race(this.#connection.agent.request(methods.agent.session.load, {
                         additionalDirectories: [...this.#additionalDirectories],
@@ -702,7 +751,8 @@ class AcpProcessSession {
                     }, { cancellationSignal: signal }), "ACP agent exited while loading a session", signal);
                 }
                 finally {
-                    this.#replaying = false;
+                    await this.#updateTail;
+                    this.#replay = { kind: "idle" };
                 }
             }
             else {
@@ -731,7 +781,23 @@ class AcpProcessSession {
         this.#configOptions = normalizeConfigOptions(lifecycleRecord["configOptions"], lifecycleRecord["modes"]);
         await this.#updateTail;
         signal.throwIfAborted();
+        this.#store.write(new AcpStoredSession(this.#mobiusSessionId, this.#agentId, this.#nativeSessionId, this.#cwd, this.#additionalDirectories, this.#prompted));
+    };
+    listNativeSessions = async (cursor, signal) => {
+        if (!this.#capabilities.listSessions)
+            throw new AcpExecutionError("This Agent does not support native session listing", {}, "native_session_unsupported");
+        const response = await this.race(this.#connection.agent.request(methods.agent.session.list, cursor === null ? {} : { cursor }, { cancellationSignal: signal }), "ACP agent exited while listing sessions", signal);
+        const decoded = nativeSessionPageSchema.safeParse(response);
+        if (!decoded.success)
+            throw new AcpExecutionError("The Agent returned an invalid native session list", { cause: decoded.error }, "invalid_native_session_response");
+        return decoded.data;
     };
+    deleteNativeSession = async (nativeSessionId, signal) => {
+        if (!this.#capabilities.deleteSession || !this.#capabilities.listSessions)
+            throw new AcpExecutionError("This Agent does not support native session deletion", {}, "native_session_unsupported");
+        await this.race(this.#connection.agent.request(methods.agent.session.delete, { sessionId: nativeSessionIdSchema.parse(nativeSessionId) }, { cancellationSignal: signal }), "ACP agent exited while deleting a session", signal);
+    };
+    nativeSessionId = () => this.#nativeSessionId;
     configure = async (options) => {
         const existing = this.#configOptions.find((option) => option.id === options.configId);
         if (existing === undefined || existing.type !== options.valueType) {
@@ -821,7 +887,24 @@ class AcpProcessSession {
             const response = await this.race(this.#connection.agent.request(methods.agent.session.prompt, { prompt, sessionId: this.#nativeSessionId }, { cancellationSignal: options.signal }), "ACP agent exited during a prompt", options.signal);
             await this.#updateTail;
             await running.activities.finish();
-            return { stopReason: response.stopReason };
+            let result;
+            try {
+                result = decodeAgentPromptResponse(response);
+            }
+            catch (cause) {
+                throw new AcpExecutionError("ACP agent returned an invalid prompt response", { cause }, "acp_invalid_prompt_response");
+            }
+            if (result.usage != null || result._meta?.quota !== undefined) {
+                await this.#getObserver().onUsage({
+                    _meta: result._meta ?? null,
+                    commandId: options.commandId,
+                    kind: SESSION_USAGE_UPDATED_KIND,
+                    sessionId: this.#mobiusSessionId,
+                    source: "prompt",
+                    usage: result.usage ?? null,
+                });
+            }
+            return result;
         }
         catch (error) {
             await running.activities.finish();
@@ -866,7 +949,6 @@ class AcpProcessSession {
             kind: SESSION_PERMISSION_RESOLVED_KIND,
             optionId: options.outcome === "selected" ? options.optionId : "",
             outcome: options.outcome,
-            protocolVersion: MOBIUS_PROTOCOL_VERSION,
             sessionId: this.#mobiusSessionId,
         });
     };
@@ -901,7 +983,6 @@ class AcpProcessSession {
             action: options.action,
             interactionId: options.interactionId,
             kind: SESSION_ELICITATION_RESOLVED_KIND,
-            protocolVersion: MOBIUS_PROTOCOL_VERSION,
             sessionId: this.#mobiusSessionId,
         });
     };
@@ -930,7 +1011,6 @@ class AcpProcessSession {
                 interactionId,
                 kind: SESSION_PERMISSION_REQUESTED_KIND,
                 options,
-                protocolVersion: MOBIUS_PROTOCOL_VERSION,
                 sessionId: this.#mobiusSessionId,
                 title: truncate(request.toolCall.title ?? "Permission required", 500),
                 toolCallId: truncate(request.toolCall.toolCallId, 255),
@@ -975,7 +1055,6 @@ class AcpProcessSession {
                 kind: SESSION_ELICITATION_REQUESTED_KIND,
                 message: truncate(request.message, 2_000),
                 mode: request.mode,
-                protocolVersion: MOBIUS_PROTOCOL_VERSION,
                 sessionId: this.#mobiusSessionId,
                 url: request.mode === "url" &&
                     typeof Reflect.get(request, "url") === "string"
@@ -999,7 +1078,6 @@ class AcpProcessSession {
             action: "complete",
             interactionId,
             kind: SESSION_ELICITATION_RESOLVED_KIND,
-            protocolVersion: MOBIUS_PROTOCOL_VERSION,
             sessionId: this.#mobiusSessionId,
         });
     };
@@ -1010,7 +1088,9 @@ class AcpProcessSession {
     processUpdate = async (notification) => {
         this.assertNativeSession(notification.sessionId);
         const update = notification.update;
-        if (this.#replaying &&
+        if (this.#replay.kind === "capture")
+            this.#replay.history.record(update);
+        if (this.#replay.kind !== "idle" &&
             (update.sessionUpdate === "user_message_chunk" ||
                 update.sessionUpdate === "agent_message_chunk" ||
                 update.sessionUpdate === "agent_thought_chunk" ||
@@ -1039,7 +1119,6 @@ class AcpProcessSession {
                     contentId: `content-${crypto.randomUUID()}`,
                     kind: AGENT_CONTENT_KIND,
                     messageId: truncate(update.messageId ?? "", 255),
-                    protocolVersion: MOBIUS_PROTOCOL_VERSION,
                     sessionId: this.#mobiusSessionId,
                 });
             }
@@ -1084,7 +1163,6 @@ class AcpProcessSession {
             await this.#getObserver().onCommands({
                 commands,
                 kind: SESSION_COMMANDS_UPDATED_KIND,
-                protocolVersion: MOBIUS_PROTOCOL_VERSION,
                 sessionId: this.#mobiusSessionId,
             });
             return;
@@ -1110,7 +1188,6 @@ class AcpProcessSession {
             }
             await this.#getObserver().onInfo({
                 kind: SESSION_INFO_UPDATED_KIND,
-                protocolVersion: MOBIUS_PROTOCOL_VERSION,
                 sessionId: this.#mobiusSessionId,
                 title: this.#sessionTitle,
                 updatedAt: this.#sessionUpdatedAt,
@@ -1123,9 +1200,9 @@ class AcpProcessSession {
                 costCurrency: truncate(update.cost?.currency ?? "", 16),
                 hasCost: update.cost !== undefined && update.cost !== null,
                 kind: SESSION_USAGE_UPDATED_KIND,
-                protocolVersion: MOBIUS_PROTOCOL_VERSION,
                 sessionId: this.#mobiusSessionId,
                 size: Math.max(0, Math.trunc(update.size)),
+                source: "context",
                 used: Math.max(0, Math.trunc(update.used)),
             });
         }
@@ -1182,7 +1259,6 @@ class AcpProcessSession {
         await this.#getObserver().onConfig({
             configOptions: this.#configOptions,
             kind: SESSION_CONFIG_UPDATED_KIND,
-            protocolVersion: MOBIUS_PROTOCOL_VERSION,
             requestId: `agent-update-${crypto.randomUUID()}`,
             sessionId: this.#mobiusSessionId,
         });
@@ -1198,7 +1274,6 @@ class AcpProcessSession {
             kind: SESSION_PERMISSION_RESOLVED_KIND,
             optionId: "",
             outcome: "cancelled",
-            protocolVersion: MOBIUS_PROTOCOL_VERSION,
             sessionId: this.#mobiusSessionId,
         });
     };
@@ -1212,7 +1287,6 @@ class AcpProcessSession {
             action: "cancel",
             interactionId,
             kind: SESSION_ELICITATION_RESOLVED_KIND,
-            protocolVersion: MOBIUS_PROTOCOL_VERSION,
             sessionId: this.#mobiusSessionId,
         });
     };
@@ -1232,13 +1306,13 @@ class AcpProcessSession {
                 action: "cancel",
                 interactionId,
                 kind: SESSION_ELICITATION_RESOLVED_KIND,
-                protocolVersion: MOBIUS_PROTOCOL_VERSION,
                 sessionId: this.#mobiusSessionId,
             });
         }
     };
 }
 export class AcpSessionManager {
+    #nativeOperations = new Set();
     #activeSessionIds = new Set();
     #cancellationRequests = new Set();
     #preparing = new Map();
@@ -1284,6 +1358,12 @@ export class AcpSessionManager {
         return await operation;
     }
     prepareSession = async (options) => {
+        const stored = this.#store.read(options.sessionId);
+        if (stored instanceof DeletedAcpStoredSession)
+            throw new AcpExecutionError("The native Agent session was deleted. Start a new chat.", {}, "native_session_deleted");
+        if (stored instanceof FoundAcpStoredSession &&
+            this.#nativeOperations.has(`${stored.session.agentId}:${stored.session.nativeSessionId}`))
+            throw new AcpExecutionError("The native session is being managed", {}, "session_busy");
         const pending = this.#preparing.get(options.sessionId);
         if (pending !== undefined) {
             const runtime = await pending;
@@ -1318,6 +1398,11 @@ export class AcpSessionManager {
         }
     };
     runPrompt = async (options) => {
+        const stored = this.#store.read(options.sessionId);
+        if (stored instanceof FoundAcpStoredSession &&
+            this.#nativeOperations.has(`${stored.session.agentId}:${stored.session.nativeSessionId}`)) {
+            throw new AcpExecutionError("The native session is being managed", {}, "session_busy");
+        }
         if (this.#activeSessionIds.has(options.sessionId)) {
             throw new AcpExecutionError("Another prompt is already running in this conversation", {}, "session_busy");
         }
@@ -1327,6 +1412,8 @@ export class AcpSessionManager {
                 return { stopReason: "cancelled" };
             }
             const runtime = await this.ensureSession(options);
+            if (this.#nativeOperations.has(`${options.agent.id}:${runtime.nativeSessionId()}`))
+                throw new AcpExecutionError("The native session is being managed", {}, "session_busy");
             if (this.#cancellationRequests.has(options.sessionId)) {
                 return { stopReason: "cancelled" };
             }
@@ -1384,5 +1471,103 @@ export class AcpSessionManager {
         }
         return started;
     };
+    listNativeSessions = async (options, cursor) => await (await this.ensureSession(options)).listNativeSessions(cursor, options.signal);
+    openNativeSession = async (options, origin) => {
+        const key = `${options.agent.id}:${origin.nativeSessionId}`;
+        if (this.#nativeOperations.has(key))
+            throw new AcpExecutionError("The native session is being managed", {}, "session_busy");
+        const linked = this.#store.findNative(options.agent.id, origin.nativeSessionId);
+        if (linked.some((entry) => this.#activeSessionIds.has(entry.sessionId) ||
+            this.#preparing.has(entry.sessionId)))
+            throw new AcpExecutionError("Wait for the native session's running operation to finish", {}, "session_busy");
+        const existing = linked[0];
+        if (origin.kind === "import" && existing !== undefined) {
+            const runtime = await this.ensureSession({
+                ...options,
+                sessionId: existing.sessionId,
+            });
+            if (this.#activeSessionIds.has(existing.sessionId) ||
+                this.#nativeOperations.has(key))
+                throw new AcpExecutionError("Wait for the native session's running operation to finish", {}, "session_busy");
+            this.#nativeOperations.add(key);
+            try {
+                const history = await runtime.loadHistory(options.signal);
+                return {
+                    prepared: runtime.prepared(),
+                    sessionId: existing.sessionId,
+                    history,
+                };
+            }
+            catch (error) {
+                this.#sessions.delete(existing.sessionId);
+                await runtime.closeProcess();
+                throw error;
+            }
+            finally {
+                this.#nativeOperations.delete(key);
+            }
+        }
+        if (this.#sessions.has(options.sessionId) ||
+            this.#preparing.has(options.sessionId) ||
+            this.#store.read(options.sessionId) instanceof FoundAcpStoredSession ||
+            this.#store.read(options.sessionId) instanceof DeletedAcpStoredSession)
+            throw new AcpExecutionError("The destination conversation already exists", {}, "session_identity_mismatch");
+        this.#nativeOperations.add(key);
+        try {
+            const runtime = await this.#startPreparation({ ...options, origin });
+            const openedKey = `${options.agent.id}:${runtime.nativeSessionId()}`;
+            this.#nativeOperations.add(openedKey);
+            try {
+                const history = await runtime.loadHistory(options.signal);
+                return {
+                    sessionId: options.sessionId,
+                    prepared: runtime.prepared(),
+                    history,
+                };
+            }
+            catch (error) {
+                this.#sessions.delete(options.sessionId);
+                this.#store.remove(options.sessionId);
+                await runtime.closeProcess();
+                throw error;
+            }
+            finally {
+                this.#nativeOperations.delete(openedKey);
+            }
+        }
+        finally {
+            this.#nativeOperations.delete(key);
+        }
+    };
+    deleteNativeSession = async (options, nativeSessionId) => {
+        const runtime = await this.ensureSession(options);
+        const key = `${options.agent.id}:${nativeSessionId}`;
+        const linked = this.#store.findNative(options.agent.id, nativeSessionId);
+        if (this.#nativeOperations.has(key) ||
+            linked.some((entry) => this.#activeSessionIds.has(entry.sessionId) ||
+                this.#preparing.has(entry.sessionId)))
+            throw new AcpExecutionError("Wait for the native session's running operation to finish", {}, "session_busy");
+        this.#nativeOperations.add(key);
+        try {
+            for (const entry of linked) {
+                const active = this.#sessions.get(entry.sessionId);
+                if (active !== undefined && active !== runtime) {
+                    this.#sessions.delete(entry.sessionId);
+                    await active.close();
+                }
+            }
+            options.signal.throwIfAborted();
+            await runtime.deleteNativeSession(nativeSessionId, options.signal);
+            const deleted = this.#store.markDeleted(options.agent.id, nativeSessionId);
+            if (runtime.nativeSessionId() === nativeSessionId) {
+                this.#sessions.delete(options.sessionId);
+                await runtime.close();
+            }
+            return deleted;
+        }
+        finally {
+            this.#nativeOperations.delete(key);
+        }
+    };
 }
 //# sourceMappingURL=session-manager.js.map