@adecore/agents 0.39.0 → 0.40.1

package/src/tasks/wake-parent.ts

@@ -13,9 +13,11 @@ const decoder = new TextDecoder();
 /* The first `bytes` of a text without cutting a character in half, and whether anything was left off. */
 function cutAt(text: string, bytes: number): { text: string; cut: boolean } {
     const encoded = encoder.encode(text);
+
     if (encoded.length <= bytes) {
         return { text, cut: false };
     }
+
     return { text: decoder.decode(encoded.slice(0, bytes)).replace(/\uFFFD$/, ''), cut: true };
 }
 
@@ -26,24 +28,30 @@ function cutAt(text: string, bytes: number): { text: string; cut: boolean } {
  */
 export function wakePrompt(tasks: readonly Task[], teamsOut = 0, restOf?: (childId: string) => string): string {
     const head = tasks.length === 1 ? 'A task you gave has settled. Its result:' : `${tasks.length} tasks you gave have settled. Their results:`;
+
     const sections = tasks.map((task) => {
         const { text, cut } = cutAt(task.result?.text ?? '', RESULT_PREVIEW_BYTES);
         const lines = [`## ${task.title} (node ${task.childId}, task ${task.id}): ${task.status}`, '', text === '' ? '(no result text)' : text];
+
         if (cut) {
             const rest = restOf === undefined ? '' : ` ${restOf(task.childId)}`;
             lines.push('', `[The result was cut at ${RESULT_PREVIEW_BYTES / 1024} KiB.${rest}]`);
         }
+
         return lines.join('\n');
     });
+
     const together = tasks.some((task) => task.batchId !== undefined)
         ? ['The tasks of one team call come in together, once every one of them has settled.']
         : [];
+
     const out =
         teamsOut === 0
             ? []
             : [
                   `${teamsOut === 1 ? 'A team you gave is' : `${teamsOut} teams you gave are`} still out: you are woken with all of a team's results once its last task settles.`
               ];
+
     return [head, ...sections, ...together, ...out].join('\n\n');
 }
 
@@ -70,6 +78,7 @@ function deliveryBlocked(items: readonly ChatItem[], tasks: readonly Task[]): bo
 function deliveryPending(items: readonly ChatItem[], tasks: readonly Task[]): boolean {
     return tasks.some((task) => {
         const turn = items.findLast((item) => item.kind === 'turn' && item.taskIds?.includes(task.id));
+
         return turn?.kind === 'turn' && turn.deliveryPending;
     });
 }
@@ -90,34 +99,47 @@ export function wakeParentHandler(deps: WakeParentDeps) {
     return async (entry: WakeParentEntry): Promise<OutboxOutcome> => {
         const parentId = entry.target;
         const pending = deps.tasks.pendingWake(parentId);
+
         if (pending.length === 0) {
             return;
         }
+
         const held = (): OutboxOutcome => (deps.tasks.readyWake(parentId).length < deps.tasks.pendingWake(parentId).length ? 'wait' : undefined);
+
         // Nothing to say yet, so the chat is not loaded from disk for it.
         if (deps.tasks.readyWake(parentId).length === 0) {
             return held();
         }
+
         const chat = await deps.chat(parentId);
+
         if (chat === null) {
             await deps.tasks.dropWake(parentId);
+
             return;
         }
+
         const items = chat.items();
         const named = new Set(items.flatMap((item) => (item.kind === 'turn' && !item.deliveryPending ? (item.taskIds ?? []) : [])));
         const already = deps.tasks.pendingWake(parentId).filter((task) => named.has(task.id));
+
         if (already.length > 0) {
             await chat.persist?.();
             await deps.tasks.markWoken(already.map((task) => task.id));
         }
+
         const tasks = deps.tasks.readyWake(parentId).filter((task) => !named.has(task.id));
+
         if (tasks.length === 0) {
             return held();
         }
+
         if (deliveryBlocked(items, tasks)) {
             return 'wait';
         }
+
         const teamsOut = deps.tasks.openBatches(parentId).length;
+
         if (
             !chat.wake({
                 text: wakePrompt(tasks, teamsOut, deps.restOf),
@@ -128,11 +150,15 @@ export function wakeParentHandler(deps: WakeParentDeps) {
         ) {
             return 'wait';
         }
+
         await chat.persist?.();
+
         if (deliveryPending(chat.items(), tasks)) {
             return 'wait';
         }
+
         await deps.tasks.markWoken(tasks.map((task) => task.id));
+
         return held();
     };
 }

package/src/tasks/wiring.ts

@@ -85,10 +85,14 @@ export interface TaskWiring {
 export function wireTasks(deps: TaskWiringDeps): TaskWiring {
     const now = deps.now ?? Date.now;
     const { chats, outbox } = deps;
+
     const enqueue = (projectId: string, target: string, work: TaskWork, notBefore?: number): Promise<void> =>
         outbox.enqueue(projectId, target, work, notBefore);
+
     const limit = backgroundLimits(outbox);
+
     const owesGiveTask = (taskId: string): boolean => outbox.list().some((entry) => isGiveTask(entry) && entry.payload.taskId === taskId);
+
     const coordinator = new TaskCoordinator({
         tasks: deps.tasks,
         now,
@@ -102,15 +106,18 @@ export function wireTasks(deps: TaskWiringDeps): TaskWiring {
         ...(deps.retryAt ? { retryAt: deps.retryAt } : {}),
         afterBackgroundWork: (chatId) => {
             const chat = chats.get(chatId);
+
             if (!chat?.running) {
                 return 'gone';
             }
+
             return reportsOnBackgroundWork(chat.info.provider) ? 'reports' : 'silent';
         },
         commandsOf: (chatId) => chats.get(chatId)?.info.background ?? [],
         activeGoal: (chatId) => {
             const chat = chats.get(chatId);
             const goal = chat?.info.goal;
+
             return chat && goal?.status === 'active' ? { objective: goal.objective, running: chat.running } : null;
         },
         limit
@@ -118,10 +125,12 @@ export function wireTasks(deps: TaskWiringDeps): TaskWiring {
 
     deps.tasks.onChange((task: Task) => {
         deps.changed?.(task);
+
         // A cancelled task owes no wake of its own, but it may be the last of a team whose held results now go out.
         if (task.status === 'cancelled' && task.batchId !== undefined) {
             outbox.wake(task.parentId);
         }
+
         // However a task ended, the limit on its child's background commands has nothing left to settle.
         if (task.status !== 'open' && limit.owed(task.id)) {
             void limit.lapse(task.id).catch((e: unknown) => console.error(`Dropping the limit of task ${task.id} failed:`, errorText(e)));
@@ -129,10 +138,12 @@ export function wireTasks(deps: TaskWiringDeps): TaskWiring {
     });
 
     const requests = chatRequests(chats);
+
     const waiting = new WaitingObserver({
         // A child on another machine asks its questions there.
         openTask: (childId) => {
             const task = deps.tasks.openFor(childId);
+
             return task?.machine === undefined ? task : undefined;
         },
         enqueue,
@@ -142,6 +153,7 @@ export function wireTasks(deps: TaskWiringDeps): TaskWiring {
     chats.observe((event) => {
         coordinator.chatEvent(event);
         waiting.chatEvent(event);
+
         if (event.event === 'chat.event' && chats.get(event.payload.chatId)?.info.activeTurnId === null) {
             outbox.wake(event.payload.chatId);
         }
@@ -155,12 +167,15 @@ export function wireTasks(deps: TaskWiringDeps): TaskWiring {
         if (task.requiresTaskTurn === true && deps.placed(task.childId) && !owesGiveTask(task.id)) {
             await enqueue(task.projectId, task.childId, { kind: 'give-task', payload: { taskId: task.id } });
         }
+
         const stored = await chats.storedBackground(task.childId);
         const storedWork = stored.items.length > 0 || stored.commands.length > 0;
+
         // A goal still active went down with the CLI, which its child's last turn settles on.
         if (!deps.placed(task.childId) || (task.background === undefined && task.requiresTaskTurn !== true && !storedWork && !stored.goal)) {
             return;
         }
+
         if (task.background === undefined && stored.turnId !== null && storedWork) {
             await deps.tasks.holdBackground(task.id, {
                 turnId: stored.turnId,
@@ -168,9 +183,12 @@ export function wireTasks(deps: TaskWiringDeps): TaskWiring {
                 commands: stored.commands
             });
         }
+
         const chat = await loadChat({ chats, placed: deps.placed }, task.childId);
+
         if (chat && chat.info.activeTurnId === null) {
             const last = chat.thread.list().findLast((item) => item.kind === 'turn');
+
             if (last?.kind === 'turn') {
                 coordinator.chatEvent({ event: 'chat.event', payload: { chatId: task.childId, event: { type: 'item', item: last } } });
             }
@@ -184,6 +202,7 @@ export function wireTasks(deps: TaskWiringDeps): TaskWiring {
                 if (task.status !== 'open') {
                     continue;
                 }
+
                 // One child whose record this version cannot read must not keep every later task from recovering.
                 try {
                     await recoverOpen(task);
@@ -191,7 +210,9 @@ export function wireTasks(deps: TaskWiringDeps): TaskWiring {
                     console.error(`Recovering task ${task.id} failed:`, errorText(e));
                 }
             }
+
             await coordinator.settled();
+
             for (const task of deps.tasks.all()) {
                 if (
                     task.status !== 'open' &&
@@ -209,6 +230,7 @@ export function wireTasks(deps: TaskWiringDeps): TaskWiring {
                 // The record first: the handler reads what the task asks from it, and a restart in between still owes the turn.
                 const task = await deps.tasks.open({ ...record, requiresTaskTurn: true }, now());
                 await enqueue(task.projectId, task.childId, { kind: 'give-task', payload: { taskId: task.id } });
+
                 return task;
             },
             chatState: (nodeId) => targets.chat(nodeId),

package/src/testing/accounts.ts

@@ -41,8 +41,10 @@ export async function testAccounts(options: {
         prepareShadow: async () => ({ linked: [], unshared: [], sharedLogin: false }),
         secrets: memorySecrets()
     });
+
     // Written and not saved, so an account whose folder is already gone is there the way a person left it.
     await writeAccounts(accountsPath(options.home), options.accounts);
     await service.load();
+
     return service;
 }

package/src/testing/fake-acp-capture.ts

@@ -30,58 +30,74 @@ export function fakeAcpCapture(capture: AcpCapture, answers: unknown[] = []): Fa
         const send = (frame: Frame): void => {
             io.out({ jsonrpc: '2.0', ...frame });
         };
+
         const update = (fields: unknown): void => {
             const notification = (fields as Frame).update === undefined ? { update: fields } : (fields as Frame);
             send({ method: 'session/update', params: { sessionId: capture.sessionId, ...notification } });
         };
+
         let waiting: { rpcId: number; rest: unknown[]; promptId: unknown; text: unknown } | null = null;
         let nextRpcId = 0;
+
         const play = (updates: unknown[], promptId: unknown, text: unknown): void => {
             for (const [index, fields] of updates.entries()) {
                 const permission = (fields as Frame).permission;
                 const request = (fields as Frame).request as { method: string; params: unknown } | undefined;
+
                 if (permission !== undefined || request !== undefined) {
                     const rpcId = nextRpcId++;
                     waiting = { rpcId, rest: updates.slice(index + 1), promptId, text };
                     send({ id: rpcId, method: request?.method ?? 'session/request_permission', params: request?.params ?? permission });
+
                     return;
                 }
+
                 const named = capture.titleFromPrompt === true && (fields as Frame).sessionUpdate === 'session_info_update';
                 update(named ? { ...(fields as Frame), title: text } : fields);
             }
+
             send(capture.promptError === undefined ? { id: promptId, result: capture.promptResponse } : { id: promptId, error: capture.promptError });
         };
+
         return {
             onLine: (line) => {
                 const frame = JSON.parse(line) as Frame;
                 const id = frame.id;
+
                 switch (frame.method) {
                     case undefined: {
                         const answered = waiting;
+
                         if (answered !== null && id === answered.rpcId) {
                             waiting = null;
                             answers.push(frame.result ?? frame.error);
                             play(answered.rest, answered.promptId, answered.text);
                         }
+
                         return;
                     }
                     case 'initialize':
                         send({ id, result: capture.initialize });
+
                         return;
                     case 'session/new':
                         update({ sessionUpdate: 'available_commands_update', availableCommands: capture.commands });
                         send({ id, result: capture.sessionNew });
+
                         return;
                     case 'session/set_config_option':
                         send({ id, result: capture.setConfigOption });
+
                         return;
                     case 'session/set_mode':
                     case 'session/close':
                         send({ id, result: {} });
+
                         return;
                     case 'session/prompt': {
                         const blocks = Array.isArray((frame.params as Frame | undefined)?.prompt) ? ((frame.params as Frame).prompt as Frame[]) : [];
                         play(capture.promptUpdates, id, blocks.find((block) => block.type === 'text')?.text);
+
                         return;
                     }
                     case 'session/cancel':

package/src/testing/fake-acp.ts

@@ -74,6 +74,7 @@ export function fakeAcpWith(options: FakeAcpOptions): FakeCli {
             if (prompt === null) {
                 return;
             }
+
             update({ sessionUpdate: 'usage_update', used: 1200, size: 200000, cost: { amount: 0.01, currency: 'USD' } });
             respond(prompt.rpcId, { stopReason, ...(options.turnUsage === undefined ? {} : { usage: options.turnUsage }) });
             prompt = null;
@@ -81,19 +82,23 @@ export function fakeAcpWith(options: FakeAcpOptions): FakeCli {
 
         const sessionState = (): Frame => {
             const meta = (totalContextTokens: number): Frame => (options.contextWindows ? { _meta: { totalContextTokens } } : {});
+
             const modelChoices = [
                 { value: 'fake-small', name: 'Fake small', ...meta(128000) },
                 { value: 'fake-large', name: 'Fake large', ...meta(1000000) }
             ];
+
             const effortChoices = [
                 { value: 'low', name: 'Low', description: 'Answers quickly' },
                 { value: 'high', name: 'High' },
                 ...(model === 'fake-large' ? [{ value: 'xhigh', name: 'Extra high' }] : [])
             ];
+
             const effortOption =
                 options.reasoningEffort === undefined
                     ? []
                     : [{ id: 'reasoning_effort', name: 'Reasoning effort', type: 'select', currentValue: effort, options: effortChoices }];
+
             return {
                 ...(modes.length === 0 ? {} : { modes: { currentModeId: mode, availableModes: modes.map((id) => ({ id, name: id })) } }),
                 ...(options.legacyModels
@@ -110,6 +115,7 @@ export function fakeAcpWith(options: FakeAcpOptions): FakeCli {
         const askPermission = (toolCall: Frame, onAnswer: (outcome: Frame) => void): void => {
             const rpcId = serverRequestId++;
             permission = { rpcId, onAnswer };
+
             send({
                 id: rpcId,
                 method: 'session/request_permission',
@@ -127,33 +133,44 @@ export function fakeAcpWith(options: FakeAcpOptions): FakeCli {
 
         const handlePrompt = (id: unknown, params: Frame): void => {
             const blocks = Array.isArray(params.prompt) ? (params.prompt as Frame[]) : [];
+
             const text = blocks
                 .filter((block) => block.type === 'text')
                 .map((block) => String(block.text))
                 .join('\n');
+
             const images = blocks.filter((block) => block.type === 'image').length;
             const history = sessionHistory.get(sessionId) ?? [];
             sessionHistory.set(sessionId, [...history, text]);
             prompt = { rpcId: id as number | string, cancelled: false };
             const last = text.split('\n\n').at(-1) ?? text;
+
             if (last === 'history?') {
                 say(`prompts before: ${history.length}`);
                 endTurn('end_turn');
+
                 return;
             }
+
             if (last === 'mode?') {
                 say(`mode: ${mode}, model: ${model}`);
                 endTurn('end_turn');
+
                 return;
             }
+
             if (last === 'crash') {
                 io.exit(1);
+
                 return;
             }
+
             if (last === 'slow') {
                 say('working');
+
                 return;
             }
+
             if (last === 'plan') {
                 update({
                     sessionUpdate: 'plan',
@@ -162,37 +179,48 @@ export function fakeAcpWith(options: FakeAcpOptions): FakeCli {
                         { content: 'Write the fix', priority: 'medium', status: 'in_progress' }
                     ]
                 });
+
                 endTurn('end_turn');
+
                 return;
             }
+
             if (last === 'refuse' || last === 'max tokens') {
                 say('no');
                 endTurn(last === 'refuse' ? 'refusal' : 'max_tokens');
+
                 return;
             }
+
             if (last.startsWith('edit:')) {
                 const path = last.slice(5).trim();
                 const toolCallId = `call-${++callCounter}`;
                 const content = [{ type: 'diff', path, oldText: 'one\ntwo\n', newText: 'one\nthree\n' }];
                 update({ sessionUpdate: 'tool_call', toolCallId, title: `Edit ${path}`, kind: 'edit', status: 'pending', locations: [{ path }] });
+
                 askPermission({ toolCallId, title: `Edit ${path}`, kind: 'edit', content }, (outcome) => {
                     const allowed = outcome.outcome === 'selected' && outcome.optionId !== 'no';
                     update({ sessionUpdate: 'tool_call_update', toolCallId, status: allowed ? 'completed' : 'failed', content });
                     endTurn(outcome.outcome === 'cancelled' ? 'cancelled' : 'end_turn');
                 });
+
                 return;
             }
+
             if (last.startsWith('tool:')) {
                 const command = last.slice(5).trim();
                 const toolCallId = `call-${++callCounter}`;
                 update({ sessionUpdate: 'agent_thought_chunk', content: { type: 'text', text: 'I should run it.' } });
                 update({ sessionUpdate: 'tool_call', toolCallId, title: `Run ${command}`, kind: 'execute', status: 'pending', rawInput: { command } });
+
                 askPermission({ toolCallId }, (outcome) => {
                     if (outcome.outcome === 'cancelled') {
                         update({ sessionUpdate: 'tool_call_update', toolCallId, status: 'failed' });
                         endTurn('cancelled');
+
                         return;
                     }
+
                     if (outcome.optionId === 'no') {
                         update({
                             sessionUpdate: 'tool_call_update',
@@ -200,22 +228,29 @@ export function fakeAcpWith(options: FakeAcpOptions): FakeCli {
                             status: 'failed',
                             content: [{ type: 'content', content: { type: 'text', text: 'rejected' } }]
                         });
+
                         say('not run');
                         endTurn('end_turn');
+
                         return;
                     }
+
                     update({ sessionUpdate: 'tool_call_update', toolCallId, status: 'in_progress' });
+
                     update({
                         sessionUpdate: 'tool_call_update',
                         toolCallId,
                         status: 'completed',
                         content: [{ type: 'content', content: { type: 'text', text: `ran ${command} (${String(outcome.optionId)})` } }]
                     });
+
                     say('done');
                     endTurn('end_turn');
                 });
+
                 return;
             }
+
             update({ sessionUpdate: 'agent_thought_chunk', content: { type: 'text', text: 'Thinking.' } });
             say(`echo: ${text}${images > 0 ? ` (${images} images)` : ''}`);
             endTurn('end_turn');
@@ -224,6 +259,7 @@ export function fakeAcpWith(options: FakeAcpOptions): FakeCli {
         const handle = (frame: Frame): void => {
             const id = frame.id;
             const params = (typeof frame.params === 'object' && frame.params !== null ? frame.params : {}) as Frame;
+
             if (frame.method === undefined) {
                 // The client's answer to a permission request.
                 if (permission !== null && id === permission.rpcId) {
@@ -232,8 +268,10 @@ export function fakeAcpWith(options: FakeAcpOptions): FakeCli {
                     const result = frame.result as { outcome?: Frame } | undefined;
                     answered.onAnswer(result?.outcome ?? { outcome: 'cancelled' });
                 }
+
                 return;
             }
+
             switch (frame.method) {
                 case 'initialize':
                     respond(id, {
@@ -246,87 +284,115 @@ export function fakeAcpWith(options: FakeAcpOptions): FakeCli {
                         authMethods: options.authMethod === undefined ? [] : [{ id: options.authMethod, name: 'Sign in' }],
                         agentInfo: { name: 'fake-acp', title: 'Fake ACP', version: '0.0.1' }
                     });
+
                     return;
                 case 'authenticate':
                     authenticated = params.methodId === options.authMethod;
                     respond(id, {});
+
                     return;
                 case 'session/new':
                     if (!authenticated) {
                         refuse(id, -32000, 'Authentication required');
+
                         return;
                     }
+
                     sessionId = `fake-session-${Math.random().toString(36).slice(2, 8)}`;
                     sessionHistory.set(sessionId, []);
+
                     if (options.commands !== undefined) {
                         update({
                             sessionUpdate: 'available_commands_update',
                             availableCommands: options.commands.map((name) => ({ name, description: name }))
                         });
                     }
+
                     respond(id, { sessionId, ...sessionState() });
+
                     return;
                 case 'session/load':
                 case 'session/resume': {
                     const history = sessionHistory.get(String(params.sessionId));
+
                     if (!authenticated) {
                         refuse(id, -32000, 'Authentication required');
+
                         return;
                     }
+
                     if (history === undefined) {
                         refuse(id, -32002, 'Session not found');
+
                         return;
                     }
+
                     sessionId = String(params.sessionId);
+
                     if (frame.method === 'session/load') {
                         for (const earlier of history) {
                             update({ sessionUpdate: 'user_message_chunk', content: { type: 'text', text: earlier } });
                             update({ sessionUpdate: 'agent_message_chunk', content: { type: 'text', text: 'replayed' } });
                         }
                     }
+
                     respond(id, sessionState());
+
                     return;
                 }
                 case 'session/close':
                     if (!options.closeSession) {
                         refuse(id, -32601, 'Method not found: session/close');
+
                         return;
                     }
+
                     sessionHistory.delete(String(params.sessionId));
                     respond(id, {});
+
                     return;
                 case 'session/set_mode':
                     mode = String(params.modeId);
                     respond(id, {});
                     update({ sessionUpdate: 'current_mode_update', currentModeId: mode });
+
                     return;
                 case 'session/set_model':
                     model = String(params.modelId);
                     respond(id, {});
+
                     return;
                 case 'session/set_config_option':
                     if (params.configId === 'model') {
                         model = String(params.value);
                     }
+
                     if (params.configId === 'reasoning_effort') {
                         if (options.reasoningEffort === 'reject') {
                             refuse(id, -32602, 'Reasoning effort is locked');
+
                             return;
                         }
+
                         effort = String(params.value);
                     }
+
                     respond(id, { configOptions: sessionState().configOptions ?? [] });
+
                     return;
                 case 'session/prompt':
                     handlePrompt(id, params);
+
                     return;
                 case 'session/cancel':
                     if (prompt !== null) {
                         prompt.cancelled = true;
+
                         if (permission === null) {
                             endTurn('cancelled');
                         }
                     }
+
                     return;
                 default:
                     if (id !== undefined) {