@adecore/agents 0.39.0 → 0.40.1

package/src/testing/fake-codex.ts

@@ -108,6 +108,7 @@ export function fakeCodexWith(options: FakeCodexOptions): FakeCli {
         const turnCompleted = (status: 'completed' | 'interrupted' | 'failed', error: string | null = null, codexErrorInfo: string | null = null): void => {
             usage();
             notify('thread/status/changed', { threadId, status: { type: 'idle' } });
+
             notify('turn/completed', {
                 threadId,
                 turn: {
@@ -118,6 +119,7 @@ export function fakeCodexWith(options: FakeCodexOptions): FakeCli {
                     error: error ? { message: error, codexErrorInfo, additionalDetails: null } : null
                 }
             });
+
             turnId = '';
         };
 
@@ -137,11 +139,14 @@ export function fakeCodexWith(options: FakeCodexOptions): FakeCli {
             goalSteps += 1;
             agentMessage(`goal step ${goalSteps}`);
             const needed = Number(/steps:(\d+)/.exec(String(goal?.objective ?? ''))?.[1] ?? '1');
+
             if (goal !== null) {
                 goal = { ...goal, tokensUsed: Number(goal.tokensUsed) + 100, status: goalSteps >= needed ? 'complete' : goal.status };
                 goalChanged();
             }
+
             turnCompleted('completed');
+
             if (goal?.status === 'active') {
                 io.later(() => {
                     if (goal?.status === 'active') {
@@ -160,6 +165,7 @@ export function fakeCodexWith(options: FakeCodexOptions): FakeCli {
         const askApproval = (kind: 'command' | 'fileChange', entry: Frame, params: Frame): void => {
             pendingApproval = { rpcId: serverRequestId, entry, kind };
             notify('thread/status/changed', { threadId, status: { type: 'active', activeFlags: ['waitingOnApproval'] } });
+
             out({
                 method: kind === 'command' ? 'item/commandExecution/requestApproval' : 'item/fileChange/requestApproval',
                 id: serverRequestId++,
@@ -173,56 +179,77 @@ export function fakeCodexWith(options: FakeCodexOptions): FakeCli {
             const raw = input?.text ?? '';
             const gap = raw.indexOf('\n\n');
             const noted = options.resumeLead !== undefined && raw.startsWith(options.resumeLead) && gap !== -1;
+
             if (noted) {
                 pasted = raw.slice(0, gap);
             }
+
             const text = noted ? raw.slice(gap + 2) : raw;
+
             if (text === 'name?') {
                 turnStarted();
                 agentMessage(threadName ?? 'unnamed');
                 turnCompleted('completed');
+
                 return;
             }
+
             if (text === 'note?' || text === 'pasted?') {
                 turnStarted();
                 agentMessage((text === 'note?' ? threadInstructions.get(threadId) : pasted) ?? 'nothing');
                 turnCompleted('completed');
+
                 return;
             }
+
             turnStarted();
             const user = item('userMessage', { clientId: null, content: [{ type: 'text', text, text_elements: [] }] });
             started(user);
             completed(user);
+
             if (goal !== null && (text === goal.objective || text === '')) {
                 io.later(goalStep);
+
                 return;
             }
+
             if (text === 'crash') {
                 io.exit(1);
+
                 return;
             }
+
             if (text === 'crash loudly') {
                 io.err('Error: the fake lost its thread\n');
                 io.exit(1);
+
                 return;
             }
+
             if (text === 'fail') {
                 turnCompleted('failed', 'The model is overloaded');
+
                 return;
             }
+
             // Lines of their own, so a task brief around them still fails the way Codex 0.156.1 does.
             const lines = text.split('\n');
+
             // A dev server Codex leaves running past the turn; its process ends once the test says later is.
             if (lines.includes('serve')) {
                 const command = item('commandExecution', { command: "/bin/zsh -lc 'bun dev'", cwd: io.cwd, processId: `pty-${nonce}`, status: 'inProgress' });
                 started(command);
                 io.later(() => completed({ ...command, status: 'completed', aggregatedOutput: '', exitCode: 0 }));
             }
+
             if (lines.includes('overloaded')) {
                 turnCompleted('failed', 'Selected model is at capacity. Please try a different model.', 'serverOverloaded');
+
                 return;
             }
+
             const limit = lines.find((line) => line.startsWith('limit:'));
+
             if (limit !== undefined) {
                 notify('account/rateLimits/updated', {
                     rateLimits: {
@@ -231,11 +258,15 @@ export function fakeCodexWith(options: FakeCodexOptions): FakeCli {
                         secondary: { usedPercent: 40, windowDurationMins: 10080, resetsAt: Number(limit.slice(6)) + 86_400 }
                     }
                 });
+
                 turnCompleted('failed', "You've hit your usage limit.", 'usageLimitExceeded');
+
                 return;
             }
+
             if (text.startsWith('image:')) {
                 const scenario = text.slice(6);
+
                 const entry = item('imageGeneration', {
                     status: 'inProgress',
                     result: '',
@@ -243,7 +274,9 @@ export function fakeCodexWith(options: FakeCodexOptions): FakeCli {
                     revisedPrompt: 'A rabbit',
                     transparentBackground: true
                 });
+
                 started(entry);
+
                 const result =
                     scenario === 'empty'
                         ? ''
@@ -254,27 +287,36 @@ export function fakeCodexWith(options: FakeCodexOptions): FakeCli {
                             : scenario === 'too-large'
                               ? Buffer.alloc(10 * 1024 * 1024 + 1).toString('base64')
                               : 'iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mP8/x8AAwMCAO+jRZkAAAAASUVORK5CYII=';
+
                 const done = {
                     ...entry,
                     status: scenario === 'failed' ? 'failed' : 'completed',
                     result,
                     ...(scenario === 'failed' ? { failure: { message: 'Image generation failed' } } : {})
                 };
+
                 completed(done);
+
                 if (scenario === 'replay') {
                     completed(done);
                 }
+
                 agentMessage('Here is the generated image.');
                 turnCompleted('completed');
+
                 return;
             }
+
             if (text === 'slow') {
                 slow = true;
                 started(item('agentMessage', { text: '', phase: 'final_answer', memoryCitation: null, delivery: null, questions: null }));
+
                 return;
             }
+
             if (text.startsWith('tool:')) {
                 const command = text.slice(5).trim();
+
                 const entry = item('commandExecution', {
                     command: `/bin/zsh -lc ${command}`,
                     cwd: io.cwd,
@@ -282,7 +324,9 @@ export function fakeCodexWith(options: FakeCodexOptions): FakeCli {
                     aggregatedOutput: null,
                     exitCode: null
                 });
+
                 started(entry);
+
                 askApproval('command', entry, {
                     kind: 'command',
                     command: `/bin/zsh -lc ${command}`,
@@ -291,20 +335,26 @@ export function fakeCodexWith(options: FakeCodexOptions): FakeCli {
                     proposedExecpolicyAmendment: [command.split(' ')[0]],
                     availableDecisions: ['accept', { acceptWithExecpolicyAmendment: { execpolicy_amendment: [command.split(' ')[0]] } }, 'cancel']
                 });
+
                 return;
             }
+
             if (text.startsWith('edit:')) {
                 const path = text.slice(5).trim();
                 const entry = item('fileChange', { changes: [{ path, kind: { type: 'add' }, diff: `+++ ${path}\n+hello\n` }], status: 'inProgress' });
                 started(entry);
                 askApproval('fileChange', entry, { reason: 'Write outside the sandbox' });
+
                 return;
             }
+
             const finish = text.startsWith('spawn and finish:');
+
             if (finish || text.startsWith('spawn:')) {
                 const prompt = text.slice(text.indexOf(':') + 1).trim();
                 const childId = `child-${nonce}-${++itemCounter}`;
                 const steps: Frame[] = [{ type: 'userMessage', id: `${childId}-prompt`, content: [{ type: 'text', text: prompt, text_elements: [] }] }];
+
                 for (let step = 1; step <= FAKE_CHILD_STEPS; step++) {
                     steps.push({
                         type: 'commandExecution',
@@ -316,7 +366,9 @@ export function fakeCodexWith(options: FakeCodexOptions): FakeCli {
                         exitCode: 0
                     });
                 }
+
                 childThreads.set(childId, steps);
+
                 const spawn = item('collabAgentToolCall', {
                     tool: 'spawnAgent',
                     prompt,
@@ -326,22 +378,28 @@ export function fakeCodexWith(options: FakeCodexOptions): FakeCli {
                     agentsStates: {},
                     status: 'inProgress'
                 });
+
                 started(spawn);
                 const running = { ...spawn, receiverThreadIds: [childId], agentsStates: { [childId]: { status: 'running', message: null } } };
+
                 if (!finish) {
                     completed(running);
                     agentMessage('spawned');
                     turnCompleted('completed');
+
                     return;
                 }
+
                 completed({ ...running, status: 'completed', agentsStates: { [childId]: { status: 'completed', message: 'the docs are read' } } });
                 agentMessage('spawned');
                 const spawnedIn = turnId;
                 turnCompleted('completed');
                 // A snapshot of the call from while its agent still ran, delivered after the agent finished.
                 io.later(() => notify('item/completed', { item: running, threadId, turnId: spawnedIn, completedAtMs: Date.now() }));
+
                 return;
             }
+
             /*
              * A spawn the way Codex 0.156.1 reports it: no spawnAgent call, a `subAgentActivity` that started under
              * the call id, the agent's own thread streaming over the same connection, and a `completed` activity
@@ -352,14 +410,17 @@ export function fakeCodexWith(options: FakeCodexOptions): FakeCli {
                 const childId = `child-${nonce}-${++itemCounter}`;
                 const childTurn = `turn-${nonce}-${++itemCounter}`;
                 childThreads.set(childId, [{ type: 'userMessage', id: `${childId}-prompt`, content: [{ type: 'text', text: prompt, text_elements: [] }] }]);
+
                 const activity = (id: string, kind: string): void => {
                     const entry = { type: 'subAgentActivity', id, kind, agentThreadId: childId, agentPath: '/root/survey' };
                     started(entry);
                     completed(entry);
                 };
+
                 const inChild = (method: string, params: Frame): void => {
                     notify(method, { threadId: childId, ...params });
                 };
+
                 activity(`call-spawn-${nonce}-${++itemCounter}`, 'started');
                 inChild('thread/status/changed', { status: { type: 'active', activeFlags: [] } });
                 inChild('turn/started', { turn: { id: childTurn, items: [], itemsView: 'notLoaded', status: 'inProgress', error: null } });
@@ -371,11 +432,14 @@ export function fakeCodexWith(options: FakeCodexOptions): FakeCli {
                 agentMessage('spawned');
                 turnCompleted('completed');
                 io.later(() => activity(`subagent-completed-${childTurn}`, 'completed'));
+
                 return;
             }
+
             if (text.startsWith('ask:')) {
                 const question = text.slice(4).trim();
                 pendingQuestion = { rpcId: serverRequestId, questionId: 'color' };
+
                 out({
                     method: 'item/tool/requestUserInput',
                     id: serverRequestId++,
@@ -399,11 +463,14 @@ export function fakeCodexWith(options: FakeCodexOptions): FakeCli {
                         ]
                     }
                 });
+
                 return;
             }
+
             if (text.startsWith('async:')) {
                 const question = text.slice(6).trim();
                 pendingSteer = true;
+
                 const entry = item('agentMessage', {
                     text: `${question}\n- Red\n- Blue`,
                     phase: 'final_answer',
@@ -411,10 +478,13 @@ export function fakeCodexWith(options: FakeCodexOptions): FakeCli {
                     delivery: 'async',
                     questions: [{ title: question, options: ['Red', 'Blue'] }]
                 });
+
                 started(entry);
                 completed(entry);
+
                 return;
             }
+
             agentMessage(`echo: ${text}${turnEffort ? ` (${turnEffort})` : ''}`);
             turnCompleted('completed');
         };
@@ -425,8 +495,10 @@ export function fakeCodexWith(options: FakeCodexOptions): FakeCli {
             const decision = result.decision;
             const accepted = decision === 'accept' || decision === 'acceptForSession' || (typeof decision === 'object' && decision !== null);
             const always = decision === 'acceptForSession' || (typeof decision === 'object' && decision !== null);
+
             if (approval.kind === 'command') {
                 const command = String(approval.entry.command).replace('/bin/zsh -lc ', '');
+
                 completed({
                     ...approval.entry,
                     status: accepted ? 'completed' : 'declined',
@@ -436,6 +508,7 @@ export function fakeCodexWith(options: FakeCodexOptions): FakeCli {
             } else {
                 completed({ ...approval.entry, status: accepted ? 'completed' : 'declined' });
             }
+
             agentMessage(accepted ? (always ? 'done, remembered' : 'done') : 'denied');
             turnCompleted('completed');
         };
@@ -451,6 +524,7 @@ export function fakeCodexWith(options: FakeCodexOptions): FakeCli {
             switch (method) {
                 case 'initialize':
                     out({ id, result: { userAgent: 'fake-codex/0.0.0', codexHome: io.cwd, platformFamily: 'unix', platformOs: 'test' } });
+
                     return;
                 case 'model/list':
                     out({
@@ -460,24 +534,31 @@ export function fakeCodexWith(options: FakeCodexOptions): FakeCli {
                             nextCursor: null
                         }
                     });
+
                     return;
                 case 'thread/start':
                 case 'thread/resume': {
                     const resumed = method === 'thread/resume' ? String(params.threadId) : null;
+
                     if (resumed === 'gone') {
                         out({ id, error: { code: -32600, message: 'no thread gone' } });
+
                         return;
                     }
+
                     threadId = resumed ?? `fake-${Math.random().toString(36).slice(2, 8)}`;
+
                     // Codex 0.154 ignores developer instructions on a resume; only a start sets them.
                     if (resumed === null) {
                         threadInstructions.set(threadId, typeof params.developerInstructions === 'string' ? params.developerInstructions : null);
                     }
+
                     threadModel = typeof params.model === 'string' ? params.model : 'fake-model';
                     threadSandbox = typeof params.sandbox === 'string' ? params.sandbox : '';
                     threadApproval = typeof params.approvalPolicy === 'string' ? params.approvalPolicy : '';
                     threadName = threadId.startsWith('named-') ? 'Named before' : null;
                     const thread = { id: threadId, model: threadModel, cwd: params.cwd, turns: [], name: threadName };
+
                     out({
                         id,
                         result: {
@@ -489,51 +570,67 @@ export function fakeCodexWith(options: FakeCodexOptions): FakeCli {
                             sandbox: { type: threadSandbox }
                         }
                     });
+
                     notify('thread/started', { thread });
+
                     return;
                 }
                 case 'thread/inject_items': {
                     if (options.injectItems === false) {
                         out({ id, error: { code: -32601, message: 'unknown method thread/inject_items' } });
+
                         return;
                     }
+
                     // The newest developer message is the one the model follows, so `note?` answers with it.
                     const items = Array.isArray(params.items) ? (params.items as Frame[]) : [];
+
                     for (const injected of items) {
                         const content = Array.isArray(injected.content) ? (injected.content[0] as { text?: unknown } | undefined) : undefined;
+
                         if (injected.role === 'developer' && typeof content?.text === 'string') {
                             threadInstructions.set(String(params.threadId), content.text);
                         }
                     }
+
                     out({ id, result: {} });
+
                     return;
                 }
                 case 'thread/fork': {
                     const source = String(params.threadId);
                     const turns = threadTurns.get(source) ?? [];
                     const last = typeof params.lastTurnId === 'string' ? turns.indexOf(params.lastTurnId) : turns.length - 1;
+
                     if (!threadTurns.has(source) || (typeof params.lastTurnId === 'string' && last < 0)) {
                         out({ id, error: { code: -32600, message: `no rollout found for thread id ${source}` } });
+
                         return;
                     }
+
                     fakeCodexForks.push(params);
                     const forked = `fork-${Math.random().toString(36).slice(2, 8)}`;
                     threadTurns.set(forked, turns.slice(0, last + 1));
                     threadInstructions.set(forked, threadInstructions.get(source) ?? null);
                     out({ id, result: { thread: { id: forked, forkedFromId: source, cwd: params.cwd, turns: [] }, model: params.model ?? 'fake-model' } });
+
                     return;
                 }
                 case 'thread/turns/list': {
                     const turns = threadTurns.get(String(params.threadId)) ?? [];
                     out({ id, result: { data: turns.map((turn) => ({ id: turn, items: [], status: 'completed', error: null })), nextCursor: null } });
+
                     return;
                 }
                 case 'thread/items/list': {
                     const steps = childThreads.get(String(params.threadId));
+
                     if (!steps) {
                         out({ id, error: { code: -32600, message: `no rollout found for thread id ${String(params.threadId)}` } });
+
                         return;
                     }
+
                     // The cursor is where the next page starts, counted from the end the list is sorted from.
                     const ordered = params.sortDirection === 'asc' ? steps : [...steps].reverse();
                     const start = typeof params.cursor === 'string' ? Number(params.cursor) : 0;
@@ -541,16 +638,19 @@ export function fakeCodexWith(options: FakeCodexOptions): FakeCli {
                     const page = ordered.slice(start, start + limit);
                     const next = start + limit < ordered.length ? String(start + limit) : null;
                     out({ id, result: { data: page.map((entry) => ({ item: entry, turnId: 'child-turn' })), nextCursor: next, backwardsCursor: null } });
+
                     return;
                 }
                 case 'thread/name/set':
                     threadName = String(params.name);
                     out({ id, result: {} });
                     notify('thread/name/updated', { threadId, threadName });
+
                     return;
                 case 'turn/start':
                     out({ id, result: { turn: { id: `turn-${nonce}-${itemCounter + 1}`, items: [], status: 'inProgress', error: null } } });
                     handleTurnStart(params);
+
                     return;
                 case 'turn/steer': {
                     // The real app-server refuses a steer that does not name the turn it is meant for.
@@ -560,29 +660,37 @@ export function fakeCodexWith(options: FakeCodexOptions): FakeCli {
                         // assertion rather than on a timeout.
                         pendingSteer = false;
                         turnCompleted('failed');
+
                         return;
                     }
+
                     out({ id, result: { turnId } });
+
                     if (pendingSteer) {
                         pendingSteer = false;
                         const input = Array.isArray(params.input) ? (params.input[0] as { text?: string } | undefined) : undefined;
                         agentMessage(`you chose ${input?.text ?? 'no answer'}`);
                         turnCompleted('completed');
                     }
+
                     return;
                 }
                 case 'turn/interrupt':
                     out({ id, result: {} });
+
                     if (slow) {
                         slow = false;
                         turnCompleted('interrupted');
                     }
+
                     return;
                 case 'thread/goal/get':
                     out({ id, result: { goal } });
+
                     return;
                 case 'thread/goal/set': {
                     const at = Math.floor(Date.now() / 1000);
+
                     if (typeof params.objective === 'string') {
                         goal = {
                             threadId,
@@ -594,26 +702,34 @@ export function fakeCodexWith(options: FakeCodexOptions): FakeCli {
                             createdAt: at,
                             updatedAt: at
                         };
+
                         goalSteps = 0;
                     }
+
                     if (goal === null) {
                         out({ id, error: { code: -32600, message: 'no goal to update' } });
+
                         return;
                     }
+
                     if (typeof params.status === 'string') {
                         goal = { ...goal, status: params.status, updatedAt: at };
                     }
+
                     out({ id, result: { goal } });
                     goalChanged();
+
                     return;
                 }
                 case 'thread/goal/clear': {
                     const cleared = goal !== null;
                     goal = null;
                     out({ id, result: { cleared } });
+
                     if (cleared) {
                         notify('thread/goal/cleared', { threadId });
                     }
+
                     return;
                 }
                 case 'thread/compact/start':
@@ -622,6 +738,7 @@ export function fakeCodexWith(options: FakeCodexOptions): FakeCli {
                     started(item('contextCompaction', {}));
                     completed(item('contextCompaction', {}));
                     turnCompleted('completed');
+
                     return;
                 default:
                     out({ id, error: { code: -32601, message: `unknown method ${method}` } });
@@ -632,16 +749,21 @@ export function fakeCodexWith(options: FakeCodexOptions): FakeCli {
             onLine: (line) => {
                 const frame = JSON.parse(line) as Frame;
                 const params = (frame.params ?? {}) as Frame;
+
                 if (typeof frame.method === 'string' && frame.id !== undefined) {
                     handleRequest(frame.id, frame.method, params);
+
                     return;
                 }
+
                 if (frame.id === undefined || frame.result === undefined) {
                     return;
                 }
+
                 const result = frame.result as Frame;
                 const approval = pendingApproval;
                 const question = pendingQuestion;
+
                 if (approval && approval.rpcId === frame.id) {
                     handleApprovalResponse(approval, result);
                 } else if (question && question.rpcId === frame.id) {

package/src/testing/manual-clock.ts

@@ -13,6 +13,7 @@ export class ManualClock implements OutboxClock {
     setTimeout(run: () => void, ms: number): unknown {
         const id = this.nextId++;
         this.timers.push({ at: this.time + ms, run, id });
+
         return id;
     }
 
@@ -24,6 +25,7 @@ export class ManualClock implements OutboxClock {
         this.time += ms;
         const due = this.timers.filter((timer) => timer.at <= this.time);
         this.timers = this.timers.filter((timer) => timer.at > this.time);
+
         for (const timer of due) {
             timer.run();
         }

package/src/testing/watch.ts

@@ -17,6 +17,7 @@ export class FakeDirectoryWatcher implements DirectoryWatcher {
         if (this.closed) {
             return;
         }
+
         this.listener(event, filename);
     }
 
@@ -41,18 +42,19 @@ export class FakeWatch implements WatchSeams {
     readonly watch: WatchDirectory = (path, options, listener) => {
         const watcher = new FakeDirectoryWatcher(path, options.recursive, listener);
         this.watchers.push(watcher);
+
         return watcher;
     };
 
     readonly schedule = (callback: () => unknown, _ms: number): (() => void) => {
         const id = this.nextId++;
         this.due.set(id, callback);
+
         return () => {
             this.due.delete(id);
         };
     };
 
-    /* How many timers are waiting to run. */
     get pending(): number {
         return this.due.size;
     }
@@ -64,9 +66,11 @@ export class FakeWatch implements WatchSeams {
     /* The one open watcher on `path`, which a test that emits on it expects to exist. */
     on(path: string): FakeDirectoryWatcher {
         const [watcher, ...rest] = this.openOn(path);
+
         if (!watcher || rest.length > 0) {
             throw new Error(`Expected one open watcher on ${path}, found ${rest.length + (watcher ? 1 : 0)}`);
         }
+
         return watcher;
     }
 
@@ -86,6 +90,7 @@ export class EventLog<T> {
         this.events.push(event);
         const ready = this.waiters.filter((waiter) => waiter.check(this.events));
         this.waiters = this.waiters.filter((waiter) => !ready.includes(waiter));
+
         for (const waiter of ready) {
             waiter.resolve();
         }
@@ -95,6 +100,7 @@ export class EventLog<T> {
         if (check(this.events)) {
             return Promise.resolve();
         }
+
         return new Promise((resolve) => {
             this.waiters.push({ check, resolve });
         });

package/src/title-file.ts

@@ -12,10 +12,13 @@ export function cleanTitle(raw: unknown): string | null {
     if (typeof raw !== 'string') {
         return null;
     }
+
     const text = raw.replace(CONTROL, ' ').replace(/\s+/g, ' ').trim();
+
     if (text === '') {
         return null;
     }
+
     return text.length <= SUGGESTED_TITLE_LIMIT ? text : `${clipText(text, SUGGESTED_TITLE_LIMIT - 1).trimEnd()}…`;
 }
 
@@ -28,30 +31,39 @@ export function cleanTitle(raw: unknown): string | null {
 export async function readLines(path: string, from: number, size: number, chunkBytes: number, onLine: (line: string) => void): Promise<number> {
     const handle = await open(path, 'r');
     let offset = from;
+
     try {
         let carry = Buffer.alloc(0);
         let position = from;
+
         while (position < size) {
             const piece = Buffer.alloc(Math.min(chunkBytes, size - position));
             const { bytesRead } = await handle.read(piece, 0, piece.length, position);
+
             if (bytesRead === 0) {
                 break;
             }
+
             position += bytesRead;
             const bytes = Buffer.concat([carry, piece.subarray(0, bytesRead)]);
             const end = bytes.lastIndexOf(0x0a);
+
             if (end < 0) {
                 carry = bytes;
+
                 continue;
             }
+
             for (const line of bytes.subarray(0, end).toString('utf8').split('\n')) {
                 onLine(line);
             }
+
             carry = bytes.subarray(end + 1);
             offset = position - carry.length;
         }
     } finally {
         await handle.close();
     }
+
     return offset;
 }