@adecore/agents 0.21.1 → 0.22.0

package/dist/usage/aggregate.js

@@ -28,6 +28,59 @@ function slotOf(format, timestampMs, resolution) {
 function emptyTotals() {
     return { ...EMPTY_TOTALS };
 }
+function foldBucket(buckets, slot, record, account, price, cost) {
+    const key = `${slot}\0${record.provider}\0${record.model}\0${account ?? ''}`;
+    let bucket = buckets.get(key);
+    if (bucket === undefined) {
+        bucket = {
+            slot,
+            provider: record.provider,
+            model: record.model,
+            account,
+            totals: emptyTotals(),
+            costUsd: 0,
+            priced: false,
+            cacheSavingsUsd: 0,
+            sessions: new Set()
+        };
+        buckets.set(key, bucket);
+    }
+    bucket.totals = addTotals(bucket.totals, record.totals);
+    bucket.costUsd += cost;
+    bucket.priced ||= price !== null;
+    bucket.cacheSavingsUsd += price === null ? 0 : cacheSavingsOf(record.totals, price);
+    if (record.sessionId !== '') {
+        bucket.sessions.add(record.sessionId);
+    }
+}
+function foldModel(models, record, account, lookup, cost) {
+    const key = `${record.provider}\0${record.model}\0${account ?? ''}`;
+    let model = models.get(key);
+    if (model === undefined) {
+        model = {
+            provider: record.provider,
+            model: record.model,
+            account,
+            totals: emptyTotals(),
+            costUsd: 0,
+            priced: false,
+            basis: lookup.basis,
+            pricedAs: lookup.pricedAs
+        };
+        models.set(key, model);
+    }
+    model.totals = addTotals(model.totals, record.totals);
+    model.costUsd += cost;
+    model.priced ||= lookup.price !== null;
+}
+function foldProject(project, record, cost) {
+    project.totals = addTotals(project.totals, record.totals);
+    project.costUsd += cost;
+    const share = project.byProvider.get(record.provider) ?? { costUsd: 0, tokens: 0 };
+    share.costUsd += cost;
+    share.tokens += totalTokensOf(record.totals);
+    project.byProvider.set(record.provider, share);
+}
 /* The account a record was made under, the default one under its CLI's kind. */
 export function accountOfRecord(record) {
     return record.account ?? record.provider;
@@ -41,8 +94,6 @@ export async function aggregate(records, payload, prices, known) {
     const format = slotFormatter(payload.timeZone, payload.resolution);
     const buckets = new Map();
     const models = new Map();
-    /* The basis of the first record of a model prices the whole row: a model has one price. */
-    const modelBasis = new Map();
     const projects = new Map();
     const sessions = new Set();
     const resolver = new ProjectResolver(known);
@@ -59,42 +110,13 @@ export async function aggregate(records, payload, prices, known) {
         if (day < payload.from || day > payload.to) {
             continue;
         }
-        const { price, basis, pricedAs } = prices.look(record.model);
-        const cost = price === null ? 0 : costOf(record.totals, price);
-        const bucketKey = `${slot}\0${record.provider}\0${record.model}\0${account ?? ''}`;
-        let bucket = buckets.get(bucketKey);
-        if (bucket === undefined) {
-            bucket = {
-                slot,
-                provider: record.provider,
-                model: record.model,
-                account,
-                totals: emptyTotals(),
-                costUsd: 0,
-                priced: false,
-                cacheSavingsUsd: 0,
-                sessions: new Set()
-            };
-            buckets.set(bucketKey, bucket);
-        }
-        bucket.totals = addTotals(bucket.totals, record.totals);
-        bucket.costUsd += cost;
-        bucket.priced ||= price !== null;
-        bucket.cacheSavingsUsd += price === null ? 0 : cacheSavingsOf(record.totals, price);
+        const lookup = prices.look(record.model);
+        const cost = lookup.price === null ? 0 : costOf(record.totals, lookup.price);
+        foldBucket(buckets, slot, record, account, lookup.price, cost);
+        foldModel(models, record, account, lookup, cost);
         if (record.sessionId !== '') {
-            bucket.sessions.add(record.sessionId);
             sessions.add(`${record.provider}\0${record.sessionId}`);
         }
-        const modelKey = `${record.provider}\0${record.model}\0${account ?? ''}`;
-        let model = models.get(modelKey);
-        if (model === undefined) {
-            model = { provider: record.provider, model: record.model, account, totals: emptyTotals(), costUsd: 0, priced: false };
-            models.set(modelKey, model);
-            modelBasis.set(modelKey, { basis, pricedAs });
-        }
-        model.totals = addTotals(model.totals, record.totals);
-        model.costUsd += cost;
-        model.priced ||= price !== null;
         let folder = folders.get(record.cwd);
         if (folder === undefined) {
             const resolved = await resolver.resolve(record.cwd);
@@ -104,13 +126,7 @@ export async function aggregate(records, payload, prices, known) {
                 projects.set(folder, { folder, name: resolved.name, projectId: resolved.projectId, byProvider: new Map(), totals: emptyTotals(), costUsd: 0 });
             }
         }
-        const project = projects.get(folder);
-        project.totals = addTotals(project.totals, record.totals);
-        project.costUsd += cost;
-        const share = project.byProvider.get(record.provider) ?? { costUsd: 0, tokens: 0 };
-        share.costUsd += cost;
-        share.tokens += totalTokensOf(record.totals);
-        project.byProvider.set(record.provider, share);
+        foldProject(projects.get(folder), record, cost);
     }
     return {
         buckets: [...buckets.values()]
@@ -128,15 +144,15 @@ export async function aggregate(records, payload, prices, known) {
             a.provider.localeCompare(b.provider) ||
             a.model.localeCompare(b.model) ||
             (a.account ?? '').localeCompare(b.account ?? '')),
-        models: [...models.entries()]
-            .map(([key, model]) => ({
+        models: [...models.values()]
+            .map((model) => ({
             provider: model.provider,
             model: model.model,
             ...(model.account === null ? {} : { account: model.account }),
             totals: model.totals,
             costUsd: model.priced ? model.costUsd : null,
-            priceBasis: modelBasis.get(key)?.basis ?? 'unknown',
-            pricedAs: modelBasis.get(key)?.pricedAs ?? null
+            priceBasis: model.basis,
+            pricedAs: model.pricedAs
         }))
             .sort((a, b) => (b.costUsd ?? -1) - (a.costUsd ?? -1)),
         projects: [...projects.values()]

package/dist/usage/exchange.js

@@ -1,7 +1,7 @@
 import { mkdir, readFile } from 'node:fs/promises';
 import { join } from 'node:path';
-import { isNotFound, writeAtomic } from '../fs.js';
 import { errorText } from '../error-text.js';
+import { isNotFound, writeAtomic } from '../fs.js';
 export const FRANKFURTER_URL = 'https://api.frankfurter.app/latest';
 /* The bank publishes one rate a day, so a rate a day old is the rate. */
 const TTL_MS = 24 * 60 * 60 * 1000;

package/dist/usage/limits/monitor.d.ts

@@ -1,8 +1,8 @@
 import type { UsageLimitsSnapshot, UsageProvider } from '@adecore/agent-contracts';
-import type { ProviderRegistry } from '../../providers/registry.ts';
+import type { CodexClientInfo } from '../../chat/codex-transport.ts';
 import type { AgentSink } from '../../events.ts';
+import type { ProviderRegistry } from '../../providers/registry.ts';
 import { type LimitsUpdate } from './normalize.ts';
-import type { CodexClientInfo } from '../../chat/codex-transport.ts';
 import { type ProbeResult } from './probe.ts';
 export type ProbeEnv = Record<string, string>;
 export interface LimitAccount {

package/dist/usage/limits/monitor.js

@@ -1,8 +1,8 @@
+import { ClientSinks } from '../../client-sinks.js';
+import { errorText } from '../../error-text.js';
 import { definedEnv } from '../../providers/accounts/launch.js';
 import { mergeWindows } from './normalize.js';
 import { probeClaude, probeCodex } from './probe.js';
-import { ClientSinks } from '../../client-sinks.js';
-import { errorText } from '../../error-text.js';
 /* Often enough that a bar is never far behind, rarely enough that two CLIs are not started all day. */
 const PROBE_INTERVAL_MS = 5 * 60_000;
 const MAX_BACKOFF_MS = 60 * 60_000;

package/dist/usage/limits/probe.js

@@ -1,8 +1,8 @@
 import { withTimeout } from '../../async.js';
 import { spawnChatProcess } from '../../chat/chat-process.js';
 import { CodexTransport, DEFAULT_CODEX_CLIENT } from '../../chat/codex-transport.js';
-import { readClaudeUsage, readCodexLimits } from './normalize.js';
 import { errorText } from '../../error-text.js';
+import { readClaudeUsage, readCodexLimits } from './normalize.js';
 /* A CLI that has not answered by now is not going to; the next pass tries again. */
 const PROBE_TIMEOUT_MS = 20_000;
 const CODEX_READ_TIMEOUT_MS = 3_000;

package/dist/usage/pricing.js

@@ -1,7 +1,7 @@
 import { mkdir, readFile } from 'node:fs/promises';
 import { join } from 'node:path';
-import { isNotFound, writeAtomic } from '../fs.js';
 import { errorText } from '../error-text.js';
+import { isNotFound, writeAtomic } from '../fs.js';
 import bundled from './prices-snapshot.json' with { type: 'json' };
 export const LITELLM_URL = 'https://raw.githubusercontent.com/BerriAI/litellm/main/model_prices_and_context_window.json';
 /* A table a day old still prices everything anyone ran today, and nobody has to be online for it. */

package/dist/usage/readers/codex.d.ts

@@ -19,5 +19,6 @@ export interface CodexParserState {
 }
 export declare function createCodexState(): CodexParserState;
 export declare function cloneCodexState(state: CodexParserState): CodexParserState;
+export declare function isForkOrSubagent(payload: Record<string, unknown>): boolean;
 export declare function parseCodexLine(line: string, state: CodexParserState): UsageRecord | null;
 export {};

package/dist/usage/readers/codex.js

@@ -45,7 +45,7 @@ function deltaOf(total, previous) {
     return delta.input < 0 || delta.cached < 0 || delta.cacheWrite < 0 || delta.output < 0 || delta.reasoning < 0 ? null : delta;
 }
 /* A thread that was forked or spawned repeats its parent's events before its own work starts. */
-function isForkOrSubagent(payload) {
+export function isForkOrSubagent(payload) {
     if (typeof payload.forked_from_id === 'string' || typeof payload.parent_thread_id === 'string') {
         return true;
     }

package/dist/usage/roots.js

@@ -2,8 +2,7 @@ import { homedir } from 'node:os';
 import { join } from 'node:path';
 /* Where in its config folder each CLI leaves its transcripts. */
 const TRANSCRIPTS = { claude: 'projects', codex: 'sessions' };
-/* Where each CLI leaves its transcripts. The same environment variables the hooks installer reads,
-   so the scanner and the installer never disagree about where a CLI keeps its things. */
+/* The transcripts of the default accounts, found through the variables the CLIs themselves read. */
 export function usageRoots(env = process.env) {
     const home = env.HOME ?? homedir();
     return [

package/dist/usage/scanner.js

@@ -1,12 +1,12 @@
 import { mkdir, open, readFile, readdir, stat } from 'node:fs/promises';
 import { join } from 'node:path';
+import { errorText } from '../error-text.js';
 import { isNotFound, writeAtomic } from '../fs.js';
 import { decodeIndex, encodeIndex } from './index-file.js';
 import { foldByKey } from './record.js';
 import { claudeMightCarryUsage, parseClaudeLine } from './readers/claude.js';
 import { cloneCodexState, codexMightCarryUsage, createCodexState, parseCodexLine } from './readers/codex.js';
 import { usageRoots } from './roots.js';
-import { errorText } from '../error-text.js';
 /* What a file holds from `from` to its end, as it is at the read. */
 async function readFrom(path, from) {
     const handle = await open(path, 'r');
@@ -53,11 +53,11 @@ async function listJsonl(dir, out = []) {
  * read again next time. The Codex state is snapshotted before that tail for the same reason.
  */
 function parseChunk(text, provider, from, state) {
-    let records = [];
     const end = text.lastIndexOf('\n');
     const whole = end === -1 ? '' : text.slice(0, end);
     const tail = text.slice(end + 1);
     const read = (chunk, codex) => {
+        const records = [];
         for (const raw of chunk.split('\n')) {
             const line = raw.endsWith('\r') ? raw.slice(0, -1) : raw;
             if (line === '') {
@@ -79,14 +79,12 @@ function parseChunk(text, provider, from, state) {
                 }
             }
         }
+        return records;
     };
     const codex = provider === 'codex' ? (state ?? createCodexState()) : null;
-    read(whole, codex);
+    const counted = read(whole, codex);
     const committed = codex === null ? null : cloneCodexState(codex);
-    const counted = records;
-    records = [];
-    read(tail, codex);
-    return { records: counted, tail: records, offset: from + (end === -1 ? 0 : Buffer.byteLength(whole, 'utf8') + 1), codex: committed };
+    return { records: counted, tail: read(tail, codex), offset: from + (end === -1 ? 0 : Buffer.byteLength(whole, 'utf8') + 1), codex: committed };
 }
 /*
  * The account a record of a root belongs to, as a record keeps it (absent for the default account):
@@ -113,8 +111,8 @@ function withAccount(records, accountOf) {
     });
 }
 /*
- * Read appended transcript bytes incrementally, but restart after rewrites or truncation. Preserve
- * totals for deleted transcripts because their usage still happened.
+ * Reads only what a transcript appended since the last scan, and starts a file over once it was
+ * rewritten or cut. A deleted transcript keeps its totals, since its usage still happened.
  */
 export class UsageScanner {
     home;

package/dist/usage/usage-service.d.ts

@@ -1,8 +1,8 @@
 import type { UsageAccount, UsageSummaryPayload, UsageSummaryResult } from '@adecore/agent-contracts';
 import type { AgentSink } from '../events.ts';
 import type { KnownProject } from './projects.ts';
-import { type UsageScannerOptions } from './scanner.ts';
 import type { UsageRootPath } from './roots.ts';
+import { type UsageScannerOptions } from './scanner.ts';
 export interface UsageServiceOptions {
     home: string;
     allowPriceFetch?: boolean;
@@ -31,5 +31,4 @@ export declare class UsageService {
     stop(): void;
     private rescan;
     private runScan;
-    private emit;
 }

package/dist/usage/usage-service.js

@@ -1,9 +1,9 @@
+import { ClientSinks } from '../client-sinks.js';
+import { errorText } from '../error-text.js';
 import { accountOfRecord, aggregate } from './aggregate.js';
 import { ExchangeRates } from './exchange.js';
 import { PriceBook } from './pricing.js';
 import { UsageScanner } from './scanner.js';
-import { errorText } from '../error-text.js';
-import { ClientSinks } from '../client-sinks.js';
 /* A scan this fresh answers the question the page is asking, so nothing is opened for it. */
 const SCAN_TTL_MS = 60_000;
 /* The accounts of the machine, and after them any a record names that the machine no longer has, under its id. */
@@ -121,10 +121,7 @@ export class UsageService {
         }
         this.report = report;
         if (report.changedFiles > 0) {
-            this.emit({ event: 'usage.changed', payload: { scannedAt: report.at } });
+            this.sinks.emit({ event: 'usage.changed', payload: { scannedAt: report.at } });
         }
     }
-    emit(event) {
-        this.sinks.emit(event);
-    }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adecore/agents",
-  "version": "0.21.1",
+  "version": "0.22.0",
   "description": "Node-compatible agent chat hosts, providers, accounts, usage and durable task coordination.",
   "type": "module",
   "exports": {
@@ -20,8 +20,8 @@
     "test": "bun --conditions=source test"
   },
   "dependencies": {
-    "@adecore/agent-contracts": "0.21.1",
-    "@adecore/intelligent-ui": "0.21.1",
+    "@adecore/agent-contracts": "0.22.0",
+    "@adecore/intelligent-ui": "0.22.0",
     "zod": "^4.6.5"
   },
   "devDependencies": {

package/src/async.ts

@@ -1,9 +1,6 @@
-/* The two waits the host does: a pause it can be woken from, and a deadline on somebody else's promise. */
-
 /*
- * Resolves after `ms`, or at once when the signal is raised. An abort ends the wait rather than
- * failing it: every caller here is a loop that checks the signal itself on the next turn, and a
- * rejection would only be caught and thrown away.
+ * 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.
  */
 export function wait(ms: number, signal?: AbortSignal): Promise<void> {
     return new Promise((resolve) => {
@@ -19,10 +16,7 @@ export function wait(ms: number, signal?: AbortSignal): Promise<void> {
     });
 }
 
-/*
- * The promise, or `message` when it takes longer than `ms`. The timer is cleared either way, so a
- * call that answers at once does not hold the process for the rest of its deadline.
- */
+/* 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> {
     return new Promise((resolve, reject) => {
         const timer = setTimeout(() => reject(new Error(message)), ms);

package/src/chat/backend.ts

@@ -160,6 +160,8 @@ export type BackendEvent =
     | { type: 'compaction'; preTokens: number | null }
     | { type: 'model'; model: string }
     | { type: 'note'; level: 'info' | 'warning' | 'error'; text: string }
+    // The CLI answered a `stopTask` with an error, so the task still runs.
+    | { type: 'stop.refused'; taskId: string; message: string }
     // `native` is the CLI's own name for where the turn ended, which a fork of the chat is cut at.
     | {
           type: 'turn.done';

package/src/chat/chat-core.ts

@@ -27,7 +27,6 @@ import {
     type ModelSelection,
     type RuntimeMode
 } from '@adecore/agent-contracts';
-import { ChatUiQueries, type ChatUiHost } from './ui-queries.ts';
 import { ClientSinks } from '../client-sinks.ts';
 import { errorText } from '../error-text.ts';
 import type { AgentEvent, AgentSink } from '../events.ts';
@@ -38,6 +37,7 @@ import { SkillIndex } from '../skills.ts';
 import type { LimitsUpdate } from '../usage/limits/normalize.ts';
 import { usageRoots } from '../usage/roots.ts';
 import type { AttachmentStore } from './attachment-store.ts';
+import { commandLabel, isBackgroundWork, runsInBackground, type BackgroundWork } from './background-work.ts';
 import type { BookmarkStore } from './bookmark-store.ts';
 import { ChatLog, COMPACT_ABOVE_BYTES } from './chat-log.ts';
 import type { SpawnChatProcess } from './chat-process.ts';
@@ -57,10 +57,10 @@ import type { CodexProcessSpec } from './codex-thread.ts';
 import type { CodexClientInfo } from './codex-transport.ts';
 import { ComposerPreferences } from './composer-preferences.ts';
 import { DeltaCoalescer } from './delta-coalescer.ts';
-import { readableAssistantText } from './readable-text.ts';
 import { ChatError } from './errors.ts';
-import { commandLabel, isBackgroundWork, runsInBackground, type BackgroundWork } from './background-work.ts';
+import { readableAssistantText } from './readable-text.ts';
 import { SubagentReader, type SubagentReaderOptions } from './subagent-reader.ts';
+import { ChatUiQueries, type ChatUiHost } from './ui-queries.ts';
 import type { VisualInput, VisualStore } from './visual-store.ts';
 
 /* A turn that was running when the host went down, and the attempt that would take it up again. */
@@ -72,12 +72,12 @@ export interface InterruptedRun {
 
 type BookmarkableItem = Extract<ChatItem, { kind: 'user' | 'assistant' }>;
 
-/* A message a person or the agent wrote in the chat's own thread; a subagent's words belong to its row. */
 function withoutHidden(info: ChatInfo): ChatInfo {
     const { hidden: _hidden, ...rest } = info;
     return rest;
 }
 
+/* A message a person or the agent wrote in the chat's own thread; a subagent's words belong to its row. */
 function isBookmarkable(item: ChatItem): item is BookmarkableItem {
     return item.kind === 'user' || (item.kind === 'assistant' && (item.parentToolUseId ?? null) === null);
 }
@@ -640,8 +640,9 @@ export class ChatCore {
     }
 
     /*
-     * Stops one running sub-agent of the CLI's own. It cannot be stopped apart from its CLI, so its row
-     * is only marked, and only while no turn runs: stopping that turn is the composer's Stop.
+     * Stops one running sub-agent of the CLI's own. The process that started it ends it with `stop_task`
+     * and the parent keeps working. Without such a process the row is only marked, and only while no
+     * turn runs: stopping that turn is the composer's Stop.
      */
     async stopSubagent(chatId: string, toolUseId: string): Promise<void> {
         await this.loaded(chatId);
@@ -656,7 +657,7 @@ export class ChatCore {
         if (row.origin === 'ruimte') {
             throw new ChatError('chat-unsupported', 'This row stands for work the host runs; stop it there');
         }
-        session.markSubagentStopped(toolUseId);
+        session.stopSubagent(toolUseId);
     }
 
     /* Ends a command or a monitor a chat's CLI runs in the background, for a person who pressed Stop on it. */

package/src/chat/chat-log.ts

@@ -48,8 +48,8 @@ export interface ChatLogState {
 }
 
 /*
- * Number and synchronously append each broadcast event so disk, memory and snapshot boundaries keep
- * one order. Recent lines stay in memory for immediate `since` attachment.
+ * Numbers every broadcast event and appends it synchronously, so disk, memory and snapshot boundaries
+ * keep one order. Recent lines stay in memory to answer an attach with `since` at once.
  */
 export class ChatLog {
     private readonly path: string | null;