@moxt-ai/mobius 0.0.183 → 0.0.185

package/dist/runtime.js

@@ -27549,6 +27549,18 @@ function isProgressMessage(content) {
 // src/acp/agent-connection.ts
 import { spawn as spawn4 } from "node:child_process";
 import { ndJsonStream as ndJsonStream2, RequestError as RequestError3 } from "@agentclientprotocol/sdk";
+function requestErrorMessage(error62) {
+  const fallback = truncate(error62.message, 500);
+  if (error62.message !== "Internal error" || !isRecord4(error62.data)) {
+    return fallback;
+  }
+  const agentError = error62.data["error"];
+  if (!isRecord4(agentError)) {
+    return fallback;
+  }
+  const message = agentError["message"];
+  return typeof message === "string" && message.length > 0 ? truncate(message, 500) : fallback;
+}
 function readableWebStream(input2) {
   let streamOpen = true;
   return new ReadableStream({
@@ -27720,7 +27732,7 @@ var AgentConnection = class {
           );
         }
         if (error62 instanceof RequestError3) {
-          throw new AcpExecutionError(truncate(error62.message, 500), { cause: error62 }, "acp_agent_error");
+          throw new AcpExecutionError(requestErrorMessage(error62), { cause: error62 }, "acp_agent_error");
         }
         throw error62;
       }
@@ -34528,11 +34540,11 @@ var AgentSession = class _AgentSession {
     }
     throw new AcpExecutionError("ACP agent initialization failed");
   }
-  static start = async (options, getObserver, store, metrics, contentExternalizer) => await _AgentSession.#start(
+  static start = async (options, recovery, getObserver, store, metrics, contentExternalizer) => await _AgentSession.#start(
     options,
     getObserver,
     store,
-    async (runtime) => await runtime.initialize(options.signal, options.origin),
+    async (runtime) => await runtime.initialize(options.signal, recovery, options.origin),
     metrics,
     contentExternalizer
   );
@@ -34570,6 +34582,16 @@ var AgentSession = class _AgentSession {
     const history = await this.#completedHistory(signal, "ACP agent exited while loading history");
     return await embedLocalHistoryImages(await history.snapshot(), signal);
   };
+  ensureHistoryLoaded = async (signal) => {
+    if (!this.#capabilities.loadSession) {
+      throw new AcpExecutionError(
+        "This Agent restores context but does not provide message history.",
+        {},
+        "native_history_unsupported"
+      );
+    }
+    await this.#completedHistory(signal, "ACP agent exited while loading history");
+  };
   loadHistoryEventsV2 = async (eventLimit, cursor, signal) => {
     if (!this.#capabilities.loadSession) {
       throw new AcpExecutionError(
@@ -34742,7 +34764,7 @@ var AgentSession = class _AgentSession {
       128
     );
   }
-  initialize = async (signal, origin) => {
+  initialize = async (signal, recovery, origin) => {
     await this.#initializeAgent(signal);
     let stored = this.#metrics.measureSync(
       "session-state-read",
@@ -34811,7 +34833,19 @@ var AgentSession = class _AgentSession {
       this.#prompted = stored.session.prompted;
       this.#sessionTitle = stored.session.title;
       this.#restored = true;
-      if (this.#capabilities.resumeSession) {
+      if (recovery.kind === "history-required") {
+        if (!this.#capabilities.loadSession) {
+          throw new AcpExecutionError(
+            "This Agent restores context but does not provide message history.",
+            {},
+            "native_history_unsupported"
+          );
+        }
+        lifecycleResponse = await this.#metrics.measure(
+          "session-load",
+          async () => (await this.#loadSession(signal, "ACP agent exited while loading a session")).response
+        );
+      } else if (this.#capabilities.resumeSession) {
         lifecycleResponse = await this.#metrics.measure(
           "session-resume",
           async () => await this.race(
@@ -36429,12 +36463,13 @@ var AgentRuntimeManager = class {
     this.#executionProcesses.retain(options.sessionId, runtime);
     return runtime;
   }
-  async #startPreparation(options, metrics = unmeasuredOperationMetrics) {
+  async #startPreparation(options, recovery, metrics = unmeasuredOperationMetrics) {
     return await this.#executionProcesses.prepare(options.sessionId, async () => {
       return await this.#startRetainedSessionProcess(
         options,
         async () => await AgentSession.start(
           options.origin === void 0 && this.#sessionIdentity === "native" && isNativeChatSessionId(options.agent.id, options.sessionId) && this.#store.read(options.sessionId) instanceof MissingAcpStoredSession ? { ...options, origin: { kind: "import", nativeSessionId: options.sessionId } } : options,
+          recovery,
           () => this.#observer,
           this.#store,
           metrics,
@@ -36443,7 +36478,7 @@ var AgentRuntimeManager = class {
       );
     });
   }
-  async #replacePreparation(existing, options, metrics) {
+  async #replacePreparation(existing, options, recovery, metrics) {
     return await this.#executionProcesses.prepare(options.sessionId, async () => {
       await this.#retireSessionProcess(
         options.sessionId,
@@ -36455,6 +36490,7 @@ var AgentRuntimeManager = class {
         options,
         async () => await AgentSession.start(
           options,
+          recovery,
           () => this.#observer,
           this.#store,
           metrics,
@@ -36471,6 +36507,7 @@ var AgentRuntimeManager = class {
         options,
         async () => await AgentSession.start(
           options,
+          { kind: "interactive-only" },
           () => this.#observer,
           this.#store,
           unmeasuredOperationMetrics,
@@ -36514,42 +36551,58 @@ var AgentRuntimeManager = class {
       return runtime;
     });
   }
-  prepareSession = async (options, metrics = unmeasuredOperationMetrics) => this.#operations.run(options, async (options2) => {
-    const stored = metrics.measureSync("session-state-read", () => this.#store.read(options2.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");
-    }
-    const pending = this.#executionProcesses.pending(options2.sessionId);
-    if (pending !== void 0) {
-      const runtime2 = await metrics.measure(
-        "session-preparation-wait",
-        async () => await waitForSharedOperation(pending, options2.signal)
-      );
-      if (runtime2.belongsTo(options2.agent.id, options2.cwd, options2.additionalDirectories)) {
-        this.#executionProcesses.touch(options2.sessionId, runtime2);
-        return runtime2.prepared();
-      }
-      return await this.prepareSession(options2, metrics);
-    }
-    const existing = this.#executionProcesses.get(options2.sessionId);
-    if (existing !== void 0) {
-      if (existing.belongsTo(options2.agent.id, options2.cwd, options2.additionalDirectories)) {
-        this.#executionProcesses.touch(options2.sessionId, existing);
-        return existing.prepared();
+  async #prepareSession(options, recovery, metrics = unmeasuredOperationMetrics) {
+    return await this.#operations.run(options, async (options2) => {
+      const stored = metrics.measureSync("session-state-read", () => this.#store.read(options2.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 (!existing.canRebind()) {
-        throw new AcpExecutionError(
-          "The agent or workspace cannot change after a conversation has started",
-          {},
-          "session_identity_mismatch"
+      const pending = this.#executionProcesses.pending(options2.sessionId);
+      if (pending !== void 0) {
+        const runtime2 = await metrics.measure(
+          "session-preparation-wait",
+          async () => await waitForSharedOperation(pending, options2.signal)
         );
+        if (runtime2.belongsTo(options2.agent.id, options2.cwd, options2.additionalDirectories)) {
+          this.#executionProcesses.touch(options2.sessionId, runtime2);
+          if (recovery.kind === "history-required") {
+            await metrics.measure(
+              "session-load",
+              async () => await runtime2.ensureHistoryLoaded(options2.signal)
+            );
+          }
+          return runtime2.prepared();
+        }
+        return await this.#prepareSession(options2, recovery, metrics);
+      }
+      const existing = this.#executionProcesses.get(options2.sessionId);
+      if (existing !== void 0) {
+        if (existing.belongsTo(options2.agent.id, options2.cwd, options2.additionalDirectories)) {
+          this.#executionProcesses.touch(options2.sessionId, existing);
+          if (recovery.kind === "history-required") {
+            await metrics.measure(
+              "session-load",
+              async () => await existing.ensureHistoryLoaded(options2.signal)
+            );
+          }
+          return existing.prepared();
+        }
+        if (!existing.canRebind()) {
+          throw new AcpExecutionError(
+            "The agent or workspace cannot change after a conversation has started",
+            {},
+            "session_identity_mismatch"
+          );
+        }
+        const runtime2 = await this.#replacePreparation(existing, options2, recovery, metrics);
+        return runtime2.prepared();
       }
-      const runtime2 = await this.#replacePreparation(existing, options2, metrics);
-      return runtime2.prepared();
-    }
-    const runtime = await this.#startPreparation(options2, metrics);
-    return runtime.prepared();
-  });
+      const runtime = await this.#startPreparation(options2, recovery, metrics);
+      return runtime.prepared();
+    });
+  }
+  prepareSession = async (options, metrics = unmeasuredOperationMetrics) => await this.#prepareSession(options, { kind: "interactive-only" }, metrics);
+  restoreSession = async (options, metrics = unmeasuredOperationMetrics) => await this.#prepareSession(options, { kind: "history-required" }, metrics);
   /**
    * Opens a short-lived native ACP session only to read the local Agent's
    * authoritative settings. Its identity and store are private to this
@@ -36563,6 +36616,7 @@ var AgentRuntimeManager = class {
           ...options2,
           sessionId: `agent-settings-${crypto.randomUUID()}`
         },
+        { kind: "interactive-only" },
         () => this.#agentSettingsObserver,
         new MemoryAcpSessionStore(),
         unmeasuredOperationMetrics,
@@ -36600,7 +36654,7 @@ var AgentRuntimeManager = class {
       );
     }
     return await this.#executionProcesses.use(options2.sessionId, async () => {
-      const runtime = await this.#startPreparation(options2, metrics);
+      const runtime = await this.#startPreparation(options2, { kind: "interactive-only" }, metrics);
       try {
         return runtime.prepared();
       } finally {
@@ -36620,7 +36674,7 @@ var AgentRuntimeManager = class {
     }
     const existing = this.#executionProcesses.get(options2.sessionId);
     if (existing === void 0) {
-      return (await this.#startPreparation(options2)).prepared();
+      return (await this.#startPreparation(options2, { kind: "interactive-only" })).prepared();
     }
     if (!existing.belongsTo(options2.agent.id, options2.cwd, options2.additionalDirectories)) {
       throw new AcpExecutionError(
@@ -36805,7 +36859,7 @@ var AgentRuntimeManager = class {
     const temporaryOptions = { ...options2, sessionId: temporarySessionId };
     return await this.#executionProcesses.use(temporarySessionId, async () => {
       try {
-        const runtime = await this.#startPreparation(temporaryOptions);
+        const runtime = await this.#startPreparation(temporaryOptions, { kind: "interactive-only" });
         let adopted = false;
         try {
           const nativeSessionId = runtime.nativeSessionId();
@@ -36971,7 +37025,7 @@ var AgentRuntimeManager = class {
     return await this.#executionProcesses.use(options2.sessionId, async () => {
       this.#nativeOperations.add(key);
       try {
-        const runtime = await this.#startPreparation({ ...options2, origin });
+        const runtime = await this.#startPreparation({ ...options2, origin }, { kind: "interactive-only" });
         const openedKey = `${options2.agent.id}:${runtime.nativeSessionId()}`;
         this.#nativeOperations.add(openedKey);
         try {
@@ -41319,7 +41373,7 @@ async function executePrompt({
 }
 
 // src/daemon-session-commands.ts
-async function prepareSession(command, config2, directories, audit, sessions, metrics, signal) {
+async function prepareSession(command, recovery, config2, directories, audit, sessions, metrics, signal) {
   return await metrics.measure("prepare-total", async () => {
     const resolved = await metrics.measure(
       "workspace-resolve",
@@ -41339,7 +41393,7 @@ async function prepareSession(command, config2, directories, audit, sessions, me
       sessionId: command.sessionId,
       signal
     };
-    const prepared = command.transient === true ? await sessions.inspectSession(preparation, metrics) : await sessions.prepareSession(preparation, metrics);
+    const prepared = command.transient === true ? await sessions.inspectSession(preparation, metrics) : recovery.kind === "history-required" ? await sessions.restoreSession(preparation, metrics) : await sessions.prepareSession(preparation, metrics);
     const configuration = command.configuration;
     const configOptions = configuration === void 0 ? prepared.configOptions : await metrics.measure(
       "configuration",
@@ -41409,7 +41463,16 @@ async function executeWorkspaceList(socket, command, directories, audit, signal)
 async function executeSessionPrepare(socket, command, config2, directories, audit, sessions, diagnostics, signal) {
   const metrics = new AccumulatingOperationMetrics();
   try {
-    const readyEvent = await prepareSession(command, config2, directories, audit, sessions, metrics, signal);
+    const readyEvent = await prepareSession(
+      command,
+      { kind: "interactive-only" },
+      config2,
+      directories,
+      audit,
+      sessions,
+      metrics,
+      signal
+    );
     send(socket, {
       ...readyEvent,
       runtimeTimings: metrics.snapshot()
@@ -41458,6 +41521,7 @@ async function executeSessionRestore(socket, command, config2, directories, audi
         sessionId: command.sessionId,
         sessionState: "provisioned"
       },
+      { kind: "history-required" },
       config2,
       directories,
       audit,