mixdog 1.3.1 → 1.3.3

package/src/session-runtime/agent-profile-changes.mjs

@@ -14,6 +14,22 @@ export function subscribeAgentProfileChanges(listener) {
   return { unsubscribe: () => listeners.delete(listener) };
 }
 
+// A bot's saved model route: the hosts of its chats (the session service)
+// move them onto it from their next turn.
+const routeListeners = new Set();
+
+export function subscribeAgentRouteChanges(listener) {
+  routeListeners.add(listener);
+  return { unsubscribe: () => routeListeners.delete(listener) };
+}
+
+/** Settles once every host has taken the route; one failing host never fails the save. */
+export async function publishAgentRouteChange(agentId, route) {
+  await Promise.allSettled(
+    [...routeListeners].map((listener) => Promise.resolve().then(() => listener(agentId, route)))
+  );
+}
+
 /** Settles once every runtime has applied the edit; one failing runtime never fails the save. */
 export async function publishAgentProfileChange() {
   invalidateRoleInstructionsCache();

package/src/session-runtime/agent-room-delivery.mjs

@@ -6,6 +6,7 @@
  * message id, so a retried post adds nothing. A user row's files are taken in
  * here exactly as a chat prompt's are at submit (session-turns.mjs): the bytes
  * go to the attachment store once, and the row keeps their references.
+ * Posts into one log run one at a time, so no two posts overwrite each other.
  */
 import {
   normalizeRoomRow,
@@ -64,43 +65,60 @@ function speechWithArtifacts(row, roomId, loadSession, log) {
     const session = loadSession(from.sessionId);
     const messages = turnSlice(session?.messages, { since: Number(from.since) || 0 });
     const { files } = collectTurnArtifacts(messages, { cwd: session?.cwd, roots: sessionRoots(session) });
-    const stored = files.filter((file) => file.id);
-    if (!stored.length) return rest;
-    return {
-      ...rest,
-      parts: stored.map((file) => ({
-        type: file.kind === 'image' ? 'image' : file.kind === 'text' ? 'text' : 'file',
-        attachmentRef: file.id,
-        ...(file.kind === 'text' ? { textKind: 'file' } : {}),
-        mimeType: file.mimeType,
-        filename: file.name,
-        sizeBytes: file.size,
-      })),
-      attachments: artifactRecords(stored),
-    };
+    return { ...rest, ...storedFileFields(files) };
   } catch (error) {
     log(`the files of ${from.sessionId} could not be taken in: ${error?.message || error}`);
     return rest;
   }
 }
 
+/** A row's `{ parts, attachments }` for the stored files among `files`
+ *  (handoff-attachments.mjs collectTurnArtifacts); none when none is stored. */
+function storedFileFields(files) {
+  const stored = (Array.isArray(files) ? files : []).filter((file) => file?.id);
+  if (!stored.length) return {};
+  return {
+    parts: stored.map((file) => ({
+      type: file.kind === 'image' ? 'image' : file.kind === 'text' ? 'text' : 'file',
+      attachmentRef: file.id,
+      ...(file.kind === 'text' ? { textKind: 'file' } : {}),
+      mimeType: file.mimeType,
+      filename: file.name,
+      sizeBytes: file.size,
+    })),
+    attachments: artifactRecords(stored),
+  };
+}
+
 export function createAgentRoomDelivery({ loadSession, saveSession, live = agentHomeLiveSurface, log = () => {} }) {
-  /** Append `rows` to the log of `sessionId`; resolves `{ added, rows }`: how
-   *  many were new, and every row as stored (files as references, no bytes). */
-  async function append(sessionId, rows) {
-    const roomId = roomIdOfSession(sessionId);
-    if (!roomId) throw new TypeError('not a group-room session');
-    const kept = (
-      await Promise.all(
-        (Array.isArray(rows) ? rows : []).map((row) => storedRow(speechWithArtifacts(row, roomId, loadSession, log)))
-      )
-    ).map((row) => normalizeRoomRow(row));
-    const messages = kept.map((row) => roomRowMessage(row));
+  const tails = new Map(); // log session → its last post
+  /** Run `post` after every earlier post into `sessionId`. */
+  function serialized(sessionId, post) {
+    const run = (tails.get(sessionId) || Promise.resolve()).then(post);
+    const tail = run.catch(() => {});
+    tails.set(sessionId, tail);
+    void tail.then(() => {
+      if (tails.get(sessionId) === tail) tails.delete(sessionId);
+    });
+    return run;
+  }
+
+  /** Append the normalized rows `build(session)` gives to the stored log
+   *  `sessionId`; runs inside `serialized`, so no other post overlaps it. */
+  async function commit(sessionId, build) {
     const session = loadSession(sessionId);
     if (!session || session.closed === true) throw new Error(`session ${sessionId} is not available`);
     if (!Array.isArray(session.messages)) session.messages = [];
+    const kept = build(session);
+    const messages = kept.map((row) => roomRowMessage(row));
     const posted = new Set(session.messages.map((message) => message?.meta?.transcript?.messageId).filter(Boolean));
-    const fresh = messages.filter((message) => !posted.has(message.meta.transcript.messageId));
+    // An id seen earlier in this batch counts as posted too: one row, once.
+    const fresh = messages.filter((message) => {
+      const { messageId } = message.meta.transcript;
+      if (posted.has(messageId)) return false;
+      posted.add(messageId);
+      return true;
+    });
     if (!fresh.length) return { added: 0, rows: kept };
     session.messages.push(...fresh);
     session.updatedAt = Date.now();
@@ -115,19 +133,47 @@ export function createAgentRoomDelivery({ loadSession, saveSession, live = agent
     }
     return { added: fresh.length, rows: kept };
   }
+
+  /** Append `rows` to the log of `sessionId`; resolves `{ added, rows }`: how
+   *  many were new, and every row as stored (files as references, no bytes).
+   *  The post takes its place in the queue before the files are taken in, so
+   *  a later post cannot overtake it while they are. */
+  async function append(sessionId, rows) {
+    const roomId = roomIdOfSession(sessionId);
+    if (!roomId) throw new TypeError('not a group-room session');
+    return serialized(sessionId, async () => {
+      const prepared = (
+        await Promise.all(
+          (Array.isArray(rows) ? rows : []).map((row) => storedRow(speechWithArtifacts(row, roomId, loadSession, log)))
+        )
+      ).map((row) => normalizeRoomRow(row));
+      return commit(sessionId, () => prepared);
+    });
+  }
   return { append };
 }
 
 let processDelivery = null;
+/** The process's one delivery. The initialization promise is cached before it
+ *  is awaited, so concurrent first callers share one instance (one `tails`
+ *  queue per log); a failed import is not cached. */
+function roomDelivery() {
+  processDelivery ??= import('../runtime/agent/orchestrator/session/store.mjs')
+    .then(({ loadSession, saveSessionAsync }) =>
+      createAgentRoomDelivery({
+        loadSession,
+        saveSession: (session) => saveSessionAsync(session, { expectedGeneration: session.generation }),
+        log: (line) => process.stderr.write(`mixdog rooms: ${line}\n`),
+      })
+    )
+    .catch((error) => {
+      processDelivery = null;
+      throw error;
+    });
+  return processDelivery;
+}
+
 /** Daemon entry: post `rows` into the room log `sessionId`. */
 export async function appendRoomRows(sessionId, rows) {
-  if (!processDelivery) {
-    const { loadSession, saveSessionAsync } = await import('../runtime/agent/orchestrator/session/store.mjs');
-    processDelivery = createAgentRoomDelivery({
-      loadSession,
-      saveSession: (session) => saveSessionAsync(session, { expectedGeneration: session.generation }),
-      log: (line) => process.stderr.write(`mixdog rooms: ${line}\n`),
-    });
-  }
-  return processDelivery.append(sessionId, rows);
+  return (await roomDelivery()).append(sessionId, rows);
 }