@adecore/agents 0.0.1 → 0.17.0-beta.1

package/src/tasks/wiring.ts

@@ -0,0 +1,231 @@
+import type { Task } from '@adecore/agent-contracts';
+import { reportsOnBackgroundWork } from '../chat/background-work.ts';
+import type { ChatCore } from '../chat/chat-core.ts';
+import { chatOpener, loadChat } from '../chat/wake-chat.ts';
+import { errorText } from '../error-text.ts';
+import type { OutboxHandlers } from '../outbox/outbox-worker.ts';
+import { backgroundLimitHandler, backgroundLimits } from './background-limit.ts';
+import { giveTaskHandler } from './give-task.ts';
+import { TaskCoordinator, type TaskCoordinatorDeps } from './task-coordinator.ts';
+import type { TaskStore } from './task-store.ts';
+import { isGiveTask, type AnyOutboxEntry, type TaskOutbox, type TaskWork } from './task-work.ts';
+import { chatRequests, deliverWaitingHandler, WaitingObserver, type ChatRequests, type WaitingWords } from './waiting-child.ts';
+import { oweWake, wakeParentHandler } from './wake-parent.ts';
+
+/* What tasks need of the chats of a host; a `ChatCore` has all of it. */
+export type TaskChats = Pick<ChatCore, 'get' | 'observe' | 'hasStored' | 'create' | 'answer' | 'deliverNote' | 'isLoading' | 'storedBackground' | 'save'>;
+
+export interface TaskRecord {
+    projectId: string;
+    parentId: string;
+    childId: string;
+    title: string;
+    prompt: string;
+}
+
+/* What the verbs of a context CLI reach of the tasks. */
+export interface TaskVerbs {
+    /* `batchId` ties the tasks of one `team --task` call together, which wake the parent as one. */
+    open(record: TaskRecord & { batchId?: string }): Promise<Task>;
+    /* Opens a task for an agent that is already running, and owes the turn that carries it. */
+    give(record: TaskRecord): Promise<Task>;
+    /* Whether the host has a chat for this node at all, and whether a turn of it is in the way. */
+    chatState(nodeId: string): Promise<'none' | 'idle' | 'running'>;
+    /* Ends the open task of this child with the result it reported; null when it has none open. */
+    done(childId: string, text: string): Promise<Task | null>;
+    /* Every task the node gave or was given, oldest first. */
+    involving(nodeId: string): Task[];
+}
+
+export interface TaskWords extends WaitingWords {
+    /* What a running agent's CLI is sent with a task given to it; the prompt alone when absent. */
+    assignment?: (task: Task) => string;
+    /* Where the rest of a result that was cut is read, after the line in the wake that says so. */
+    restOf?: (childId: string) => string;
+}
+
+export interface TaskWiringDeps {
+    tasks: TaskStore;
+    chats: TaskChats;
+    outbox: TaskOutbox;
+    /* Whether a project still places the node; a child that went is cancelled by `prune`, never failed. */
+    placed(nodeId: string): boolean;
+    /* What a person calls a node, for the notes a task leaves. */
+    titleFor(nodeId: string): string | null;
+    /* Raises attention on a node whose task failed, for the person who has to look at why. */
+    alert(nodeId: string, title: string, body: string): void;
+    /* Told of every task written, inside the broadcast of the child that settled it, so it only notes. */
+    changed?: (task: Task) => void;
+    /* When the host tries a turn that stopped on an overload again; null when it does not. */
+    retryAt?: TaskCoordinatorDeps['retryAt'];
+    words: TaskWords;
+    now?: () => number;
+}
+
+export interface TaskWiring {
+    coordinator: TaskCoordinator;
+    recover(): Promise<void>;
+    waiting: WaitingObserver;
+    verbs: TaskVerbs;
+    requests: ChatRequests;
+    handlers: OutboxHandlers<TaskWork>;
+    /* For the worker's `onParked`: a task whose turn never opened is one nobody is working on, and fails. */
+    onParked(entry: AnyOutboxEntry, error: unknown): void;
+    /* For a project that no longer places these ids: cancel what went, then look at the parents again. */
+    prune(projectId: string, ids: ReadonlySet<string>): Promise<void>;
+}
+
+/*
+ * The tasks of a host in one place, so the host only hands in what it has: the coordinator that
+ * settles, the work the outbox runs, the notes in a parent's thread and what the verbs reach.
+ */
+export function wireTasks(deps: TaskWiringDeps): TaskWiring {
+    const now = deps.now ?? Date.now;
+    const { chats, outbox } = deps;
+    const enqueue = (projectId: string, target: string, work: TaskWork, notBefore?: number): Promise<void> =>
+        outbox.enqueue(projectId, target, work, notBefore);
+    const limit = backgroundLimits(outbox);
+    const coordinator = new TaskCoordinator({
+        tasks: deps.tasks,
+        now,
+        chatItems: (chatId) => chats.get(chatId)?.thread.list() ?? null,
+        placed: (nodeId) => deps.placed(nodeId),
+        loading: (chatId) => chats.isLoading(chatId),
+        // Until the turn that carries a task ran, no turn of the child is its answer.
+        owedTurn: (taskId) => outbox.list().some((entry) => isGiveTask(entry) && entry.payload.taskId === taskId),
+        oweWake: (task) => oweWake({ enqueue }, task),
+        alert: (nodeId, title, body) => deps.alert(nodeId, title, body),
+        ...(deps.retryAt ? { retryAt: deps.retryAt } : {}),
+        afterBackgroundWork: (chatId) => {
+            const chat = chats.get(chatId);
+            if (!chat?.running) {
+                return 'gone';
+            }
+            return reportsOnBackgroundWork(chat.info.provider) ? 'reports' : 'silent';
+        },
+        commandsOf: (chatId) => chats.get(chatId)?.info.background ?? [],
+        limit
+    });
+
+    deps.tasks.onChange((task: Task) => {
+        deps.changed?.(task);
+        // A cancelled task owes no wake of its own, but it may be the last of a team whose held results now go out.
+        if (task.status === 'cancelled' && task.batchId !== undefined) {
+            outbox.wake(task.parentId);
+        }
+        // However a task ended, the limit on its child's background commands has nothing left to settle.
+        if (task.status !== 'open' && limit.owed(task.id)) {
+            void limit.lapse(task.id).catch((e: unknown) => console.error(`Dropping the limit of task ${task.id} failed:`, errorText(e)));
+        }
+    });
+
+    const requests = chatRequests(chats);
+    const waiting = new WaitingObserver({ openTask: (childId) => deps.tasks.openFor(childId), enqueue, now });
+
+    chats.observe((event) => {
+        coordinator.chatEvent(event);
+        waiting.chatEvent(event);
+        if (event.event === 'chat.event' && chats.get(event.payload.chatId)?.info.activeTurnId === null) {
+            outbox.wake(event.payload.chatId);
+        }
+    });
+
+    const chatFor = chatOpener({ chats, placed: deps.placed });
+
+    return {
+        coordinator,
+        recover: async () => {
+            for (const task of deps.tasks.all()) {
+                if (task.status === 'open' && task.requiresTaskTurn === true && deps.placed(task.childId)) {
+                    if (!outbox.list().some((entry) => isGiveTask(entry) && entry.payload.taskId === task.id)) {
+                        await enqueue(task.projectId, task.childId, { kind: 'give-task', payload: { taskId: task.id } });
+                    }
+                }
+                const storedBackground = task.status === 'open' ? await chats.storedBackground(task.childId) : { turnId: null, items: [], commands: [] };
+                if (
+                    task.status === 'open' &&
+                    deps.placed(task.childId) &&
+                    (task.background !== undefined ||
+                        task.requiresTaskTurn === true ||
+                        storedBackground.items.length > 0 ||
+                        storedBackground.commands.length > 0)
+                ) {
+                    if (
+                        task.background === undefined &&
+                        storedBackground.turnId !== null &&
+                        (storedBackground.items.length > 0 || storedBackground.commands.length > 0)
+                    ) {
+                        await deps.tasks.holdBackground(task.id, {
+                            turnId: storedBackground.turnId,
+                            itemIds: storedBackground.items.map((item) => item.id),
+                            commands: storedBackground.commands
+                        });
+                    }
+                    const chat = await loadChat({ chats, placed: deps.placed }, task.childId);
+                    if (chat && chat.info.activeTurnId === null) {
+                        const last = chat.thread.list().findLast((item) => item.kind === 'turn');
+                        if (last?.kind === 'turn') {
+                            coordinator.chatEvent({ event: 'chat.event', payload: { chatId: task.childId, event: { type: 'item', item: last } } });
+                        }
+                    }
+                }
+            }
+            await coordinator.settled();
+            for (const task of deps.tasks.all()) {
+                if (
+                    task.status !== 'open' &&
+                    task.wake === 'pending' &&
+                    !outbox.list().some((entry) => entry.kind === 'wake-parent' && (entry.payload as { taskId?: string }).taskId === task.id)
+                ) {
+                    await oweWake({ enqueue }, task);
+                }
+            }
+        },
+        waiting,
+        verbs: {
+            open: (record) => deps.tasks.open(record, now()),
+            give: async (record) => {
+                // The record first: the handler reads what the task asks from it, and a restart in between still owes the turn.
+                const task = await deps.tasks.open({ ...record, requiresTaskTurn: true }, now());
+                await enqueue(task.projectId, task.childId, { kind: 'give-task', payload: { taskId: task.id } });
+                return task;
+            },
+            chatState: async (nodeId) => {
+                const session = chats.get(nodeId);
+                if (session) {
+                    return session.info.activeTurnId === null ? 'idle' : 'running';
+                }
+                // A chat nobody has loaded is idle: the turn opens on the thread the host reads back from disk.
+                return (await chats.hasStored(nodeId)) ? 'idle' : 'none';
+            },
+            done: (childId, text) => coordinator.done(childId, text),
+            involving: (nodeId) => deps.tasks.involving(nodeId)
+        },
+        requests,
+        handlers: {
+            'wake-parent': wakeParentHandler({ tasks: deps.tasks, chat: chatFor, ...(deps.words.restOf ? { restOf: deps.words.restOf } : {}) }),
+            'background-limit': backgroundLimitHandler({ tasks: deps.tasks, coordinator, chats, placed: deps.placed }),
+            'give-task': giveTaskHandler({
+                tasks: deps.tasks,
+                chat: chatFor,
+                titleFor: deps.titleFor,
+                placed: deps.placed,
+                ...(deps.words.assignment ? { assignment: deps.words.assignment } : {})
+            }),
+            'deliver-waiting': deliverWaitingHandler({
+                request: requests.request,
+                titleFor: deps.titleFor,
+                deliver: (chatId, delivery) => chats.deliverNote(chatId, delivery),
+                words: { app: deps.words.app, cli: deps.words.cli }
+            })
+        },
+        onParked: (entry, error) => {
+            if (isGiveTask(entry)) {
+                coordinator.giveFailed(entry.target, error);
+            }
+        },
+        prune: async (projectId, ids) => {
+            coordinator.cancelled(await deps.tasks.prune(projectId, ids, now()));
+        }
+    };
+}

package/src/title-file.ts

@@ -0,0 +1,57 @@
+import { open } from 'node:fs/promises';
+import { clipText, SUGGESTED_TITLE_LIMIT } from '@adecore/agent-contracts';
+
+// oxlint-disable-next-line no-control-regex
+const CONTROL = /[\u0000-\u001f\u007f]+/g;
+
+/*
+ * A model wrote this, so it is text and nothing else: no control characters, no line breaks, one
+ * space between words and a length a header can hold.
+ */
+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()}…`;
+}
+
+/*
+ * Hands every whole line between `from` and `size` of a file that only grows to `onLine`, and
+ * answers where the next read starts: just past the last whole line, so a line still being written
+ * is read once it is done. In pieces, so a file of hundreds of megabytes is never one buffer, and cut
+ * on bytes, since a piece may end halfway into a character.
+ */
+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;
+}

package/src/usage/accounts.ts

@@ -0,0 +1,86 @@
+import { USAGE_PROVIDERS, type ChatInfo, type ProviderAccounts, type UsageAccount, type UsageProvider } from '@adecore/agent-contracts';
+import { definedEnv } from '../providers/accounts/launch.ts';
+import type { ProviderAccountsService } from '../providers/accounts/service.ts';
+import type { LimitAccount, LimitAccounts } from './limits/monitor.ts';
+import { accountRoots, type UsageRootPath } from './roots.ts';
+
+function isUsageProvider(kind: string): kind is UsageProvider {
+    return (USAGE_PROVIDERS as readonly string[]).includes(kind);
+}
+
+interface MachineAccount extends UsageAccount {
+    isDefault: boolean;
+    enabled: boolean;
+    signedIn: boolean;
+}
+
+/* The accounts of the CLIs whose usage the host reads; a default account nobody named is called after its CLI. */
+export function machineAccounts(snapshot: ProviderAccounts, nameOf: (kind: UsageProvider) => string): MachineAccount[] {
+    return Object.entries(snapshot.accounts).flatMap(([id, account]) => {
+        if (!isUsageProvider(account.kind)) {
+            return [];
+        }
+        const isDefault = id === account.kind;
+        const state = snapshot.statuses.find((status) => status.id === id)?.state;
+        return [
+            {
+                id,
+                kind: account.kind,
+                label: account.label ?? (isDefault ? nameOf(account.kind) : id),
+                ...(account.color === undefined ? {} : { color: account.color }),
+                isDefault,
+                enabled: account.enabled !== false,
+                signedIn: state === 'ready'
+            }
+        ];
+    });
+}
+
+function usageAccount({ id, kind, label, color }: MachineAccount): UsageAccount {
+    return { id, kind, label, ...(color === undefined ? {} : { color }) };
+}
+
+/* What the usage page may filter by: every account, whether it is on or signed in or not, since what it spent still counts. */
+export function usageAccountsOf(service: ProviderAccountsService, nameOf: (kind: UsageProvider) => string): UsageAccount[] {
+    return machineAccounts(service.snapshot(), nameOf).map(usageAccount);
+}
+
+/* The transcripts of every account the machine has. */
+export function usageRootsOf(service: ProviderAccountsService): UsageRootPath[] {
+    return accountRoots(
+        Object.entries(service.snapshot().accounts).flatMap(([id, { kind }]) => {
+            if (!isUsageProvider(kind)) {
+                return [];
+            }
+            const folder = service.transcriptFolder(kind, id);
+            return folder === null || folder === '' ? [] : [{ id, kind, folder }];
+        })
+    );
+}
+
+/* The plans the limits monitor reads: the default account of every CLI, and every other one that is on and signed in. */
+export function limitAccountsOf(
+    service: ProviderAccountsService,
+    nameOf: (kind: UsageProvider) => string,
+    baseEnv: Record<string, string | undefined>
+): LimitAccounts {
+    return {
+        list: () =>
+            machineAccounts(service.snapshot(), nameOf)
+                .filter((account) => account.isDefault || (account.enabled && account.signedIn))
+                .map((account): LimitAccount => ({ ...usageAccount(account), isDefault: account.isDefault })),
+        envFor: (kind, id) => definedEnv(service.envFor(kind, id, baseEnv)),
+        lastUsedAt: (id) => service.lastLaunchAt(id)
+    };
+}
+
+/* The account every CLI session a chat here ran was under, by `<provider>\0<sessionId>`, for the transcripts accounts share. */
+export function chatSessionAccounts(chats: ReadonlyArray<Pick<ChatInfo, 'provider' | 'agentSessionId' | 'account'>>): Map<string, string> {
+    const known = new Map<string, string>();
+    for (const chat of chats) {
+        if (chat.agentSessionId !== null) {
+            known.set(`${chat.provider}\0${chat.agentSessionId}`, chat.account ?? chat.provider);
+        }
+    }
+    return known;
+}

package/src/usage/aggregate.ts

@@ -0,0 +1,220 @@
+import { addTotals, EMPTY_TOTALS, totalTokensOf } from '@adecore/agent-contracts';
+import type {
+    UsageBucket,
+    UsageModel,
+    UsagePriceBasis,
+    UsageProject,
+    UsageProvider,
+    UsageResolution,
+    UsageSummaryPayload,
+    UsageTotals
+} from '@adecore/agent-contracts';
+import { cacheSavingsOf, costOf, type PriceBook } from './pricing.ts';
+import { ProjectResolver, type KnownProject } from './projects.ts';
+import type { UsageRecord } from './record.ts';
+
+export interface Aggregation {
+    buckets: UsageBucket[];
+    models: UsageModel[];
+    projects: UsageProject[];
+    sessions: number;
+}
+
+/*
+ * The calendar day a moment falls in, as the viewer's clock reads it. The host may stand in
+ * another zone than the person looking, so the zone travels with the request and every boundary
+ * here is local wall clock, never UTC.
+ */
+function slotFormatter(timeZone: string, resolution: UsageResolution): Intl.DateTimeFormat {
+    const options: Intl.DateTimeFormatOptions =
+        resolution === 'hour'
+            ? { timeZone, year: 'numeric', month: '2-digit', day: '2-digit', hour: '2-digit', hourCycle: 'h23' }
+            : { timeZone, year: 'numeric', month: '2-digit', day: '2-digit' };
+    try {
+        return new Intl.DateTimeFormat('en-CA', options);
+    } catch {
+        // A zone this machine does not know degrades to UTC rather than failing the whole request.
+        return new Intl.DateTimeFormat('en-CA', { ...options, timeZone: 'UTC' });
+    }
+}
+
+/* `2026-09-10` for a day, `2026-09-10T14` for an hour: the day is always the first ten characters. */
+function slotOf(format: Intl.DateTimeFormat, timestampMs: number, resolution: UsageResolution): string {
+    const parts = format.formatToParts(new Date(timestampMs));
+    const at = (type: Intl.DateTimeFormatPartTypes): string => parts.find((part) => part.type === type)?.value ?? '';
+    const day = `${at('year')}-${at('month')}-${at('day')}`;
+    return resolution === 'hour' ? `${day}T${at('hour')}` : day;
+}
+
+function emptyTotals(): UsageTotals {
+    return { ...EMPTY_TOTALS };
+}
+
+interface BucketAccumulator {
+    slot: string;
+    provider: UsageProvider;
+    model: string;
+    account: string | null;
+    totals: UsageTotals;
+    costUsd: number;
+    priced: boolean;
+    cacheSavingsUsd: number;
+    sessions: Set<string>;
+}
+
+interface ModelAccumulator {
+    provider: UsageProvider;
+    model: string;
+    account: string | null;
+    totals: UsageTotals;
+    costUsd: number;
+    priced: boolean;
+}
+
+interface ProjectAccumulator {
+    folder: string;
+    name: string;
+    projectId: string | null;
+    byProvider: Map<UsageProvider, { costUsd: number; tokens: number }>;
+    totals: UsageTotals;
+    costUsd: number;
+}
+
+/* The account a record was made under, the default one under its CLI's kind. */
+export function accountOfRecord(record: UsageRecord): string {
+    return record.account ?? record.provider;
+}
+
+/*
+ * Every record of the period folded three ways at once: per slot for the chart, per model for the
+ * breakdown and its price basis, and per folder for the projects. The three cannot be derived from
+ * one another without a bucket per slot times model times project, which is a table nobody reads.
+ */
+export async function aggregate(
+    records: readonly UsageRecord[],
+    payload: UsageSummaryPayload,
+    prices: PriceBook,
+    known: readonly KnownProject[]
+): Promise<Aggregation> {
+    const format = slotFormatter(payload.timeZone, payload.resolution);
+    const buckets = new Map<string, BucketAccumulator>();
+    const models = new Map<string, ModelAccumulator>();
+    /* The basis of the first record of a model prices the whole row: a model has one price. */
+    const modelBasis = new Map<string, { basis: UsagePriceBasis; pricedAs: string | null }>();
+    const projects = new Map<string, ProjectAccumulator>();
+    const sessions = new Set<string>();
+    const resolver = new ProjectResolver(known);
+    const folders = new Map<string, string>();
+    // A filter splits buckets and models per account; without one they fold the way they did before accounts.
+    const only = payload.accounts === undefined ? null : new Set(payload.accounts);
+
+    for (const record of records) {
+        const account = only === null ? null : accountOfRecord(record);
+        if (only !== null && !only.has(account!)) {
+            continue;
+        }
+        const slot = slotOf(format, record.timestampMs, payload.resolution);
+        const day = slot.slice(0, 10);
+        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);
+        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);
+            folder = resolved.folder;
+            folders.set(record.cwd, folder);
+            if (!projects.has(folder)) {
+                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);
+    }
+
+    return {
+        buckets: [...buckets.values()]
+            .map((bucket) => ({
+                slot: bucket.slot,
+                provider: bucket.provider,
+                model: bucket.model,
+                ...(bucket.account === null ? {} : { account: bucket.account }),
+                totals: bucket.totals,
+                costUsd: bucket.priced ? bucket.costUsd : null,
+                cacheSavingsUsd: bucket.cacheSavingsUsd,
+                sessions: bucket.sessions.size
+            }))
+            .sort(
+                (a, b) =>
+                    a.slot.localeCompare(b.slot) ||
+                    a.provider.localeCompare(b.provider) ||
+                    a.model.localeCompare(b.model) ||
+                    (a.account ?? '').localeCompare(b.account ?? '')
+            ),
+        models: [...models.entries()]
+            .map(([key, 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
+            }))
+            .sort((a, b) => (b.costUsd ?? -1) - (a.costUsd ?? -1)),
+        projects: [...projects.values()]
+            .map((project) => ({
+                folder: project.folder,
+                name: project.name,
+                projectId: project.projectId,
+                byProvider: Object.fromEntries(project.byProvider),
+                totals: project.totals,
+                costUsd: project.costUsd
+            }))
+            .sort((a, b) => b.costUsd - a.costUsd),
+        sessions: sessions.size
+    };
+}