@moxt-ai/mobius 0.0.197 → 0.0.198

package/dist/index.js

@@ -30271,6 +30271,73 @@ var sessionEventV2 = sqliteTable(
 // src/acp/session-event-store-v2.ts
 var HOT_EVENT_HIGH_WATER_MARK = 256;
 var HOT_EVENT_RETENTION = 128;
+var PositionedSessionEventV2 = class {
+  #event;
+  position;
+  constructor(event, position) {
+    this.#event = event;
+    this.position = position;
+  }
+  get event() {
+    return this.#event;
+  }
+  replaceEvent = (event) => {
+    this.#event = event;
+  };
+};
+var SessionEventsV2 = class {
+  hot = [];
+  #toolCallUpdateMap = /* @__PURE__ */ new Map();
+  sessionGenerationId;
+  nextPosition = 1;
+  constructor() {
+    this.sessionGenerationId = randomUUID();
+  }
+  getToolCallUpdate = (toolCallId) => this.#toolCallUpdateMap.get(toolCallId);
+  updateToolCallUpdate = (toolCallId, item) => {
+    const current = this.#toolCallUpdateMap.get(toolCallId);
+    if (current === void 0 || current.position !== item.position) {
+      return false;
+    }
+    current.replaceEvent(item.event);
+    return true;
+  };
+  append = (item) => {
+    this.hot.push(item);
+    const event = item.event;
+    if (event.type === "acp" && (event.payload.sessionUpdate === "tool_call" || event.payload.sessionUpdate === "tool_call_update")) {
+      this.#toolCallUpdateMap.set(event.payload.toolCallId, item);
+    }
+  };
+  removeHotHead = (count) => {
+    this.hot.splice(0, count);
+  };
+};
+function projectAppend(session, event, position) {
+  if (event.type !== "acp" || event.payload.sessionUpdate !== "tool_call_update") {
+    return { item: new PositionedSessionEventV2(event, position), kind: "append" };
+  }
+  const update = event.payload;
+  const previous = session.getToolCallUpdate(update.toolCallId);
+  const previousPayload = previous?.event.type === "acp" ? previous.event.payload : void 0;
+  const previousUpdate = previousPayload?.sessionUpdate === "tool_call" || previousPayload?.sessionUpdate === "tool_call_update" ? previousPayload : void 0;
+  const merged = {
+    ...previousUpdate,
+    ...update,
+    sessionUpdate: "tool_call_update",
+    toolCallId: update.toolCallId
+  };
+  const item = new PositionedSessionEventV2({ payload: merged, type: "acp" }, position);
+  return previousPayload?.sessionUpdate !== "tool_call_update" || previous === void 0 ? { item, kind: "append" } : {
+    item,
+    kind: "compact-and-append",
+    previous: new PositionedSessionEventV2(compactedToolCallUpdate(update.toolCallId), previous.position),
+    toolCallId: update.toolCallId
+  };
+}
+function compactedToolCallUpdate(toolCallId) {
+  return { payload: { sessionUpdate: "tool_call_update", toolCallId }, type: "acp" };
+}
 function eventPage(sessionGenerationId, eventCount, eventLimit, cursor, read) {
   const parsedCursor = cursor === null ? eventCount : Number(cursor);
   if (!Number.isSafeInteger(parsedCursor) || parsedCursor < 0 || parsedCursor > eventCount) {
@@ -30298,18 +30365,18 @@ function pageAcpSessionEventsV2(sessionGenerationId, events, eventLimit, cursor)
 var MemoryAcpSessionEventStoreV2 = class {
   #events = /* @__PURE__ */ new Map();
   #session = (sessionId) => {
-    const session = this.#events.get(sessionId) ?? {
-      hot: [],
-      nextPosition: 1,
-      sessionGenerationId: randomUUID()
-    };
+    const session = this.#events.get(sessionId) ?? new SessionEventsV2();
     this.#events.set(sessionId, session);
     return session;
   };
   append = (sessionId, event) => {
     const session = this.#session(sessionId);
     const position = session.nextPosition;
-    session.hot.push({ event, position });
+    const projected = projectAppend(session, event, position);
+    if (projected.kind === "compact-and-append") {
+      session.updateToolCallUpdate(projected.toolCallId, projected.previous);
+    }
+    session.append(projected.item);
     session.nextPosition += 1;
     return { position, sessionGenerationId: session.sessionGenerationId };
   };
@@ -30328,7 +30395,7 @@ var MemoryAcpSessionEventStoreV2 = class {
     this.#events.delete(sessionId);
   };
   reset = (sessionId) => {
-    this.#events.set(sessionId, { hot: [], nextPosition: 1, sessionGenerationId: randomUUID() });
+    this.#events.set(sessionId, new SessionEventsV2());
   };
 };
 var cachedEventRowSchema = external_exports.object({ eventJson: external_exports.string(), position: external_exports.number().int().positive() });
@@ -30363,11 +30430,7 @@ var CachedAcpSessionEventStoreV2 = class {
     }
   }
   #session = (sessionId) => {
-    const session = this.#sessions.get(sessionId) ?? {
-      hot: [],
-      nextPosition: 1,
-      sessionGenerationId: randomUUID()
-    };
+    const session = this.#sessions.get(sessionId) ?? new SessionEventsV2();
     this.#sessions.set(sessionId, session);
     return session;
   };
@@ -30377,7 +30440,11 @@ var CachedAcpSessionEventStoreV2 = class {
     }
     const session = this.#session(sessionId);
     const position = session.nextPosition;
-    session.hot.push({ event, position });
+    const projected = projectAppend(session, event, position);
+    if (projected.kind === "compact-and-append") {
+      this.#updateToolCallUpdate(sessionId, session, projected.toolCallId, projected.previous);
+    }
+    session.append(projected.item);
     session.nextPosition += 1;
     this.#sessions.set(sessionId, session);
     if (session.hot.length > HOT_EVENT_HIGH_WATER_MARK) {
@@ -30385,6 +30452,23 @@ var CachedAcpSessionEventStoreV2 = class {
     }
     return { position, sessionGenerationId: session.sessionGenerationId };
   };
+  #updateToolCallUpdate = (sessionId, session, toolCallId, item) => {
+    if (!session.updateToolCallUpdate(toolCallId, item) || !this.#isLocalDBAvailable) {
+      return;
+    }
+    try {
+      this.#database.update(sessionEventV2).set({ eventJson: JSON.stringify(item.event) }).where(
+        and(
+          eq(sessionEventV2.generationId, session.sessionGenerationId),
+          eq(sessionEventV2.sessionId, sessionId),
+          eq(sessionEventV2.position, item.position)
+        )
+      ).run();
+    } catch (cause) {
+      this.#isLocalDBAvailable = false;
+      console.warn("Mobius V2 Session event cache writes are unavailable; retaining events in memory", cause);
+    }
+  };
   #scheduleFlush = () => {
     if (!this.#isLocalDBAvailable || this.#flushSchedule.kind !== "idle") {
       return;
@@ -30431,7 +30515,10 @@ var CachedAcpSessionEventStoreV2 = class {
         }
       });
       for (const batch of batches) {
-        this.#sessions.get(batch.sessionId)?.hot.splice(0, batch.count);
+        const session = this.#sessions.get(batch.sessionId);
+        if (session !== void 0) {
+          session.removeHotHead(batch.count);
+        }
       }
     } catch (cause) {
       this.#isLocalDBAvailable = false;
@@ -30452,7 +30539,10 @@ var CachedAcpSessionEventStoreV2 = class {
         )
       ).orderBy(asc(sessionEventV2.position)).all().map((value) => {
         const row = cachedEventRowSchema.parse(value);
-        return { event: decodeCachedEvent(JSON.parse(row.eventJson)), position: row.position };
+        return new PositionedSessionEventV2(
+          decodeCachedEvent(JSON.parse(row.eventJson)),
+          row.position
+        );
       });
       const hot = (session?.hot ?? []).filter(
         ({ position }) => position >= startPosition && position <= endPosition
@@ -30486,7 +30576,7 @@ var CachedAcpSessionEventStoreV2 = class {
   reset = (sessionId) => {
     const previous = this.#sessions.get(sessionId);
     this.#deletePersisted(sessionId, previous?.sessionGenerationId);
-    this.#sessions.set(sessionId, { hot: [], nextPosition: 1, sessionGenerationId: randomUUID() });
+    this.#sessions.set(sessionId, new SessionEventsV2());
   };
   close = () => {
     if (this.#flushSchedule.kind === "closed") {
@@ -39732,7 +39822,7 @@ function send(socket, message) {
   }
   socket.send(encodeDaemonToServiceMessage(message));
 }
-async function settleAbandonedTurn(eventLog, operations, audit, cancellation) {
+async function settleAbandonedTurn(projection, operations, audit, cancellation) {
   const attemptId = operations.findUnsettledAttemptId(cancellation.commandId, cancellation.sessionId);
   if (attemptId === null) {
     console.warn("Mobius daemon ignored cancellation for an inactive turn");
@@ -39743,14 +39833,14 @@ async function settleAbandonedTurn(eventLog, operations, audit, cancellation) {
     event: "session_abandoned_turn_settled",
     sessionId: cancellation.sessionId
   });
-  await eventLog.failed(
+  await projection.failed(
     cancellation.sessionId,
     cancellation.commandId,
     "agent_execution_abandoned",
     "The local Agent execution was abandoned before it completed"
   );
   operations.transitionExecution(cancellation.commandId, "failed");
-  eventLog.publishTerminal(cancellation.sessionId, cancellation.commandId);
+  projection.publishTerminal(cancellation.sessionId, cancellation.commandId);
 }
 function operationErrorCode(error62) {
   if (error62 instanceof AcpExecutionError || error62 instanceof LocalAuthorizationError || error62 instanceof LocalAgentCatalogError || error62 instanceof PromptArtifactError) {
@@ -41900,7 +41990,7 @@ import { WebSocket as WebSocket5 } from "undici";
 // package.json
 var package_default = {
   name: "@moxt-ai/mobius",
-  version: "0.0.197",
+  version: "0.0.198",
   description: "Mobius CLI for pairing and running local AI agent services.",
   type: "module",
   bin: {
@@ -42977,7 +43067,7 @@ function omitAgentReasoning(events) {
   }
   return retained;
 }
-async function loadHistoryPage(sessionId, eventLimit, initialCursor, omitReasoning, queuedPromptRequests, load, eventLogV2) {
+async function loadHistoryPage(sessionId, eventLimit, initialCursor, omitReasoning, queuedPromptRequests, load, eventProjectionV2) {
   let cursor = initialCursor;
   let loaded = [];
   let sessionGenerationId = null;
@@ -42989,7 +43079,7 @@ async function loadHistoryPage(sessionId, eventLimit, initialCursor, omitReasoni
     }
     sessionGenerationId = replay.sessionGenerationId;
     const events2 = replay.events.map(
-      (event, index2) => eventLogV2.event(
+      (event, index2) => eventProjectionV2.event(
         sessionId,
         replay.sessionGenerationId,
         replay.startPosition + index2,
@@ -43025,7 +43115,7 @@ async function loadHistoryPage(sessionId, eventLimit, initialCursor, omitReasoni
     queuedPromptRequests
   };
 }
-async function executeSessionLiveHistoryV2PageLoad(socket, command, config2, directories, audit, diagnostics, sessions, nativeSessions, eventLogV2, signal) {
+async function executeSessionLiveHistoryV2PageLoad(socket, command, config2, directories, audit, diagnostics, sessions, nativeSessions, eventProjectionV2, signal) {
   let agentId;
   try {
     const [entry] = await nativeSessions.querySessions([command.sessionId], signal);
@@ -43047,7 +43137,7 @@ async function executeSessionLiveHistoryV2PageLoad(socket, command, config2, dir
       sessionId: command.sessionId,
       signal
     };
-    const recovery = eventLogV2.promptRequestRecovery(command.sessionId);
+    const recovery = eventProjectionV2.promptRequestRecovery(command.sessionId);
     const events = await loadHistoryPage(
       command.sessionId,
       command.eventLimit,
@@ -43055,7 +43145,7 @@ async function executeSessionLiveHistoryV2PageLoad(socket, command, config2, dir
       command.omit?.includes("agent-reasoning") === true,
       recovery.queuedPromptRequests,
       async (eventLimit, cursor) => await sessions.loadSessionEventsV2(loadOptions, eventLimit, cursor),
-      eventLogV2
+      eventProjectionV2
     );
     signal.throwIfAborted();
     audit.record({
@@ -43094,7 +43184,7 @@ async function executeSessionLiveHistoryV2PageLoad(socket, command, config2, dir
     }
   }
 }
-async function executeSessionPreviewHistoryPageLoad(socket, command, config2, directories, audit, diagnostics, sessions, eventLogV2, signal) {
+async function executeSessionPreviewHistoryPageLoad(socket, command, config2, directories, audit, diagnostics, sessions, eventProjectionV2, signal) {
   try {
     const resolved = await resolveSessionDirectories(
       directories,
@@ -43117,7 +43207,7 @@ async function executeSessionPreviewHistoryPageLoad(socket, command, config2, di
       command.omit?.includes("agent-reasoning") === true,
       [],
       async (eventLimit, cursor) => await sessions.previewNativeSessionEventsV2(loadOptions, command.sessionId, eventLimit, cursor),
-      eventLogV2
+      eventProjectionV2
     );
     signal.throwIfAborted();
     audit.record({
@@ -43360,7 +43450,7 @@ function daemonActivity(command, activity2) {
 }
 async function executePrompt({
   operations,
-  eventLogV2,
+  eventProjectionV2,
   command,
   config: config2,
   directories,
@@ -43440,7 +43530,7 @@ async function executePrompt({
       }
     }
     const stream = activateAttempt();
-    const lifecycleV2 = eventLogV2.started(
+    const lifecycleV2 = eventProjectionV2.started(
       command.sessionId,
       command.commandId,
       attemptId,
@@ -43495,7 +43585,7 @@ async function executePrompt({
       });
       stopReason = result.stopReason;
     }
-    await eventLogV2.completed(command.sessionId, command.commandId, stopReason);
+    await eventProjectionV2.completed(command.sessionId, command.commandId, stopReason);
     operations.transitionExecution(command.commandId, stopReason === "cancelled" ? "cancelled" : "succeeded");
     audit.record({
       commandId: command.commandId,
@@ -43504,7 +43594,7 @@ async function executePrompt({
     });
   } catch (error62) {
     if (signal.aborted && cancellationRequested()) {
-      await eventLogV2.completed(command.sessionId, command.commandId, "cancelled");
+      await eventProjectionV2.completed(command.sessionId, command.commandId, "cancelled");
       operations.transitionExecution(command.commandId, "cancelled");
       audit.record({
         commandId: command.commandId,
@@ -43521,7 +43611,7 @@ async function executePrompt({
     const code = operationErrorCode(error62);
     const failureCode = code === "session_operation_failed" ? "agent_execution_failed" : code;
     const failureMessage = code === "session_operation_failed" ? "The local agent could not complete the request" : operationErrorMessage(error62);
-    await eventLogV2.failed(command.sessionId, command.commandId, failureCode, failureMessage);
+    await eventProjectionV2.failed(command.sessionId, command.commandId, failureCode, failureMessage);
     operations.transitionExecution(command.commandId, "failed");
     console.error("Mobius daemon command failed", error62);
   }
@@ -43633,7 +43723,7 @@ function createDaemonCommandHandler({
   installations,
   nativeSessions,
   operations,
-  eventLogV2,
+  eventProjectionV2,
   externalContent,
   activeTurns,
   diagnostics,
@@ -43653,7 +43743,7 @@ function createDaemonCommandHandler({
     timer
   });
   const queueChanged = (sessionId) => {
-    void eventLogV2.queueChanged(sessionId).catch((error62) => {
+    void eventProjectionV2.queueChanged(sessionId).catch((error62) => {
       console.error("Could not record queue change", error62);
     });
   };
@@ -43713,7 +43803,7 @@ function createDaemonCommandHandler({
           diagnostics,
           sessions,
           nativeSessions,
-          eventLogV2,
+          eventProjectionV2,
           signal
         );
         return;
@@ -43727,7 +43817,7 @@ function createDaemonCommandHandler({
           audit,
           diagnostics,
           sessions,
-          eventLogV2,
+          eventProjectionV2,
           signal
         );
         return;
@@ -43770,9 +43860,11 @@ function createDaemonCommandHandler({
         const cancellation = message;
         const turn2 = activeTurns.get(cancellation.commandId);
         if (turn2 === void 0 || !turn2.matches(cancellation)) {
-          void settleAbandonedTurn(eventLogV2, operations, audit, cancellation).catch((error62) => {
-            console.error("Could not settle abandoned turn", error62);
-          });
+          void settleAbandonedTurn(eventProjectionV2, operations, audit, cancellation).catch(
+            (error62) => {
+              console.error("Could not settle abandoned turn", error62);
+            }
+          );
           return;
         }
         const cancellationState = turn2.requestCancellation();
@@ -43931,10 +44023,10 @@ function createDaemonCommandHandler({
         return;
       }
       const turn = activeTurns.start(command, receipt.attemptId);
-      eventLogV2.requested(command);
+      eventProjectionV2.requested(command);
       void executePrompt({
         operations,
-        eventLogV2,
+        eventProjectionV2,
         command,
         config: config2,
         directories,
@@ -43958,7 +44050,7 @@ function createDaemonCommandHandler({
         console.error("Mobius daemon turn failed", error62);
       }).finally(() => {
         activeTurns.finish(turn);
-        eventLogV2.publishTerminal(command.sessionId, command.commandId);
+        eventProjectionV2.publishTerminal(command.sessionId, command.commandId);
         if (command.disposition === SessionPromptDisposition.Queue) {
           queueChanged(command.sessionId);
         }
@@ -44200,7 +44292,7 @@ async function runRelayConnection({
   nativeSessions,
   operations,
   publisher,
-  eventLogV2,
+  eventProjectionV2,
   externalContent,
   activeTurns,
   connectionEpoch,
@@ -44222,7 +44314,7 @@ async function runRelayConnection({
     installations,
     nativeSessions,
     operations,
-    eventLogV2,
+    eventProjectionV2,
     externalContent,
     activeTurns,
     diagnostics,
@@ -44465,7 +44557,7 @@ var SystemDaemonTimer = class {
 };
 var systemDaemonTimer = new SystemDaemonTimer();
 
-// src/session-event-log-v2.ts
+// src/session-event-projection-v2.ts
 function promptContent(command) {
   const content = [];
   if (command.prompt.length > 0) {
@@ -44489,7 +44581,7 @@ function promptContent(command) {
   }
   return content;
 }
-function sessionEventV22(sessionGenerationId, sessionId, position, event, recordedAt) {
+function projectSessionEventV2(sessionGenerationId, sessionId, position, event, recordedAt) {
   return {
     eventId: `event-${sessionGenerationId}-${position.toString().padStart(16, "0")}`,
     ...event,
@@ -44500,7 +44592,7 @@ function sessionEventV22(sessionGenerationId, sessionId, position, event, record
     sessionId
   };
 }
-var DaemonSessionEventLogV2 = class {
+var DaemonSessionEventProjectionV2 = class {
   #publisher;
   #terminal = /* @__PURE__ */ new Map();
   #publications = /* @__PURE__ */ new Map();
@@ -44584,7 +44676,7 @@ var DaemonSessionEventLogV2 = class {
     }
     this.#queued.delete(commandId);
   };
-  event = (sessionId, sessionGenerationId, position, event, recordedAt) => sessionEventV22(sessionGenerationId, sessionId, position, event, recordedAt);
+  event = (sessionId, sessionGenerationId, position, event, recordedAt) => projectSessionEventV2(sessionGenerationId, sessionId, position, event, recordedAt);
   queueChanged = async (sessionId) => {
     await this.#recordLifecycle(sessionId, {
       type: "lifecycle-metadata",
@@ -44713,7 +44805,7 @@ async function runDaemon(config2, audit, signal, timer = systemDaemonTimer, opti
   await using externalContent = new LocalExternalContentStore(stateDirectory);
   const operations = new DaemonOperationState();
   const publisher = new DaemonSessionEventPublisher(timer);
-  const eventLogV2 = new DaemonSessionEventLogV2(
+  const eventProjectionV2 = new DaemonSessionEventProjectionV2(
     publisher,
     (sessionId, event) => agentRuntime.recordLifecycleEventV2(sessionId, event)
   );
@@ -44724,7 +44816,7 @@ async function runDaemon(config2, audit, signal, timer = systemDaemonTimer, opti
       if (event.kind === "session.info.updated") {
         publisher.publishInfo(event);
       }
-    }, eventLogV2.record),
+    }, eventProjectionV2.record),
     sessionStore,
     {
       access: (options2) => options2.agent.id === "codex" ? {
@@ -44849,7 +44941,7 @@ async function runDaemon(config2, audit, signal, timer = systemDaemonTimer, opti
           nativeSessions,
           operations,
           publisher,
-          eventLogV2,
+          eventProjectionV2,
           externalContent,
           activeTurns,
           connectionEpoch,