@adecore/agents 0.38.0 → 0.40.0

package/src/chat/codex-thread.ts

@@ -18,6 +18,7 @@ export interface ThreadItemsParams {
 export function parseThreadItemsPage(result: unknown): { entries: Record<string, unknown>[]; nextCursor: string | null } {
     const data = isRecord(result) && Array.isArray(result.data) ? result.data.filter(isRecord) : [];
     const nextCursor = isRecord(result) && typeof result.nextCursor === 'string' && result.nextCursor !== '' ? result.nextCursor : null;
+
     return { entries: data, nextCursor };
 }
 
@@ -40,23 +41,31 @@ function userText(content: unknown): string {
 export function projectCodexItems(entriesOldestFirst: Record<string, unknown>[], now: number): ChatItem[] {
     const { thread, projector } = readingThread('Codex', () => now);
     const protocol = new CodexProtocol(0);
+
     for (const entry of entriesOldestFirst) {
         const item = isRecord(entry.item) ? entry.item : null;
+
         if (!item || typeof item.id !== 'string') {
             continue;
         }
+
         projector.reset();
+
         if (item.type === 'userMessage') {
             const text = userText(item.content);
+
             if (text !== '') {
                 thread.upsert({ id: `user-${item.id}`, kind: 'user', createdAt: now, turnId: null, text });
             }
+
             continue;
         }
+
         for (const event of protocol.handle({ method: 'item/completed', params: { item } })) {
             projector.project(0, event);
         }
     }
+
     return thread.list().map(settledReading);
 }
 
@@ -78,12 +87,15 @@ async function withAppServer<T>(spec: CodexProcessSpec, work: (transport: CodexT
         onFrame: () => undefined,
         onExit: () => undefined
     });
+
     try {
         await transport.request('initialize', {
             clientInfo: spec.client ?? DEFAULT_CODEX_CLIENT,
             capabilities: { experimentalApi: true, requestAttestation: false }
         });
+
         transport.notify('initialized', {});
+
         return await work(transport);
     } finally {
         transport.end();
@@ -112,17 +124,21 @@ export interface ThreadForkParams {
 async function nthTurnId(transport: CodexTransport, threadId: string, turns: number): Promise<string | null> {
     let seen = 0;
     let cursor: string | null = null;
+
     do {
         const page = parseThreadItemsPage(
             await transport.request('thread/turns/list', { threadId, limit: 100, sortDirection: 'asc', ...(cursor === null ? {} : { cursor }) })
         );
+
         for (const turn of page.entries) {
             if (++seen === turns) {
                 return typeof turn.id === 'string' ? turn.id : null;
             }
         }
+
         cursor = page.nextCursor;
     } while (cursor !== null);
+
     return null;
 }
 
@@ -134,13 +150,17 @@ async function nthTurnId(transport: CodexTransport, threadId: string, turns: num
 export function forkThreadOnce(spec: CodexProcessSpec, params: ThreadForkParams): Promise<string> {
     return withAppServer(spec, async (transport) => {
         let lastTurnId: string | null = null;
+
         if (params.at !== null) {
             lastTurnId = 'turnId' in params.at ? params.at.turnId : await nthTurnId(transport, params.threadId, params.at.turns);
+
             if (lastTurnId === null) {
                 throw new ChatError('turn-not-found', 'Codex keeps fewer turns in this thread than the chat shows, so the turn could not be found');
             }
         }
+
         let result: unknown;
+
         try {
             result = await transport.request('thread/fork', {
                 threadId: params.threadId,
@@ -151,10 +171,13 @@ export function forkThreadOnce(spec: CodexProcessSpec, params: ThreadForkParams)
         } catch (error) {
             throw new ChatError('fork-failed', errorText(error));
         }
+
         const thread = isRecord(result) && isRecord(result.thread) ? result.thread : null;
+
         if (thread === null || typeof thread.id !== 'string' || thread.id === '') {
             throw new ChatError('fork-failed', 'Codex answered the fork without a thread');
         }
+
         return thread.id;
     });
 }

package/src/chat/composer-preferences.ts

@@ -39,22 +39,27 @@ export class ComposerPreferences {
     /* The newest pick among the connected clients, narrowed to this provider; empty with none. */
     for(provider: AgentKind): ComposerPreference {
         const newest = this.newest();
+
         if (newest === null) {
             return {};
         }
+
         const { runtimeMode, selections, accounts } = newest.preference;
         const selection = selections?.[provider];
         const account = accounts?.[provider];
+
         return { ...(runtimeMode ? { runtimeMode } : {}), ...(selection ? { selection } : {}), ...(account ? { account } : {}) };
     }
 
     private newest(): Held | null {
         let newest: Held | null = null;
+
         for (const held of this.byClient.values()) {
             if (newest === null || isNewer(held, newest)) {
                 newest = held;
             }
         }
+
         return newest;
     }
 }
@@ -62,5 +67,6 @@ export class ComposerPreferences {
 function isNewer(held: Held, than: Held): boolean {
     const changedAt = held.preference.changedAt ?? 0;
     const otherChangedAt = than.preference.changedAt ?? 0;
+
     return changedAt === otherChangedAt ? held.told > than.told : changedAt > otherChangedAt;
 }

package/src/chat/context-breakdown.ts

@@ -21,6 +21,7 @@ function inputTokens(input: unknown): number {
     if (input === undefined || input === null) {
         return 0;
     }
+
     return textTokens(typeof input === 'string' ? input : JSON.stringify(input));
 }
 
@@ -35,27 +36,33 @@ export function estimateContextBreakdown(items: readonly ChatItem[], contextToke
     let filesRead = 0;
     let conversation = 0;
     const start = items.findLastIndex((item) => item.kind === 'compaction') + 1;
+
     for (const item of items.slice(start)) {
         switch (item.kind) {
             case 'user':
                 conversation += textTokens(item.text);
                 filesRead += (item.attachments ?? []).filter((attachment) => attachmentImageMime(attachment) !== null).length * IMAGE_TOKENS;
+
                 break;
             case 'assistant':
                 if (!item.parentToolUseId) {
                     conversation += textTokens(item.text);
                 }
+
                 break;
             case 'tool': {
                 if (item.parentToolUseId !== null) {
                     break;
                 }
+
                 const tokens = inputTokens(item.input) + textTokens(item.output ?? item.progress?.output ?? '');
+
                 if (isReadTool(item.name)) {
                     filesRead += tokens;
                 } else {
                     toolOutput += tokens;
                 }
+
                 break;
             }
             case 'subagent':
@@ -63,18 +70,22 @@ export function estimateContextBreakdown(items: readonly ChatItem[], contextToke
                 if (item.origin !== HOST_TASK_ORIGIN) {
                     toolOutput += textTokens(item.prompt ?? '') + textTokens(item.result ?? '');
                 }
+
                 break;
             default:
                 break;
         }
     }
+
     const total = Math.max(0, Math.round(contextTokens));
     const estimated = toolOutput + filesRead + conversation;
     const scale = estimated > total ? total / estimated : 1;
+
     const parts = {
         toolOutput: Math.floor(toolOutput * scale),
         filesRead: Math.floor(filesRead * scale),
         conversation: Math.floor(conversation * scale)
     };
+
     return { ...parts, system: Math.max(0, total - parts.toolOutput - parts.filesRead - parts.conversation) };
 }

package/src/chat/delta-coalescer.ts

@@ -24,12 +24,16 @@ export class DeltaCoalescer {
         if (event.type !== 'delta' || event.uiQueries !== undefined) {
             this.flush();
             this.send(event);
+
             return;
         }
+
         if (this.pending !== null && this.pending.itemId === event.itemId) {
             this.pending.text += event.text;
+
             return;
         }
+
         this.flush();
         this.pending = { itemId: event.itemId, text: event.text };
         this.timer = setTimeout(() => this.flush(), this.tickMs);
@@ -43,10 +47,13 @@ export class DeltaCoalescer {
             clearTimeout(this.timer);
             this.timer = null;
         }
+
         const pending = this.pending;
+
         if (pending === null) {
             return;
         }
+
         this.pending = null;
         this.send({ type: 'delta', itemId: pending.itemId, text: pending.text });
     }
@@ -57,6 +64,7 @@ export class DeltaCoalescer {
             clearTimeout(this.timer);
             this.timer = null;
         }
+
         this.pending = null;
     }
 }

package/src/chat/external-sessions.ts

@@ -33,13 +33,16 @@ function titleOf(text: string): string {
 
 function records(head: string): Array<Record<string, unknown>> {
     const lines = head.split('\n');
+
     // The head ends wherever the byte limit fell, so its last line may not parse.
     return lines.flatMap((line) => {
         if (line === '') {
             return [];
         }
+
         try {
             const parsed: unknown = JSON.parse(line);
+
             return isRecord(parsed) ? [parsed] : [];
         } catch {
             return [];
@@ -54,11 +57,14 @@ function claudePrompt(entry: Record<string, unknown>): string | null {
     if (CLAUDE_BOOKKEEPING.has(String(entry.type)) || entry.type !== 'user' || entry.isSidechain === true || entry.isMeta === true) {
         return null;
     }
+
     const message = typeof entry.message === 'object' && entry.message !== null ? (entry.message as Record<string, unknown>) : {};
     const said = spokenText(message.content);
+
     if (said === null || said.trim() === '' || said.startsWith('<command-') || said.startsWith('<local-command-')) {
         return null;
     }
+
     return said;
 }
 
@@ -71,30 +77,38 @@ export async function listClaudeSessions({ projectsDir, folder, fs }: { projects
     const dir = join(projectsDir, claudeProjectSlug(folder));
     const names = (await fs.readdir(dir)).filter((name) => name.endsWith('.jsonl'));
     const stats = await Promise.all(names.map(async (name) => ({ name, stat: await fs.stat(join(dir, name)) })));
+
     const newest = stats
         .flatMap(({ name, stat }) => (stat === null ? [] : [{ name, mtimeMs: stat.mtimeMs }]))
         .sort((left, right) => right.mtimeMs - left.mtimeMs)
         .slice(0, CLAUDE_MAX_FILES);
+
     const sessions: ExternalSession[] = [];
+
     for (const { name, mtimeMs } of newest) {
         const prompt = records(await fs.readHead(join(dir, name), HEAD_BYTES))
             .map(claudePrompt)
             .find((said) => said !== null);
+
         if (prompt !== undefined && prompt !== null) {
             sessions.push({ provider: 'claude', sessionId: name.slice(0, -'.jsonl'.length), title: titleOf(prompt), updatedAt: mtimeMs, cwd: folder });
         }
     }
+
     return sessions;
 }
 
 function codexPrompt(entry: Record<string, unknown>): string | null {
     const payload = typeof entry.payload === 'object' && entry.payload !== null ? (entry.payload as Record<string, unknown>) : null;
+
     if (payload === null) {
         return null;
     }
+
     if (entry.type === 'event_msg' && payload.type === 'user_message' && typeof payload.message === 'string') {
         return payload.message.trim() === '' ? null : payload.message;
     }
+
     return null;
 }
 
@@ -105,14 +119,17 @@ function newestFirst(names: string[]): string[] {
 
 async function rolloutFiles(sessionsDir: string, fs: SessionFs, max: number): Promise<string[]> {
     const files: string[] = [];
+
     for (const year of newestFirst(await fs.readdir(sessionsDir))) {
         for (const month of newestFirst(await fs.readdir(join(sessionsDir, year)))) {
             for (const day of newestFirst(await fs.readdir(join(sessionsDir, year, month)))) {
                 const names = newestFirst(
                     (await fs.readdir(join(sessionsDir, year, month, day))).filter((name) => name.startsWith('rollout-') && name.endsWith('.jsonl'))
                 );
+
                 for (const name of names) {
                     files.push(join(sessionsDir, year, month, day, name));
+
                     if (files.length >= max) {
                         return files;
                     }
@@ -120,6 +137,7 @@ async function rolloutFiles(sessionsDir: string, fs: SessionFs, max: number): Pr
             }
         }
     }
+
     return files;
 }
 
@@ -139,35 +157,45 @@ export async function listCodexSessions({
     maxFiles?: number;
 }): Promise<ExternalSession[]> {
     const sessions: ExternalSession[] = [];
+
     for (const path of await rolloutFiles(sessionsDir, fs, maxFiles)) {
         const entries = records(await fs.readHead(path, HEAD_BYTES));
         const meta = entries[0];
+
         const payload =
             meta?.type === 'session_meta' && typeof meta.payload === 'object' && meta.payload !== null ? (meta.payload as Record<string, unknown>) : null;
+
         if (payload === null || payload.cwd !== folder || typeof payload.id !== 'string' || isForkOrSubagent(payload)) {
             continue;
         }
+
         const prompt = entries.map(codexPrompt).find((said) => said !== null);
+
         if (prompt === undefined || prompt === null) {
             continue;
         }
+
         const stat = await fs.stat(path);
         sessions.push({ provider: 'codex', sessionId: payload.id, title: titleOf(prompt), updatedAt: stat?.mtimeMs ?? 0, cwd: folder });
     }
+
     return sessions;
 }
 
 /* A `node:fs` behind the seam, for a host that lists the real thing. */
 export async function nodeSessionFs(): Promise<SessionFs> {
     const { readdir, stat, open } = await import('node:fs/promises');
+
     return {
         readdir: async (path) => readdir(path).catch(() => []),
         stat: async (path) => stat(path).catch(() => null),
         readHead: async (path, maxBytes) => {
             const handle = await open(path, 'r');
+
             try {
                 const buffer = Buffer.alloc(maxBytes);
                 const { bytesRead } = await handle.read(buffer, 0, maxBytes, 0);
+
                 return buffer.subarray(0, bytesRead).toString('utf8');
             } finally {
                 await handle.close();

package/src/chat/generated-image.ts

@@ -16,9 +16,11 @@ function imageInfo(bytes: Buffer): ImageInfo | null {
     ) {
         return { mime: 'image/png', extension: 'png', width: bytes.readUInt32BE(16), height: bytes.readUInt32BE(20) };
     }
+
     if (bytes.length >= 13 && /GIF8[79]a/.test(bytes.toString('ascii', 0, 6))) {
         return { mime: 'image/gif', extension: 'gif', width: bytes.readUInt16LE(6), height: bytes.readUInt16LE(8) };
     }
+
     if (
         bytes.length >= 20 &&
         bytes.toString('ascii', 0, 4) === 'RIFF' &&
@@ -26,56 +28,77 @@ function imageInfo(bytes: Buffer): ImageInfo | null {
         bytes.readUInt32LE(4) + 8 === bytes.length
     ) {
         const kind = bytes.toString('ascii', 12, 16);
+
         if (kind === 'VP8X' && bytes.length >= 30) {
             return { mime: 'image/webp', extension: 'webp', width: bytes.readUIntLE(24, 3) + 1, height: bytes.readUIntLE(27, 3) + 1 };
         }
+
         if (kind === 'VP8 ' && bytes.length >= 30 && bytes.subarray(23, 26).equals(Buffer.from([157, 1, 42]))) {
             return { mime: 'image/webp', extension: 'webp', width: bytes.readUInt16LE(26) & 0x3fff, height: bytes.readUInt16LE(28) & 0x3fff };
         }
+
         if (kind === 'VP8L' && bytes.length >= 25 && bytes[20] === 0x2f) {
             const size = bytes.readUInt32LE(21);
+
             return { mime: 'image/webp', extension: 'webp', width: (size & 0x3fff) + 1, height: ((size >> 14) & 0x3fff) + 1 };
         }
+
         return null;
     }
+
     if (bytes.length >= 4 && bytes[0] === 255 && bytes[1] === 216 && bytes[2] === 255) {
         let offset = 2;
+
         while (offset + 4 <= bytes.length && bytes[offset] === 255) {
             const marker = bytes[offset + 1]!;
+
             if (marker === 218 || marker === 217) {
                 break;
             }
+
             if (marker === 255) {
                 offset++;
+
                 continue;
             }
+
             const size = bytes.readUInt16BE(offset + 2);
+
             if (size < 2 || offset + 2 + size > bytes.length) {
                 return null;
             }
+
             if ([192, 193, 194, 195, 197, 198, 199, 201, 202, 203, 205, 206, 207].includes(marker) && size >= 8) {
                 return { mime: 'image/jpeg', extension: 'jpg', width: bytes.readUInt16BE(offset + 7), height: bytes.readUInt16BE(offset + 5) };
             }
+
             offset += size + 2;
         }
     }
+
     return null;
 }
 
 export function generatedImage(data: string, prompt?: string): { upload: ChatAttachmentUpload; width?: number; height?: number } {
     const parsed = ChatAttachmentUploadSchema.safeParse({ name: 'image', mime: 'application/octet-stream', data });
+
     if (!parsed.success) {
         throw new Error('The generated image is empty, invalid base64 or exceeds 10 MiB');
     }
+
     const bytes = Buffer.from(data, 'base64');
+
     // Buffer's decoder accepts malformed padding and trailing bits; the protocol requires canonical base64.
     if (bytes.toString('base64') !== data) {
         throw new Error('The generated image contains invalid base64');
     }
+
     const info = imageInfo(bytes);
+
     if (info === null || (info.width !== undefined && info.width === 0) || (info.height !== undefined && info.height === 0)) {
         throw new Error('The generated bytes are not a supported image');
     }
+
     const stem =
         (prompt ?? '')
             .normalize('NFKD')
@@ -83,6 +106,8 @@ export function generatedImage(data: string, prompt?: string): { upload: ChatAtt
             .replace(/^-|-$/g, '')
             .slice(0, 80)
             .toLowerCase() || 'generated-image';
+
     const upload = { name: `${stem}.${info.extension}`, mime: info.mime, data };
+
     return { upload, ...(info.width === undefined ? {} : { width: info.width }), ...(info.height === undefined ? {} : { height: info.height }) };
 }

package/src/chat/index.ts

@@ -1,5 +1,6 @@
 // Public API: exports.test.ts snapshots this list, so a name added or dropped here is an API change.
 export { type AcpAgentSpec, type AcpClientInfo, type AcpUsageReport, createAcpBackend } from './acp-backend.ts';
+
 export type {
     AcpAgentInfo,
     AcpModel,
@@ -13,12 +14,14 @@ export type {
     AcpThoughtLevel,
     AcpTurnUsage
 } from './acp-protocol.ts';
+
 export { AttachmentStore } from './attachment-store.ts';
 export type { BackendLaunch, TurnInput, ApprovalDecision, BackendEvent, BackendHost, ChatBackend } from './backend.ts';
 export { runningInBackground, type BackgroundWork } from './background-work.ts';
 export { BookmarkStore, type BookmarkListener } from './bookmark-store.ts';
 export { type InterruptedRun, type ChatCoreHooks, type ChatCoreOptions, ChatCore } from './chat-core.ts';
 export { COMPACT_ABOVE_BYTES, type ChatLogLine } from './chat-log.ts';
+
 export {
     type ChatSpawnOptions,
     type SpawnChatProcess,
@@ -29,6 +32,7 @@ export {
     type ChatProcess,
     type ChatChildOptions
 } from './chat-process.ts';
+
 export {
     type PromptNotes,
     type ChatReferences,
@@ -40,6 +44,7 @@ export {
     type ChatSendExtras,
     type ResumeDecision
 } from './chat-session.ts';
+
 export { type ChatRecordExtras, type ChatRecord, ChatStore, type ChatSeq, type ChatStoreOptions } from './chat-store.ts';
 export { suggestChatTitle, type ChatTitleInput } from './chat-title.ts';
 export type { ClaudeBackendOptions } from './claude-backend.ts';

package/src/chat/input.ts

@@ -22,27 +22,34 @@ function isTokenEnd(char: string | undefined): boolean {
 function findSkillToken(text: string, name: string, from: number): number {
     const token = `$${name}`;
     let index = text.indexOf(token, from);
+
     while (index >= 0) {
         if (isBoundary(text[index - 1]) && isTokenEnd(text[index + token.length])) {
             return index;
         }
+
         index = text.indexOf(token, index + 1);
     }
+
     return -1;
 }
 
 /* The last `$name` in the text that names one of the skills, longest name first on a tie. */
 export function lastSkillToken(text: string, skills: string[]): { index: number; name: string } | null {
     let best: { index: number; name: string } | null = null;
+
     for (const name of [...new Set(skills)].sort((a, b) => b.length - a.length)) {
         let index = findSkillToken(text, name, 0);
+
         while (index >= 0) {
             if (best === null || index > best.index) {
                 best = { index, name };
             }
+
             index = findSkillToken(text, name, index + 1);
         }
     }
+
     return best;
 }
 
@@ -55,11 +62,14 @@ export function lastSkillToken(text: string, skills: string[]): { index: number;
  */
 export function splitSkillPrompt(text: string, skills: string[]): { lead: string; invocation: string | null } {
     const last = lastSkillToken(text, skills);
+
     if (last === null) {
         return { lead: text, invocation: null };
     }
+
     const lead = text.slice(0, last.index).replace(/\$([A-Za-z][A-Za-z0-9_:-]*)/g, (match, name: string) => (skills.includes(name) ? `/${name}` : match));
     const rest = text.slice(last.index + last.name.length + 1).replace(/^[ \t]+/, '');
+
     return { lead: lead.trimEnd(), invocation: rest === '' ? `/${last.name}` : `/${last.name} ${rest}` };
 }
 
@@ -79,11 +89,14 @@ export function buildUserMessage({ text, attachments = [], prefix = '', skills =
     const note = attachmentNote(attachments);
     // The prefix must be the first thing the model reads, so it joins the leading block.
     const prompt = [`${prefix}${lead}`.trimEnd(), note].filter((part) => part.trim() !== '').join('\n\n');
+
     if (prompt !== '') {
         content.push({ type: 'text', text: prompt });
     }
+
     if (invocation !== null) {
         content.push({ type: 'text', text: invocation });
     }
+
     return { type: 'user', message: { role: 'user', content }, parent_tool_use_id: null, session_id: '', ...(promptId ? { uuid: promptId } : {}) };
 }