@adecore/agents 0.48.0 → 0.48.2

package/dist/chat/chat-session.js

@@ -22,6 +22,10 @@ function continuedNoteId(turnId) {
 function newId(prefix) {
     return `${prefix}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
 }
+/* The note of what the agent heard in front of a prompt, which a person reads in the turn it opened. */
+function saidNote(turnId, now, text) {
+    return { id: newId('note'), kind: 'note', createdAt: now, turnId, level: 'info', text, said: true };
+}
 /*
  * Item and request ids carry the generation of the CLI that made them, and a restart of the host
  * must not hand out one a stored thread already holds. Starting from the clock puts every run above
@@ -834,7 +838,7 @@ export class ChatSession {
         const context = this.contextNote(words.prompt);
         const preamble = [words.preamble, context.preamble].filter(Boolean).join('\n\n') || null;
         if (context.note) {
-            this.emit([this.thread.upsert({ id: newId('note'), kind: 'note', createdAt: now, turnId, level: 'info', text: context.note })]);
+            this.emit([this.thread.upsert(saidNote(turnId, now, context.note))]);
         }
         const input = { promptId: randomUUID(), text: words.prompt, preamble, attachments: [], mentions: [], skills: [] };
         this.submission = { turnId, input };
@@ -900,7 +904,7 @@ export class ChatSession {
             ...(wake.note === undefined
                 ? []
                 : [this.thread.upsert({ id: newId('note'), kind: 'note', createdAt: now, turnId, level: 'info', text: wake.note })]),
-            ...(note === null ? [] : [this.thread.upsert({ id: newId('note'), kind: 'note', createdAt: now, turnId, level: 'info', text: note })]),
+            ...(note === null ? [] : [this.thread.upsert(saidNote(turnId, now, note))]),
             this.thread.patchInfo({ status: this.thread.statusFor(turnId), activeTurnId: turnId })
         ]);
         this.options.persist();
@@ -1383,7 +1387,7 @@ export class ChatSession {
         const now = Date.now();
         const events = [this.thread.upsert({ id: turnId, kind: 'turn', createdAt: now, turnId, state: 'running', origin: 'user', endedAt: null, costUsd: 0 })];
         if (note !== null) {
-            events.push(this.thread.upsert({ id: newId('note'), kind: 'note', createdAt: now, turnId, level: 'info', text: note }));
+            events.push(this.thread.upsert(saidNote(turnId, now, note)));
         }
         if (text !== null) {
             const mentions = extras.mentions?.length ? extras.mentions : undefined;

package/dist/messages/deliver-notice.d.ts

@@ -9,13 +9,13 @@ export interface MessageWords {
 }
 export interface ChatNoticeTargets {
     chat(id: string): Promise<'idle' | 'running' | 'none'>;
-    fromMessage(id: string): boolean;
+    wokenBy(id: string): readonly string[];
 }
 export interface ChatDelivery {
     outcome: 'wake' | 'no-chat' | 'in-turn' | 'from-message';
     waiting: number;
 }
-export declare function turnFromMessage(items: readonly ChatItem[], activeTurnId: string | null): boolean;
+export declare function turnWokenBy(items: readonly ChatItem[], activeTurnId: string | null): readonly string[];
 export declare function chatNoticeTargets(chats: Pick<ChatCore, 'get' | 'hasStored'>): ChatNoticeTargets;
 export declare function deliverToChat(store: Pick<NoticeStore, 'put'>, targets: ChatNoticeTargets, notice: Omit<Notice, 'createdAt'>): Promise<ChatDelivery>;
 export interface NoticeChat {

package/dist/messages/deliver-notice.js

@@ -1,24 +1,26 @@
 /*
- * Whether the turn a chat is running was itself opened by a message, which stops two agents that
- * read each other from waking each other forever. It rides on the turn, so it survives a restart.
- * Between turns the last one counts, since work it left running (a background subagent) may still
- * write, and a turn the CLI opened by itself takes the step of the turn before it.
+ * Who sent the message that opened the turn a chat is running, empty when no message opened it,
+ * which stops two agents that read each other from waking each other forever. It rides on the turn,
+ * so it survives a restart. Between turns the last one counts, since work it left running (a
+ * background subagent) may still write, and a turn the CLI opened by itself takes the step of the
+ * turn before it.
  */
-export function turnFromMessage(items, activeTurnId) {
+export function turnWokenBy(items, activeTurnId) {
     const from = activeTurnId === null ? items.findLastIndex((item) => item.kind === 'turn') : items.findIndex((item) => item.id === activeTurnId);
     for (let i = from; i >= 0; i--) {
         const turn = items[i];
         if (turn.kind !== 'turn') {
             continue;
         }
-        if ((turn.messageFrom ?? []).length > 0) {
-            return true;
+        const senders = turn.messageFrom ?? [];
+        if (senders.length > 0) {
+            return senders;
         }
         if (turn.origin !== 'agent' || turn.taskIds !== undefined || turn.summaryFor !== undefined) {
-            return false;
+            return [];
         }
     }
-    return false;
+    return [];
 }
 /* The chats of a core as a message sees them. */
 export function chatNoticeTargets(chats) {
@@ -31,17 +33,19 @@ export function chatNoticeTargets(chats) {
             // A chat nobody has loaded is idle: the turn opens on the thread the host reads back from disk.
             return (await chats.hasStored(id)) ? 'idle' : 'none';
         },
-        fromMessage: (id) => {
+        wokenBy: (id) => {
             const session = chats.get(id);
-            return session !== undefined && turnFromMessage(session.thread.list(), session.info.activeTurnId);
+            return session === undefined ? [] : turnWokenBy(session.thread.list(), session.info.activeTurnId);
         }
     };
 }
 /*
  * One message on its way to a chat, and whether the chat owes a turn on it. A chat between turns gets
  * one, as for a settled task, or the message sits there until someone happens to prompt that chat.
- * One step deep: the turn a message opened wakes nobody with a message of its own. A node that runs
- * something else, such as a terminal, is the host's to deliver to before this.
+ * A turn a message opened wakes nobody with a message of its own, except the sender it answers,
+ * once: only while that sender's own turn was opened by no message, so a question and its answer
+ * take two steps and the turn the answer opens wakes nobody. A node that runs something else, such
+ * as a terminal, is the host's to deliver to before this.
  */
 export async function deliverToChat(store, targets, notice) {
     const waiting = await store.put(notice);
@@ -52,7 +56,9 @@ export async function deliverToChat(store, targets, notice) {
     if (chat === 'running') {
         return { outcome: 'in-turn', waiting };
     }
-    if (targets.fromMessage(notice.from)) {
+    const wokenBy = targets.wokenBy(notice.from);
+    const answer = wokenBy.includes(notice.targetId) && targets.wokenBy(notice.targetId).length === 0;
+    if (wokenBy.length > 0 && !answer) {
         return { outcome: 'from-message', waiting };
     }
     return { outcome: 'wake', waiting };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adecore/agents",
-  "version": "0.48.0",
+  "version": "0.48.2",
   "description": "Node-compatible agent chat hosts, providers, accounts, usage and durable task coordination.",
   "type": "module",
   "exports": {
@@ -93,8 +93,8 @@
     "test": "bun --conditions=source test"
   },
   "dependencies": {
-    "@adecore/agent-contracts": "0.48.0",
-    "@adecore/intelligent-ui": "0.48.0",
+    "@adecore/agent-contracts": "0.48.2",
+    "@adecore/intelligent-ui": "0.48.2",
     "zod": "^4.6.7"
   },
   "devDependencies": {

package/src/chat/chat-session.ts

@@ -6,6 +6,7 @@ import type {
     ChatGoalAction,
     ChatInfo,
     ChatItem,
+    ChatNoteItem,
     ChatNoteMessage,
     ChatQueuedMessage,
     ChatQuoteSource,
@@ -157,6 +158,11 @@ function newId(prefix: string): string {
     return `${prefix}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
 }
 
+/* The note of what the agent heard in front of a prompt, which a person reads in the turn it opened. */
+function saidNote(turnId: string, now: number, text: string): ChatNoteItem {
+    return { id: newId('note'), kind: 'note', createdAt: now, turnId, level: 'info', text, said: true };
+}
+
 /*
  * Item and request ids carry the generation of the CLI that made them, and a restart of the host
  * must not hand out one a stored thread already holds. Starting from the clock puts every run above
@@ -1184,7 +1190,7 @@ export class ChatSession {
         const preamble = [words.preamble, context.preamble].filter(Boolean).join('\n\n') || null;
 
         if (context.note) {
-            this.emit([this.thread.upsert({ id: newId('note'), kind: 'note', createdAt: now, turnId, level: 'info', text: context.note })]);
+            this.emit([this.thread.upsert(saidNote(turnId, now, context.note))]);
         }
 
         const input: TurnInput = { promptId: randomUUID(), text: words.prompt, preamble, attachments: [], mentions: [], skills: [] };
@@ -1271,7 +1277,7 @@ export class ChatSession {
             ...(wake.note === undefined
                 ? []
                 : [this.thread.upsert({ id: newId('note'), kind: 'note', createdAt: now, turnId, level: 'info', text: wake.note })]),
-            ...(note === null ? [] : [this.thread.upsert({ id: newId('note'), kind: 'note', createdAt: now, turnId, level: 'info', text: note })]),
+            ...(note === null ? [] : [this.thread.upsert(saidNote(turnId, now, note))]),
             this.thread.patchInfo({ status: this.thread.statusFor(turnId), activeTurnId: turnId })
         ]);
 
@@ -1878,7 +1884,7 @@ export class ChatSession {
         const events = [this.thread.upsert({ id: turnId, kind: 'turn', createdAt: now, turnId, state: 'running', origin: 'user', endedAt: null, costUsd: 0 })];
 
         if (note !== null) {
-            events.push(this.thread.upsert({ id: newId('note'), kind: 'note', createdAt: now, turnId, level: 'info', text: note }));
+            events.push(this.thread.upsert(saidNote(turnId, now, note)));
         }
 
         if (text !== null) {

package/src/messages/deliver-notice.ts

@@ -18,8 +18,8 @@ export interface MessageWords {
 export interface ChatNoticeTargets {
     /* What the host holds under this id: a chat between turns, one that is in a turn, or no chat at all. */
     chat(id: string): Promise<'idle' | 'running' | 'none'>;
-    /* Whether the turn this node is running was opened by a message of its own, which is where waking stops. */
-    fromMessage(id: string): boolean;
+    /* The senders whose message opened the turn this node is running, empty for a turn no message opened. */
+    wokenBy(id: string): readonly string[];
 }
 
 /*
@@ -33,12 +33,13 @@ export interface ChatDelivery {
 }
 
 /*
- * Whether the turn a chat is running was itself opened by a message, which stops two agents that
- * read each other from waking each other forever. It rides on the turn, so it survives a restart.
- * Between turns the last one counts, since work it left running (a background subagent) may still
- * write, and a turn the CLI opened by itself takes the step of the turn before it.
+ * Who sent the message that opened the turn a chat is running, empty when no message opened it,
+ * which stops two agents that read each other from waking each other forever. It rides on the turn,
+ * so it survives a restart. Between turns the last one counts, since work it left running (a
+ * background subagent) may still write, and a turn the CLI opened by itself takes the step of the
+ * turn before it.
  */
-export function turnFromMessage(items: readonly ChatItem[], activeTurnId: string | null): boolean {
+export function turnWokenBy(items: readonly ChatItem[], activeTurnId: string | null): readonly string[] {
     const from = activeTurnId === null ? items.findLastIndex((item) => item.kind === 'turn') : items.findIndex((item) => item.id === activeTurnId);
 
     for (let i = from; i >= 0; i--) {
@@ -48,16 +49,18 @@ export function turnFromMessage(items: readonly ChatItem[], activeTurnId: string
             continue;
         }
 
-        if ((turn.messageFrom ?? []).length > 0) {
-            return true;
+        const senders = turn.messageFrom ?? [];
+
+        if (senders.length > 0) {
+            return senders;
         }
 
         if (turn.origin !== 'agent' || turn.taskIds !== undefined || turn.summaryFor !== undefined) {
-            return false;
+            return [];
         }
     }
 
-    return false;
+    return [];
 }
 
 /* The chats of a core as a message sees them. */
@@ -73,10 +76,10 @@ export function chatNoticeTargets(chats: Pick<ChatCore, 'get' | 'hasStored'>): C
             // A chat nobody has loaded is idle: the turn opens on the thread the host reads back from disk.
             return (await chats.hasStored(id)) ? 'idle' : 'none';
         },
-        fromMessage: (id) => {
+        wokenBy: (id) => {
             const session = chats.get(id);
 
-            return session !== undefined && turnFromMessage(session.thread.list(), session.info.activeTurnId);
+            return session === undefined ? [] : turnWokenBy(session.thread.list(), session.info.activeTurnId);
         }
     };
 }
@@ -84,8 +87,10 @@ export function chatNoticeTargets(chats: Pick<ChatCore, 'get' | 'hasStored'>): C
 /*
  * One message on its way to a chat, and whether the chat owes a turn on it. A chat between turns gets
  * one, as for a settled task, or the message sits there until someone happens to prompt that chat.
- * One step deep: the turn a message opened wakes nobody with a message of its own. A node that runs
- * something else, such as a terminal, is the host's to deliver to before this.
+ * A turn a message opened wakes nobody with a message of its own, except the sender it answers,
+ * once: only while that sender's own turn was opened by no message, so a question and its answer
+ * take two steps and the turn the answer opens wakes nobody. A node that runs something else, such
+ * as a terminal, is the host's to deliver to before this.
  */
 export async function deliverToChat(store: Pick<NoticeStore, 'put'>, targets: ChatNoticeTargets, notice: Omit<Notice, 'createdAt'>): Promise<ChatDelivery> {
     const waiting = await store.put(notice);
@@ -99,7 +104,10 @@ export async function deliverToChat(store: Pick<NoticeStore, 'put'>, targets: Ch
         return { outcome: 'in-turn', waiting };
     }
 
-    if (targets.fromMessage(notice.from)) {
+    const wokenBy = targets.wokenBy(notice.from);
+    const answer = wokenBy.includes(notice.targetId) && targets.wokenBy(notice.targetId).length === 0;
+
+    if (wokenBy.length > 0 && !answer) {
         return { outcome: 'from-message', waiting };
     }