mixdog 1.3.3 → 1.3.5

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

@@ -1,8 +1,9 @@
 /**
  * Rows posted into an agent's home thread (`sess_home_<owner>`) from outside
  * its turns: held requests of unattended runs, reports of task sessions the
- * agent created, and routine results left by runs from before routines ran as
- * turns in the thread itself (routine-home-turn.mjs).
+ * agent created, the agent's own reply of a turn it ran in a hidden session
+ * (Mixy's heartbeat), and routine results left by runs from before routines
+ * ran as turns in the thread itself (routine-home-turn.mjs).
  *
  * Delivery is durable. The finished run is first ENQUEUED in a persisted
  * per-home queue (`routine-results.json`), keyed by the run id, so a retried
@@ -67,6 +68,12 @@ import {
 /** A queued item's stored message and live notice: a routine result, or a
  *  held request of an unattended run (session-runtime/held-requests.mjs). */
 function deliveredRow(item, messageId) {
+  // The agent's own words from a turn it ran elsewhere (mixy-heartbeat.mjs):
+  // one ordinary reply of the agent in its thread.
+  if (item.kind === 'agent-message') {
+    const message = { role: 'assistant', content: item.text, meta: { transcript: { at: item.at, messageId } } };
+    return { message, notice: { text: item.text, tone: 'info', assistant: true } };
+  }
   if (item.kind === 'held-request') {
     const message = heldRequestMessage({ ...item.held, at: item.at, messageId });
     return { message, notice: heldRequestNotice(message) };
@@ -124,9 +131,11 @@ export function scheduleOwnerAgentId(schedule) {
 }
 
 let liveSurface = null;
-/** `{ busy(sessionId), notice(sessionId, notice), wake(sessionId, prompt, { id }),
- *  submit(sessionId, prompt, options), abort(sessionId) }` from the session
- *  service; `wake` starts one hidden turn with submission `id` (resolves
+/** `{ busy(sessionId), notice(sessionId, notice), react(sessionId, messageId,
+ *  reactions), wake(sessionId, prompt, { id }), submit(sessionId, prompt,
+ *  options), abort(sessionId) }` from the session service; `react` shows a
+ *  message's new reactions in the runtime hosting it (message-reactions.mjs),
+ *  `wake` starts one hidden turn with submission `id` (resolves
  *  false when it was refused, else `{ settled }`: a promise of the turn's end
  *  status, 'done' when it finished), `submit` queues a routine turn
  *  (resolves whether it was accepted), `abort` stops the running turn. */
@@ -413,9 +422,9 @@ export function createRoutineResultQueue(
     async omitted(homeId) {
       return (await read()).omitted[homeId] || null;
     },
-    /** Queue `item` for `homeId`; `unwatch` drops that watch in the same write,
-     *  also when the item was queued or posted before. */
-    async add(homeId, item, { unwatch = '' } = {}) {
+    /** Queue `item` for `homeId`; `unwatch` (run ids) drops those watches in the
+     *  same write, also when the item was queued or posted before. */
+    async add(homeId, item, { unwatch = [] } = {}) {
       await update((doc) => {
         let next = null;
         if (item.roundTrip !== true) next = appended(doc, homeId, [item]);
@@ -434,9 +443,10 @@ export function createRoutineResultQueue(
             next = { ...next, rounds: { ...doc.rounds, [homeId]: counted } };
           }
         }
-        if (!unwatch || !doc.watches[unwatch]) return next ?? undefined;
+        const dropped = unwatch.filter((runId) => doc.watches[runId]);
+        if (!dropped.length) return next ?? undefined;
         const watches = { ...doc.watches };
-        delete watches[unwatch];
+        for (const runId of dropped) delete watches[runId];
         return { ...(next || doc), watches };
       });
     },
@@ -585,7 +595,19 @@ function homeProvenDeleted(homeId, agentPresence, roomPresence) {
 }
 
 /** The queued item of one task report (enqueueTask). */
-function taskReportItem({ runId, taskSessionId, title, status, text = '', target, files = [], omitted = 0, hop = 0 }) {
+function taskReportItem({
+  runId,
+  taskSessionId,
+  title,
+  status,
+  text = '',
+  target,
+  files = [],
+  omitted = 0,
+  hop = 0,
+  watchId = '',
+  watchIds = [],
+}) {
   // The model-facing reply keeps its lines up to REPLY_LIMIT; the row's
   // one-line summary is derived from it (agentTaskMessage).
   const reply = boundedReply(text);
@@ -601,6 +623,11 @@ function taskReportItem({ runId, taskSessionId, title, status, text = '', target
     ...(reply.chars > reply.text.length ? { textChars: reply.chars } : {}),
     // Any session other than a task session the agent created.
     ...(target === 'session' ? { target } : {}),
+    // The send this report ends (the `sendId` the send's result named).
+    ...(watchId ? { sendId: String(watchId) } : {}),
+    // Every send this one turn answered (sends folded into a running turn
+    // report once); `sendId` is the first of them.
+    ...(watchIds.length > 1 ? { sendIds: watchIds.map(String) } : {}),
     // The files the turn produced (handoff-attachments.mjs collectTurnArtifacts).
     ...(Array.isArray(files) && files.length ? { files, ...(omitted > 0 ? { omitted } : {}) } : {}),
     roundTrip: status !== 'started' && status !== 'blocked',
@@ -997,11 +1024,11 @@ export function createAgentHomeDelivery({
    *  create) for its home thread, then start draining it. `status` 'started'
    *  and 'blocked' only post a line; a turn's end also wakes the agent. */
   async function enqueueTask(agentId, report) {
-    const { runId, taskSessionId, watchId = '', from = '' } = report;
+    const { runId, taskSessionId, watchId = '', watchIds = [], from = '' } = report;
     const homeId = agentHomeSessionId(agentId) || agentHomeSessionId(MIXY_AGENT_ID);
     if (!runId || !taskSessionId) throw new Error('task report: runId and taskSessionId required');
     const item = taskReportItem(report);
-    const unwatch = watchId ? String(watchId) : '';
+    const unwatch = [...new Set([watchId, ...watchIds].filter(Boolean).map(String))];
     // A room member's own work reports to its member session, never its home.
     const target = roomMemberOfSession(from)?.agentId === agentId ? from : homeId;
     await queue.add(target, item, { unwatch });
@@ -1009,6 +1036,17 @@ export function createAgentHomeDelivery({
     return target;
   }
 
+  /** Persist `text`, the agent's own reply from turn `runId` it ran outside
+   *  its thread, for `agentId`'s home thread, then start draining it. It posts
+   *  once, as the agent's message; no turn follows. */
+  async function enqueueMessage(agentId, { runId, text }) {
+    const homeId = agentHomeSessionId(agentId) || agentHomeSessionId(MIXY_AGENT_ID);
+    if (!runId || !String(text || '').trim()) throw new Error('agent message: runId and text required');
+    await queue.add(homeId, { runId: String(runId), kind: 'agent-message', text: String(text).trim(), at: Date.now() });
+    void drain(homeId);
+    return homeId;
+  }
+
   /** Show `run`'s live-only row (routineRunNotice: `running`, or a result whose
    *  delivery failed) in `row`'s owner home when it is open and idle. Nothing
    *  is stored and no turn or unread mark follows; the posted result (same
@@ -1054,6 +1092,7 @@ export function createAgentHomeDelivery({
     enqueue,
     enqueueHeld,
     enqueueTask,
+    enqueueMessage,
     announce,
     drain,
     recover,
@@ -1128,6 +1167,11 @@ export async function deliverHeldRequest(agentId, held) {
   return (await processDelivery()).enqueueHeld(agentId, held);
 }
 
+/** Queue the agent's own reply of a turn it ran outside its home thread. */
+export async function deliverAgentMessage(agentId, message) {
+  return (await processDelivery()).enqueueMessage(agentId, message);
+}
+
 /** Queue one report of a task session for `agentId`'s home thread. */
 export async function deliverAgentTask(agentId, report) {
   return (await processDelivery()).enqueueTask(agentId, report);

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

@@ -15,6 +15,7 @@ import {
   roomRowItem,
   roomRowMessage,
 } from '../runtime/agent/orchestrator/session/agent-room.mjs';
+import { reactInSession } from '../runtime/agent/orchestrator/session/message-reactions.mjs';
 import { artifactRecords } from '../runtime/shared/handoff-artifacts.mjs';
 import { collectTurnArtifacts, sessionRoots, turnSlice } from './handoff-attachments.mjs';
 import {
@@ -150,7 +151,28 @@ export function createAgentRoomDelivery({ loadSession, saveSession, live = agent
       return commit(sessionId, () => prepared);
     });
   }
-  return { append };
+
+  /** A member's reaction (`change`: message-reactions.mjs reactToMessage's,
+   *  members never repeating one another's emoji) on a user row of the log
+   *  `sessionId`, in line with the posts; a room open in a window shows it at
+   *  once. Resolves reactToMessage's result. */
+  async function react(sessionId, change) {
+    if (!roomIdOfSession(sessionId)) throw new TypeError('not a group-room session');
+    return serialized(sessionId, async () => {
+      const session = loadSession(sessionId);
+      if (!session || session.closed === true) throw new Error(`session ${sessionId} is not available`);
+      const result = reactInSession(session, { ...change, othersKeep: true });
+      if (!result.changed) return result;
+      await saveSession(session);
+      try {
+        live()?.react?.(sessionId, result.messageId, result.reactions);
+      } catch (error) {
+        log(`live reaction in ${sessionId} failed: ${error?.message || error}`);
+      }
+      return result;
+    });
+  }
+  return { append, react };
 }
 
 let processDelivery = null;
@@ -177,3 +199,8 @@ function roomDelivery() {
 export async function appendRoomRows(sessionId, rows) {
   return (await roomDelivery()).append(sessionId, rows);
 }
+
+/** Daemon entry: a member's reaction on a user row of the room log `sessionId`. */
+export async function reactInRoom(sessionId, change) {
+  return (await roomDelivery()).react(sessionId, change);
+}