@adecore/agents 0.39.0 → 0.40.0

package/src/tasks/task-coordinator.ts

@@ -46,23 +46,28 @@ export interface TaskCoordinatorDeps {
 function answerOf(items: readonly ChatItem[], turnId: string): string | null {
     for (let i = items.length - 1; i >= 0; i--) {
         const item = items[i]!;
+
         if (item.kind === 'assistant' && item.turnId === turnId && !item.parentToolUseId) {
             const text = readableAssistantText(item).trim();
+
             if (text !== '') {
                 return text;
             }
         }
     }
+
     return null;
 }
 
 function lastNote(items: readonly ChatItem[], turnId: string, levels: readonly string[]): string | null {
     for (let i = items.length - 1; i >= 0; i--) {
         const item = items[i]!;
+
         if (item.kind === 'note' && item.turnId === turnId && levels.includes(item.level)) {
             return item.text;
         }
     }
+
     return null;
 }
 
@@ -87,23 +92,24 @@ export function resultOfTurn(turn: ChatTurnItem, items: readonly ChatItem[], at:
     if (turn.state === 'done') {
         return { status: 'done', result: { text: answerOf(items, turn.id) ?? 'It ended its turn without an answer.', source: 'turn', at } };
     }
+
     if (turn.state === 'aborted') {
         const text = abortedByMachine(turn, items)
             ? (lastNote(items, turn.id, ['warning']) ?? 'The machine stopped it.')
             : 'It was stopped before it finished.';
+
         return { status: 'failed', result: { text, source: 'turn', at } };
     }
+
     return { status: 'failed', result: { text: lastNote(items, turn.id, ['error']) ?? 'Its turn ended in an error.', source: 'turn', at } };
 }
 
 /*
  * Settles tasks from what children do and does nothing else: it writes the task store and owes wakes
  * in the outbox, never starts a turn, since it runs inside the broadcast of the child it heard. A chat
- * child settles when a turn ends with none of its own tasks still open or waiting to wake it, no goal
- * still active and no work of its CLI's still running in the background, or once the commands it runs
- * there outlast their limit;
- * an agent that is not a chat, which the host tells it about, settles only on `done`, or fails when it
- * ends without one.
+ * child settles when a turn ends with no task of its own open or waiting to wake it, no active goal and
+ * no background work running, or once its background commands outlast their limit. An agent that is
+ * not a chat settles only on `done`, or fails when it ends without one.
  */
 export class TaskCoordinator {
     private readonly deps: TaskCoordinatorDeps;
@@ -123,6 +129,7 @@ export class TaskCoordinator {
         while (this.pending.size > 0) {
             await Promise.allSettled([...this.pending]);
         }
+
         await this.deps.tasks.settled();
     }
 
@@ -133,9 +140,11 @@ export class TaskCoordinator {
      */
     async settleFromElsewhere(taskId: string, result: TaskResult, status: 'done' | 'failed' = 'done'): Promise<Task | null> {
         const task = this.deps.tasks.get(taskId);
+
         if (task?.machine === undefined || task.status !== 'open') {
             return null;
         }
+
         return this.settleNow(task, status, result);
     }
 
@@ -143,10 +152,13 @@ export class TaskCoordinator {
         if (this.stopped || event.event !== 'chat.event') {
             return;
         }
+
         const { chatId, event: chatEvent } = event.payload;
+
         if (this.deps.loading?.(chatId)) {
             return;
         }
+
         if (chatEvent.type === 'item' && chatEvent.item.kind === 'turn' && chatEvent.item.state === 'running') {
             this.turnStarted(chatId);
         } else if (chatEvent.type === 'item' && chatEvent.item.kind === 'turn') {
@@ -164,14 +176,9 @@ export class TaskCoordinator {
      * which says how that kind of agent reports back.
      */
     agentEnded(childId: string, text: string): void {
-        if (this.stopped) {
-            return;
+        if (this.deps.placed(childId)) {
+            this.failed(childId, text);
         }
-        const task = this.localTask(childId);
-        if (!task || !this.deps.placed(childId)) {
-            return;
-        }
-        this.settle(task, 'failed', { text, source: 'exit', at: this.deps.now() });
     }
 
     startFailed(childId: string, error: unknown): void {
@@ -186,9 +193,11 @@ export class TaskCoordinator {
     /* `done` from the child itself, which wins over whatever else was about to settle it. */
     async done(childId: string, text: string): Promise<Task | null> {
         const task = this.localTask(childId);
+
         if (!task) {
             return null;
         }
+
         return this.settleNow(task, 'done', { text, source: 'done', at: this.deps.now() });
     }
 
@@ -200,17 +209,23 @@ export class TaskCoordinator {
     async outlasted(childId: string, commands: readonly string[], cause: 'limit' | 'restart' = 'limit'): Promise<Task | null> {
         const task = this.localTask(childId);
         const items = this.deps.chatItems(childId);
+
         if (this.stopped || !task || items === null || this.delegating(childId)) {
             return null;
         }
+
         const last = items.findLast((item): item is ChatTurnItem => item.kind === 'turn');
+
         if (!last || last.state === 'running' || !this.answers(items, last, task)) {
             return null;
         }
+
         const { status, result } = resultOfTurn(last, items, this.deps.now());
+
         if (cause === 'restart') {
             return this.settleNow(task, 'failed', { ...result, text: `${result.text}\n\n${restartedNote(commands)}`, source: 'exit' });
         }
+
         return this.settleNow(task, status, { ...result, text: `${result.text}\n\n${outlastedNote(commands)}` });
     }
 
@@ -224,15 +239,18 @@ export class TaskCoordinator {
     /* The open task a chat here works on; one whose child runs on another machine is settled from there. */
     private localTask(childId: string): Task | undefined {
         const task = this.deps.tasks.openFor(childId);
+
         return task?.machine === undefined ? task : undefined;
     }
 
     /* An open task of this child that nothing can carry any more. */
     private failed(childId: string, text: string): void {
         const task = this.localTask(childId);
+
         if (!task || this.stopped) {
             return;
         }
+
         this.settle(task, 'failed', { text, source: 'exit', at: this.deps.now() });
     }
 
@@ -241,41 +259,53 @@ export class TaskCoordinator {
      * gets a turn of its own that names it; the turn that was in its way answers the person who sent it,
      * not the task, and nothing settles while that turn is still owed. A turn after it answers too, as the
      * one the CLI opens about work that turn left running. A child opened with its task has no turn of that
-     * kind, so its first turn settles it, as it always did.
+     * kind, so its first turn settles it.
      */
     private answers(items: readonly ChatItem[], turn: ChatTurnItem, task: Task): boolean {
         if ((turn.taskIds ?? []).includes(task.id)) {
             return true;
         }
+
         if (this.deps.owedTurn(task.id)) {
             return false;
         }
+
         const own = items.findIndex((item) => item.kind === 'turn' && (item.taskIds ?? []).includes(task.id));
+
         return own === -1 ? task.requiresTaskTurn !== true && turn.createdAt >= task.createdAt : own < items.findIndex((item) => item.id === turn.id);
     }
 
     private turnEnded(chatId: string, turn: ChatTurnItem): void {
         const task = this.localTask(chatId);
         const items = this.deps.chatItems(chatId);
+
         if (!task || items === null || !this.answers(items, turn, task) || this.delegating(chatId)) {
             return;
         }
+
         const paused = this.pauseFor(chatId, turn, items);
+
         if (paused !== null) {
             this.hold(task, paused);
+
             return;
         }
+
         // A goal holds the task with no limit, and the parent sleeps on through the turns its CLI opens toward it.
         const goal = turn.state === 'done' ? (this.deps.activeGoal?.(chatId) ?? null) : null;
+
         if (goal?.running === true) {
             return;
         }
+
         if (goal !== null) {
             const { result } = resultOfTurn(turn, items, this.deps.now());
             this.settle(task, 'failed', { ...result, text: `${result.text}\n\n${goalLostNote(goal.objective)}`, source: 'exit' });
+
             return;
         }
-        // A turn a person stopped or that failed ends the task as it always did, whatever still runs beside it.
+
+        // A turn a person stopped or that failed ends the task, whatever still runs beside it.
         if (turn.state === 'done' && this.heldInBackground(chatId, task, items)) {
             this.track(
                 this.deps.tasks.holdBackground(task.id, {
@@ -285,21 +315,27 @@ export class TaskCoordinator {
                 }),
                 `Saving the background work of task ${task.id} failed`
             );
+
             return;
         }
+
         if (task.background?.turnId === turn.id) {
             const after = this.deps.afterBackgroundWork(chatId);
+
             if (after === 'reports') {
                 return;
             }
+
             if (after === 'gone') {
                 this.settleGone(task, task.background, turn, items);
+
                 return;
             }
         } else if (turn.state === 'done' && this.deps.limit.owed(task.id) && this.deps.afterBackgroundWork(chatId) === 'gone') {
             // After a restart nothing here remembers the turn was held, but the limit it owes does, and that settles it.
             return;
         }
+
         const { status, result } = resultOfTurn(turn, items, this.deps.now());
         this.settle(task, status, result);
     }
@@ -309,27 +345,38 @@ export class TaskCoordinator {
         if (background.itemIds.length === 0 && this.deps.limit.owed(task.id)) {
             return;
         }
+
+        const rowOf = (id: string): ChatItem | undefined => items.find((item) => item.id === id);
+
         const lost = background.itemIds.filter((id) => {
-            const item = items.find((item) => item.id === id);
+            const item = rowOf(id);
+
             return !item || (item.kind === 'subagent' ? item.status !== 'done' : item.kind !== 'tool' || item.state !== 'done');
         });
+
         if (lost.length > 0 || background.commands.length > 0) {
             const names = lost.map((id) => {
-                const row = items.find((item) => item.id === id);
+                const row = rowOf(id);
+
                 return row?.kind === 'subagent' ? row.description || row.toolUseId : row?.kind === 'tool' ? row.name : id;
             });
+
             this.settle(task, 'failed', {
                 text: `The agent ended before its background work completed: ${[...names, ...background.commands].join(', ')}. This work will not send a result.`,
                 source: 'exit',
                 at: this.deps.now()
             });
+
             return;
         }
+
         const reports = background.itemIds.flatMap((id) => {
-            const row = items.find((item) => item.id === id);
+            const row = rowOf(id);
             const report = row?.kind === 'subagent' ? row.result : row?.kind === 'tool' ? row.output : null;
+
             return report ? [report] : [];
         });
+
         this.settle(task, 'done', {
             text: reports.join('\n\n') || resultOfTurn(turn, items, this.deps.now()).result.text,
             source: 'turn',
@@ -347,17 +394,22 @@ export class TaskCoordinator {
             if (this.deps.limit.owed(task.id)) {
                 void this.deps.limit.lapse(task.id).catch((e: unknown) => console.error(`Dropping the limit of task ${task.id} failed:`, errorText(e)));
             }
+
             return true;
         }
+
         const commands = this.deps.commandsOf(chatId);
+
         if (commands.length === 0) {
             return false;
         }
+
         if (!this.deps.limit.owed(task.id)) {
             void this.deps.limit
                 .owe(task, commands.map(commandLabel), this.deps.now() + BACKGROUND_COMMAND_LIMIT_MS)
                 .catch((e: unknown) => console.error(`Owing the limit of task ${task.id} failed:`, errorText(e)));
         }
+
         return true;
     }
 
@@ -367,19 +419,24 @@ export class TaskCoordinator {
      */
     private pauseFor(chatId: string, turn: ChatTurnItem, items: readonly ChatItem[]): NonNullable<Task['paused']> | null {
         const limit = turn.state === 'error' ? turn.limit : undefined;
+
         if (limit?.kind === 'usage') {
             return { kind: 'usage', ...(limit.resetsAt === undefined ? {} : { until: limit.resetsAt }) };
         }
+
         if (limit?.kind === 'overload') {
             const at = this.deps.retryAt?.(chatId, turn, items) ?? null;
+
             return at === null ? null : { kind: 'overload', until: at };
         }
+
         return null;
     }
 
     /* A child that took up work again is no longer waiting out a limit. */
     private turnStarted(chatId: string): void {
         const task = this.localTask(chatId);
+
         if (task?.paused !== undefined) {
             this.hold(task, null);
         }
@@ -392,10 +449,13 @@ export class TaskCoordinator {
     private recheck(chatId: string): void {
         const task = this.localTask(chatId);
         const items = this.deps.chatItems(chatId);
+
         if (!task || items === null || this.delegating(chatId)) {
             return;
         }
+
         const last = items.findLast((item): item is ChatTurnItem => item.kind === 'turn');
+
         if (last && last.state !== 'running' && last.createdAt >= task.createdAt) {
             this.turnEnded(chatId, last);
         }
@@ -417,13 +477,17 @@ export class TaskCoordinator {
 
     private async settleNow(task: Task, status: 'done' | 'failed', result: TaskResult): Promise<Task | null> {
         const settled = await this.deps.tasks.settle(task.id, status, result, this.deps.now());
+
         if (!settled) {
             return null;
         }
+
         await this.deps.oweWake(settled);
+
         if (status === 'failed') {
             this.deps.alert(settled.childId, `Task failed: ${settled.title}`, clipText(result.text, 500));
         }
+
         return settled;
     }
 }

package/src/tasks/task-store.ts

@@ -40,6 +40,7 @@ export class TaskStore {
     /* Told about every task that is written, after it is on disk. */
     onChange(listener: TaskListener): () => void {
         this.listeners.add(listener);
+
         return () => {
             this.listeners.delete(listener);
         };
@@ -72,7 +73,9 @@ export class TaskStore {
             settledAt: null,
             wake: 'pending'
         };
+
         await this.write(task);
+
         return task;
     }
 
@@ -88,9 +91,11 @@ export class TaskStore {
 
     async holdBackground(id: string, background: NonNullable<Task['background']>): Promise<void> {
         const task = this.get(id);
+
         if (!task || task.status !== 'open' || JSON.stringify(task.background) === JSON.stringify(background)) {
             return;
         }
+
         await this.write({ ...task, background });
     }
 
@@ -122,46 +127,57 @@ export class TaskStore {
      */
     async settle(id: string, status: 'done' | 'failed' | 'cancelled', result: TaskResult | null, now: number): Promise<Task | null> {
         const task = this.tasks.get(id);
+
         if (!task || task.status !== 'open') {
             return null;
         }
+
         const { paused: _paused, ...open } = task;
         const settled: Task = { ...open, status, result, settledAt: now, wake: status === 'cancelled' ? 'none' : task.wake };
         await this.write(settled);
+
         return settled;
     }
 
     /* Holds an open task while its child waits out a limit, or lets it go on with null; false when it was not open. */
     async pause(id: string, paused: NonNullable<Task['paused']> | null): Promise<boolean> {
         const task = this.tasks.get(id);
+
         if (!task || task.status !== 'open') {
             return false;
         }
+
         if (JSON.stringify(task.paused ?? null) === JSON.stringify(paused)) {
             return true;
         }
+
         const { paused: _was, ...rest } = task;
         await this.write(paused === null ? rest : { ...rest, paused });
+
         return true;
     }
 
     /* Cancels the open tasks of these children, with the reason as the result; a cancelled task wakes nobody. */
     async cancelOpen(childIds: ReadonlySet<string>, reason: string, now: number): Promise<Task[]> {
         const cancelled: Task[] = [];
+
         for (const task of this.sorted()) {
             if (task.status === 'open' && childIds.has(task.childId)) {
                 const settled = await this.settle(task.id, 'cancelled', { text: reason, source: 'exit', at: now }, now);
+
                 if (settled) {
                     cancelled.push(settled);
                 }
             }
         }
+
         return cancelled;
     }
 
     async markWoken(ids: readonly string[]): Promise<void> {
         for (const id of ids) {
             const task = this.tasks.get(id);
+
             if (task && task.wake === 'pending') {
                 await this.write({ ...task, wake: 'sent' });
             }
@@ -178,12 +194,14 @@ export class TaskStore {
      */
     readyWake(parentId: string): Task[] {
         const open = new Set(this.openBatches(parentId));
+
         return this.pendingWake(parentId).filter((task) => task.batchId === undefined || !open.has(task.batchId));
     }
 
     /* The batches of this parent with a task still open, oldest first. */
     openBatches(parentId: string): string[] {
         const ids = this.ofParent(parentId).flatMap((task) => (task.status === 'open' && task.batchId !== undefined ? [task.batchId] : []));
+
         return [...new Set(ids)];
     }
 
@@ -194,6 +212,7 @@ export class TaskStore {
     async dropWake(parentId: string): Promise<void> {
         for (const { id } of this.ofParent(parentId)) {
             const task = this.tasks.get(id);
+
             if (task && task.wake === 'pending') {
                 await this.write({ ...task, wake: 'none' });
             }
@@ -206,21 +225,27 @@ export class TaskStore {
      */
     async prune(projectId: string, ids: ReadonlySet<string>, now: number): Promise<Task[]> {
         const cancelled: Task[] = [];
+
         for (const task of this.sorted()) {
             if (task.projectId !== projectId) {
                 continue;
             }
+
             if (!ids.has(task.parentId)) {
                 await this.tasks.remove(task.id);
+
                 continue;
             }
+
             if (!ids.has(task.childId) && task.status === 'open') {
                 const settled = await this.settle(task.id, 'cancelled', null, now);
+
                 if (settled) {
                     cancelled.push(settled);
                 }
             }
         }
+
         return cancelled;
     }
 
@@ -233,6 +258,7 @@ export class TaskStore {
         const write = this.writeNow(task);
         this.writes.add(write);
         void write.finally(() => this.writes.delete(write)).catch(() => undefined);
+
         return write;
     }
 
@@ -241,9 +267,11 @@ export class TaskStore {
         if (!(await this.tasks.write(task))) {
             return;
         }
+
         for (const listener of this.listeners) {
             listener(task);
         }
+
         this.sinks.emit({ event: 'task.changed', payload: { task } });
     }
 }

package/src/tasks/waiting-child.ts

@@ -29,12 +29,14 @@ export function chatRequests(chats: Pick<ChatCore, 'get' | 'answer'>): ChatReque
             // The projector writes each under the kind it is.
             const thread = chats.get(nodeId)?.thread;
             const item = thread?.get(`question-${requestId}`) ?? thread?.get(`approval-${requestId}`);
+
             return item?.kind === 'question' || item?.kind === 'approval' ? item : null;
         },
         waiting: (nodeId) => (chats.get(nodeId)?.thread.list() ?? []).filter(isPendingRequest),
         answer: (nodeId, requestId, answers) => {
             try {
                 chats.answer(nodeId, requestId, answers);
+
                 return true;
             } catch {
                 return false;
@@ -86,16 +88,22 @@ export class WaitingObserver {
         if (this.stopped || event.event !== 'chat.event') {
             return;
         }
+
         const { chatId, event: chatEvent } = event.payload;
+
         if (chatEvent.type !== 'item' || !isPendingRequest(chatEvent.item)) {
             return;
         }
+
         const task = this.deps.openTask(chatId);
         const key = `${chatId}\n${chatEvent.item.requestId}`;
+
         if (task === undefined || this.owed.has(key)) {
             return;
         }
+
         this.owed.add(key);
+
         void this.deps
             .enqueue(
                 task.projectId,
@@ -120,16 +128,19 @@ const NOTE_QUESTION_LENGTH = 200;
 
 function quotedShort(text: string): string {
     const line = oneLine(text);
+
     return JSON.stringify(line.length > NOTE_QUESTION_LENGTH ? `${clipText(line, NOTE_QUESTION_LENGTH - 1)}…` : line);
 }
 
 /* One question as the parent's CLI reads it, with the choices it may pick from. */
 function questionLine(question: ChatQuestionItem['questions'][number]): string {
     const choices = question.choices.map((choice) => (choice.description === '' ? choice.label : `${choice.label} (${choice.description})`));
+
     const how =
         choices.length === 0
             ? 'answer in your own words'
             : `choices: ${choices.join(' | ')}; ${question.multiSelect ? 'pick one or more' : 'pick one'}, or answer in your own words`;
+
     return `- question ${question.id}: ${quoted(question.question)} (${how})`;
 }
 
@@ -146,9 +157,12 @@ export interface WaitingWords {
 function answerCall(cli: string, childId: string, item: ChatQuestionItem): string {
     if (item.questions.length === 1) {
         const multi = item.questions[0]!.multiSelect ? ', several labels in one --answer separated by a comma' : '';
+
         return `${cli} answer ${childId} ${item.requestId} --answer '<a choice label as written, or your own words>'${multi}`;
     }
+
     const shape = Object.fromEntries(item.questions.map((question) => [question.id, '...']));
+
     return `${cli} answer ${childId} ${item.requestId} --answers '${JSON.stringify(shape)}', one answer per question id`;
 }
 
@@ -158,8 +172,10 @@ function answerCall(cli: string, childId: string, item: ChatQuestionItem): strin
  */
 export function waitingTexts(child: { id: string; title: string }, item: WaitingRequest, words: WaitingWords): { note: string; preamble: string } {
     const who = `${child.title} (node ${child.id})`;
+
     if (item.kind === 'approval') {
         const what = item.description === null ? item.toolName : `${item.toolName}: ${item.description}`;
+
         return {
             note: `${who} waits for a person to approve ${what}`,
             preamble: [
@@ -168,11 +184,14 @@ export function waitingTexts(child: { id: string; title: string }, item: Waiting
             ].join('\n')
         };
     }
+
     const asked = item.questions.length === 1 ? quotedShort(item.questions[0]!.question) : `${item.questions.length} questions`;
+
     const how = [
         ...item.questions.map(questionLine),
         `A person can answer it in that node, and this chat with ${answerCall(words.cli, child.id, item)}. Whoever answers first wins; the verb refuses a question that was answered already.`
     ];
+
     return {
         note: [`${who} waits for an answer to ${asked}`, '', ...how].join('\n'),
         preamble: [
@@ -197,9 +216,11 @@ export function deliverWaitingHandler(deps: DeliverWaitingDeps) {
     return async (entry: DeliverWaitingEntry): Promise<OutboxOutcome> => {
         const { childId, requestId } = entry.payload;
         const item = deps.request(childId, requestId);
+
         if (!isPendingRequest(item)) {
             return;
         }
+
         const texts = waitingTexts({ id: childId, title: deps.titleFor(childId) ?? childId }, item, deps.words);
         await deps.deliver(entry.target, { noteId: waitingNoteId(childId, requestId), from: childId, ...texts });
     };