@adecore/agents 0.38.0 → 0.40.0

package/dist/providers/codex.js

@@ -28,7 +28,6 @@ const CODEX_PRIORITY_TIER = 'priority';
 export function codexServiceTier(selection) {
     return selection.options.serviceTier === true ? CODEX_PRIORITY_TIER : null;
 }
-// What the app-server can do, as far as a client has to know.
 export const CODEX_CAPABILITIES = {
     chat: true,
     terminal: true,

package/dist/providers/detect.js

@@ -16,7 +16,7 @@ export async function detectCli(command, env = process.env, spawn = spawnChatPro
         if ((await code) !== 0) {
             return { installed: false, version: null };
         }
-        const version = /\d+\.\d+\.\d+/.exec(output)?.[0] ?? output.trim() ?? null;
+        const version = /\d+\.\d+\.\d+/.exec(output)?.[0] ?? output.trim();
         return { installed: true, version };
     }
     catch {

package/dist/providers/shell-commands.js

@@ -4,8 +4,7 @@ const REFUSED = new Set(['|', '>', '<', '$', '`', '(', ')', '{', '}', '*', '?',
 /*
  * Whether a shell command line is only simple commands, joined by `&&`, `||`, `;` or newlines, each of
  * which starts with one of `allowed`. Anything the tokenizer cannot prove simple answers false, so a
- * true is safe to act on without a person: a pipe, a redirect, an expansion, a subshell, a background
- * `&`, an unquoted glob or an unbalanced quote all refuse the whole line.
+ * true is safe to act on without a person.
  */
 export function isOnlyCommands(command, allowed) {
     let word = '';

package/dist/run-process.js

@@ -1,8 +1,6 @@
 import { spawn } from 'node:child_process';
-import { killProcessTree } from './chat/chat-process.js';
+import { KILL_GRACE_MS, killProcessTree } from './chat/chat-process.js';
 import { spawnTarget } from './windows-command.js';
-// What a command and everything it started get between the SIGTERM and the SIGKILL.
-const KILL_GRACE_MS = 2000;
 // Stdout and stderr together; a short command that prints more is ended and fails instead of filling memory.
 const MAX_OUTPUT_BYTES = 16 * 1024 * 1024;
 /* One short command to its end, with what it printed. A command that cannot start rejects. */

package/dist/skills.d.ts

@@ -17,7 +17,7 @@ export interface SkillRootOptions {
 export declare function parseFrontmatter(text: string): Record<string, string>;
 export declare function pluginSkillRoots(configDir: string): Promise<SkillRoot[]>;
 export declare function skillRootsFor(kind: AgentKind, cwd: string, options?: SkillRootOptions): Promise<SkillRoot[]>;
-export declare function whileBusy<T>(operation: () => Promise<T>, wait?: (ms: number) => Promise<void>): Promise<T>;
+export declare function whileBusy<T>(operation: () => Promise<T>, sleep?: (ms: number) => Promise<void>): Promise<T>;
 export declare function mapLimited<T, R>(items: readonly T[], limit: number, work: (item: T) => Promise<R>): Promise<R[]>;
 export declare function scanSkillRoots(roots: SkillRoot[], limits?: SkillScanLimits): Promise<ChatSkill[]>;
 export declare function discoverSkills(kind: AgentKind, cwd: string, options?: SkillRootOptions): Promise<ChatSkill[]>;

package/dist/skills.js

@@ -2,7 +2,8 @@ import { existsSync } from 'node:fs';
 import { open, readdir, readFile, realpath, stat } from 'node:fs/promises';
 import { homedir } from 'node:os';
 import { dirname, join, parse } from 'node:path';
-import { isNotFound } from './fs.js';
+import { wait } from './async.js';
+import { hasErrorCode, isNotFound } from './fs.js';
 const SCAN_LIMITS = { directories: 2000, skills: 1000 };
 const ENTRIES_PER_FOLDER = 1000;
 // Paths one folder resolves or reads at once, so a large folder never runs the process out of file handles.
@@ -143,13 +144,10 @@ export async function skillRootsFor(kind, cwd, options = {}) {
 }
 /* Too many files open, in this process or on the system: it says nothing about the path that was asked for. */
 function isBusy(e) {
-    return typeof e === 'object' && e !== null && 'code' in e && (e.code === 'EMFILE' || e.code === 'ENFILE');
-}
-function sleep(ms) {
-    return new Promise((resolve) => setTimeout(resolve, ms));
+    return hasErrorCode(e, 'EMFILE', 'ENFILE');
 }
 /* Runs `operation` again a few times while the process is short of file handles, and throws if it still is. */
-export async function whileBusy(operation, wait = sleep) {
+export async function whileBusy(operation, sleep = wait) {
     for (let attempt = 1;; attempt++) {
         try {
             return await operation();
@@ -158,7 +156,7 @@ export async function whileBusy(operation, wait = sleep) {
             if (!isBusy(e) || attempt > BUSY_RETRIES) {
                 throw e;
             }
-            await wait(BUSY_RETRY_MS * attempt);
+            await sleep(BUSY_RETRY_MS * attempt);
         }
     }
 }
@@ -310,7 +308,6 @@ export async function scanSkillRoots(roots, limits = SCAN_LIMITS) {
 export async function discoverSkills(kind, cwd, options = {}) {
     return scanSkillRoots(await skillRootsFor(kind, cwd, options));
 }
-// How long a scan stays good; a skill written mid-session shows up on the next look.
 const CACHE_TTL_MS = 30_000;
 /* The skills of one CLI in one folder, scanned at most once per half minute. There is no watcher. */
 export class SkillIndex {

package/dist/tasks/background-limit.js

@@ -41,12 +41,13 @@ export async function restartBackgroundLimits(outbox, now) {
 }
 /* The `background-limit` entries of a host's outbox, one per task at most, as the coordinator owes and drops them. */
 export function backgroundLimits(outbox) {
+    const limitOf = (entry, taskId) => isBackgroundLimit(entry) && entry.payload.taskId === taskId;
     return {
-        owed: (taskId) => outbox.list().some((entry) => isBackgroundLimit(entry) && entry.payload.taskId === taskId),
+        owed: (taskId) => outbox.list().some((entry) => limitOf(entry, taskId)),
         owe: (task, commands, at) => outbox.enqueue(task.projectId, task.childId, { kind: 'background-limit', payload: { taskId: task.id, commands: [...commands] } }, at),
         lapse: async (taskId) => {
             for (const entry of outbox.list()) {
-                if (isBackgroundLimit(entry) && entry.payload.taskId === taskId) {
+                if (limitOf(entry, taskId)) {
                     await outbox.remove(entry.id);
                 }
             }

package/dist/tasks/task-coordinator.js

@@ -52,11 +52,9 @@ export function resultOfTurn(turn, items, 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 {
     deps;
@@ -114,14 +112,9 @@ export class TaskCoordinator {
      * which says how that kind of agent reports back.
      */
     agentEnded(childId, text) {
-        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, error) {
         this.failed(childId, `The agent could not be started: ${errorText(error)}`);
@@ -183,7 +176,7 @@ 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.
      */
     answers(items, turn, task) {
         if ((turn.taskIds ?? []).includes(task.id)) {
@@ -216,7 +209,7 @@ export class TaskCoordinator {
             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, {
                 turnId: turn.id,
@@ -247,13 +240,14 @@ export class TaskCoordinator {
         if (background.itemIds.length === 0 && this.deps.limit.owed(task.id)) {
             return;
         }
+        const rowOf = (id) => 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', {
@@ -264,7 +258,7 @@ export class TaskCoordinator {
             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] : [];
         });

package/dist/testing/watch.js

@@ -42,7 +42,6 @@ export class FakeWatch {
             this.due.delete(id);
         };
     };
-    /* How many timers are waiting to run. */
     get pending() {
         return this.due.size;
     }

package/dist/usage/limits/monitor.js

@@ -193,7 +193,6 @@ export class UsageMonitor {
         return this.probe(account.kind, this.registry.get(account.kind).command, env);
     }
     emit() {
-        const event = { event: 'usage.limitsChanged', payload: this.snapshot() };
-        this.sinks.emit(event);
+        this.sinks.emit({ event: 'usage.limitsChanged', payload: this.snapshot() });
     }
 }

package/dist/usage/readers/claude.js

@@ -1,4 +1,4 @@
-import { asObject, asString, int } from '../record.js';
+import { asObject, asString, countsTokens, int, parseObject } from '../record.js';
 /* Only a line with this in it can carry counts, which keeps `JSON.parse` off about two thirds of them. */
 export function claudeMightCarryUsage(line) {
     return line.includes('"usage"');
@@ -9,14 +9,7 @@ export function claudeMightCarryUsage(line) {
  * Anthropic's, so `input_tokens` already excludes what was read from or written to the cache.
  */
 export function parseClaudeLine(line) {
-    let parsed;
-    try {
-        parsed = JSON.parse(line);
-    }
-    catch {
-        return null;
-    }
-    const record = asObject(parsed);
+    const record = parseObject(line);
     if (record === null || record.type !== 'assistant') {
         return null;
     }
@@ -44,7 +37,7 @@ export function parseClaudeLine(line) {
         output: int(usage.output_tokens),
         reasoning: outputDetails === null ? 0 : int(outputDetails.thinking_tokens)
     };
-    if (totals.input + totals.cacheRead + totals.cacheWrite + totals.output === 0) {
+    if (!countsTokens(totals)) {
         return null;
     }
     return {

package/dist/usage/readers/codex.js

@@ -1,4 +1,4 @@
-import { asObject, asString, int } from '../record.js';
+import { asObject, asString, int, parseObject } from '../record.js';
 export function codexMightCarryUsage(line) {
     return ['token_count', 'turn_context', 'session_meta', 'thread_settings_applied', 'token_usage_record', 'compacted'].some((type) => line.includes(type));
 }
@@ -59,14 +59,7 @@ export function isForkOrSubagent(payload) {
 /* Codex includes cache reads and writes in input_tokens. Compaction can appear separately from
    cumulative token_count events, so response identities prevent charging the same request twice. */
 export function parseCodexLine(line, state) {
-    let parsed;
-    try {
-        parsed = JSON.parse(line);
-    }
-    catch {
-        return null;
-    }
-    const record = asObject(parsed);
+    const record = parseObject(line);
     const payload = record === null ? null : asObject(record.payload);
     if (record === null || payload === null) {
         return null;

package/dist/usage/readers/grok.js

@@ -1,5 +1,5 @@
 import { basename, dirname } from 'node:path';
-import { asObject, asString, int } from '../record.js';
+import { asObject, asString, countsTokens, int, parseObject } from '../record.js';
 /* The file Grok keeps the counts of a session in, beside its other files in the session's folder. */
 export const GROK_USAGE_FILE = 'usage.json';
 // `costUsdTicks` counts in ticks of 10^-10 USD, as Grok's own docs on `grok usage` say.
@@ -26,7 +26,7 @@ function recordOf(counts, model, base, turn) {
         output: int(counts.outputTokens),
         reasoning: int(counts.reasoningTokens)
     };
-    if (totals.input + totals.cacheRead + totals.cacheWrite + totals.output === 0) {
+    if (!countsTokens(totals)) {
         return null;
     }
     const ticks = int(counts.costUsdTicks);
@@ -45,14 +45,7 @@ function recordOf(counts, model, base, turn) {
  * read as one, which leaves what the scanner held of it.
  */
 export function parseGrokUsage(text, path) {
-    let parsed;
-    try {
-        parsed = JSON.parse(text);
-    }
-    catch {
-        return null;
-    }
-    const file = asObject(parsed);
+    const file = parseObject(text);
     if (file === null || !Array.isArray(file.turns)) {
         return null;
     }

package/dist/usage/readers/host-log.js

@@ -1,4 +1,4 @@
-import { asObject, asString, int } from '../record.js';
+import { asString, countsTokens, int, parseObject } from '../record.js';
 export function hostUsageLine(entry) {
     return `${JSON.stringify(entry)}\n`;
 }
@@ -8,14 +8,7 @@ export function hostLogMightCarryUsage(line) {
 }
 /* The provider is the root's, so one reader serves every API a host logs. */
 export function parseHostUsageLine(line, provider) {
-    let parsed;
-    try {
-        parsed = JSON.parse(line);
-    }
-    catch {
-        return null;
-    }
-    const entry = asObject(parsed);
+    const entry = parseObject(line);
     if (entry === null) {
         return null;
     }
@@ -33,7 +26,7 @@ export function parseHostUsageLine(line, provider) {
         output: int(entry.output),
         reasoning: int(entry.reasoning)
     };
-    if (totals.input + totals.cacheRead + totals.cacheWrite + totals.output === 0) {
+    if (!countsTokens(totals)) {
         return null;
     }
     return {

package/dist/usage/record.d.ts

@@ -13,5 +13,7 @@ export interface UsageRecord {
 }
 export declare function int(value: unknown): number;
 export declare function asObject(value: unknown): Record<string, unknown> | null;
+export declare function parseObject(text: string): Record<string, unknown> | null;
+export declare function countsTokens(totals: UsageTotals): boolean;
 export declare function asString(value: unknown): string;
 export declare function foldByKey(records: readonly UsageRecord[]): UsageRecord[];

package/dist/usage/record.js

@@ -6,6 +6,19 @@ export function int(value) {
 export function asObject(value) {
     return typeof value === 'object' && value !== null ? value : null;
 }
+/* A line or file of a transcript as a JSON object, or null for anything else. */
+export function parseObject(text) {
+    try {
+        return asObject(JSON.parse(text));
+    }
+    catch {
+        return null;
+    }
+}
+/* Whether a call moved any tokens at all; one that moved none is not a call worth a record. */
+export function countsTokens(totals) {
+    return totals.input + totals.cacheRead + totals.cacheWrite + totals.output !== 0;
+}
 export function asString(value) {
     return typeof value === 'string' ? value : '';
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adecore/agents",
-  "version": "0.38.0",
+  "version": "0.40.0",
   "description": "Node-compatible agent chat hosts, providers, accounts, usage and durable task coordination.",
   "type": "module",
   "exports": {
@@ -81,13 +81,13 @@
     "test": "bun --conditions=source test"
   },
   "dependencies": {
-    "@adecore/agent-contracts": "0.38.0",
-    "@adecore/intelligent-ui": "0.38.0",
-    "zod": "^4.6.5"
+    "@adecore/agent-contracts": "0.40.0",
+    "@adecore/intelligent-ui": "0.40.0",
+    "zod": "^4.6.7"
   },
   "devDependencies": {
-    "@types/bun": "^1.4.2",
-    "@types/node": "^26.6.3",
+    "@types/bun": "^1.4.4",
+    "@types/node": "^26.6.5",
     "typescript": "^7.0.2"
   },
   "license": "FSL-1.1-MIT",

package/src/async.ts

@@ -1,3 +1,5 @@
+import { asError } from './error-text.ts';
+
 /*
  * Resolves after `ms`, or at once when the signal is raised. An abort resolves instead of rejecting:
  * every caller is a loop that checks the signal itself on its next turn.
@@ -5,6 +7,7 @@
 export function wait(ms: number, signal?: AbortSignal): Promise<void> {
     return new Promise((resolve) => {
         const timer = setTimeout(resolve, ms);
+
         signal?.addEventListener(
             'abort',
             () => {
@@ -16,19 +19,34 @@ export function wait(ms: number, signal?: AbortSignal): Promise<void> {
     });
 }
 
+export interface DeadlineTimer {
+    setTimeout(run: () => void, ms: number): unknown;
+    clearTimeout(handle: unknown): void;
+}
+
+const SYSTEM_TIMER: DeadlineTimer = {
+    setTimeout: (run, ms) => setTimeout(run, ms),
+    clearTimeout: (handle) => clearTimeout(handle as ReturnType<typeof setTimeout>)
+};
+
 /* The timer is cleared either way, so a call that answers at once does not hold the process until its deadline. */
-export function withTimeout<T>(promise: Promise<T>, ms: number, message: string): Promise<T> {
+export function withDeadline<T>(promise: Promise<T>, ms: number, message: string, timer: DeadlineTimer = SYSTEM_TIMER): Promise<T> {
     return new Promise((resolve, reject) => {
-        const timer = setTimeout(() => reject(new Error(message)), ms);
+        const handle = timer.setTimeout(() => reject(new Error(message)), ms);
+
         promise.then(
             (value) => {
-                clearTimeout(timer);
+                timer.clearTimeout(handle);
                 resolve(value);
             },
             (e: unknown) => {
-                clearTimeout(timer);
-                reject(e instanceof Error ? e : new Error(String(e)));
+                timer.clearTimeout(handle);
+                reject(asError(e));
             }
         );
     });
 }
+
+export function withTimeout<T>(promise: Promise<T>, ms: number, message: string): Promise<T> {
+    return withDeadline(promise, ms, message);
+}