@adecore/agents 0.41.1 → 0.43.0

package/dist/chat/chat-core.d.ts

@@ -235,6 +235,7 @@ export declare class ChatCore {
     clear(chatId: string, force?: boolean): Promise<void>;
     cancel(chatId: string, subagents?: boolean): void;
     turnDiff(chatId: string, turnId: string): Promise<ChatCheckpointDiff | null>;
+    toolOutput(chatId: string, itemId: string): Promise<string | null>;
     approve(chatId: string, requestId: string, decision: 'allow' | 'allow-always' | 'deny', message?: string): void;
     answer(chatId: string, requestId: string, answers: Record<string, string>): void;
     dismiss(chatId: string, itemId: string): void;

package/dist/chat/chat-core.js

@@ -780,9 +780,25 @@ export class ChatCore {
             session.markSubagentsStopped();
         }
     }
-    /* What a turn changed against the tree it started from; null when it has no checkpoint. */
-    turnDiff(chatId, turnId) {
-        return this.require(chatId).turnDiff(turnId);
+    /* What a turn changed against the tree it started from, whole also where the thread keeps only its first diffs; null when it has no checkpoint. */
+    async turnDiff(chatId, turnId) {
+        const session = this.require(chatId);
+        const turn = session.thread.get(turnId);
+        if (turn?.kind === 'turn' && turn.checkpointDiffRef && this.store) {
+            return await this.store.readDiff(chatId, turn.checkpointDiffRef.id);
+        }
+        return await session.turnDiff(turnId);
+    }
+    /* The whole of what a tool call answered, also where the thread keeps only its beginning. */
+    async toolOutput(chatId, itemId) {
+        const tool = this.require(chatId).thread.get(itemId);
+        if (tool?.kind !== 'tool') {
+            throw new ChatError('item-not-found', `No tool call ${itemId} in chat ${chatId}`);
+        }
+        if (!tool.outputRef || !this.store) {
+            return tool.output;
+        }
+        return await this.store.readPayload(chatId, tool.outputRef.id);
     }
     approve(chatId, requestId, decision, message) {
         if (!this.require(chatId).approve(requestId, decision, message)) {
@@ -1121,6 +1137,8 @@ export class ChatCore {
             // A chat killed while the write was out has no log left to fold.
             if (this.logs.get(chatId) === log && folds) {
                 log.compact(at.seq);
+                // With the log folded, the record alone says which payloads the thread still needs.
+                await this.store.prunePayloads(chatId);
             }
         });
         this.writes.set(chatId, next.catch(() => undefined));

package/dist/chat/chat-store.d.ts

@@ -1,4 +1,4 @@
-import { type ChatInfo, type ChatItem } from '@adecore/agent-contracts';
+import { type ChatCheckpointDiff, type ChatInfo, type ChatItem } from '@adecore/agent-contracts';
 import { type AttachmentStore } from './attachment-store.ts';
 import { type ChatLogLine } from './chat-log.ts';
 export type ChatRecordExtras = Record<string, unknown>;
@@ -24,6 +24,8 @@ export declare class ChatStore {
     readonly dir: string;
     private readonly attachments;
     private readonly isSidecar;
+    private readonly payloads;
+    private readonly referenced;
     constructor(home: string, options?: ChatStoreOptions);
     logPath(chatId: string): string;
     list(): Promise<string[]>;
@@ -31,9 +33,13 @@ export declare class ChatStore {
     discardLog(chatId: string): Promise<number>;
     write(chatId: string, info: ChatInfo, items: ChatItem[], at?: ChatSeq, preambles?: readonly string[], extras?: ChatRecordExtras, uiAccess?: Readonly<Record<string, unknown>>): Promise<number>;
     writeSync(chatId: string, info: ChatInfo, items: ChatItem[], at?: ChatSeq, preambles?: readonly string[], extras?: ChatRecordExtras, uiAccess?: Readonly<Record<string, unknown>>): void;
+    readPayload(chatId: string, id: string): Promise<string>;
+    readDiff(chatId: string, id: string): Promise<ChatCheckpointDiff>;
+    prunePayloads(chatId: string): Promise<void>;
     read(chatId: string): Promise<ChatRecord | null>;
     unreadable(chatId: string): Promise<boolean>;
     settled(chatId: string): Promise<boolean>;
     private readSnapshot;
+    private compact;
     delete(chatId: string): Promise<void>;
 }

package/dist/chat/chat-store.js

@@ -8,6 +8,7 @@ import { recordFileName } from '../record-directory.js';
 import { migrateInlineAttachments } from './attachment-store.js';
 import { isBookmarkFileName } from './bookmark-store.js';
 import { parseLog } from './chat-log.js';
+import { compactItems, PayloadStore } from './payload-store.js';
 import { ChatThread } from './thread.js';
 import { isVisualFileName } from './visual-store.js';
 // zod strips what it does not know inside the info and the items, so a file written by an older build
@@ -57,16 +58,22 @@ function liftUiAccess(record) {
 }
 /*
  * One JSON file per chat under `<home>/chats`, written while a turn runs and on shutdown, with
- * the log of what happened since beside it (`ChatLog` appends to it; reading plays it back).
+ * the log of what happened since beside it (`ChatLog` appends to it; reading plays it back). An
+ * output or diff past the inline limit goes to the chat's payload folder, and the record keeps
+ * its beginning (`PayloadStore`).
  */
 export class ChatStore {
     dir;
     attachments;
     isSidecar;
+    payloads;
+    // The payloads the record this process wrote last refers to, which is what a prune keeps.
+    referenced = new Map();
     constructor(home, options = {}) {
         this.dir = join(home, 'chats');
         this.attachments = options.attachments ?? null;
         this.isSidecar = options.isSidecar ?? (() => false);
+        this.payloads = new PayloadStore(this.dir);
     }
     logPath(chatId) {
         return join(this.dir, logName(chatId));
@@ -102,9 +109,13 @@ export class ChatStore {
     }
     /* Answers how many bytes the record took, which is what tells a caller whether writing it is cheap. */
     async write(chatId, info, items, at = { seq: 0, resetSeq: 0 }, preambles = [], extras = {}, uiAccess = {}) {
-        const body = recordBody(info, items, at, preambles, extras, uiAccess);
+        const compacted = compactItems(items);
         await mkdir(this.dir, { recursive: true, mode: 0o700 });
+        // Before the record, so a record on disk never names a payload that is not.
+        await this.payloads.ensure(chatId, compacted.payloads);
+        const body = recordBody(info, compacted.items, at, preambles, extras, uiAccess);
         await writeAtomic(join(this.dir, recordFileName(chatId)), body);
+        this.referenced.set(chatId, new Set(compacted.payloads.keys()));
         return body.length;
     }
     /*
@@ -112,8 +123,28 @@ export class ChatStore {
      * before an awaited write comes back, so a shutdown has to put the threads down synchronously.
      */
     writeSync(chatId, info, items, at = { seq: 0, resetSeq: 0 }, preambles = [], extras = {}, uiAccess = {}) {
+        const compacted = compactItems(items);
         mkdirSync(this.dir, { recursive: true, mode: 0o700 });
-        writeAtomicSync(join(this.dir, recordFileName(chatId)), recordBody(info, items, at, preambles, extras, uiAccess));
+        this.payloads.ensureSync(chatId, compacted.payloads);
+        writeAtomicSync(join(this.dir, recordFileName(chatId)), recordBody(info, compacted.items, at, preambles, extras, uiAccess));
+        this.referenced.set(chatId, new Set(compacted.payloads.keys()));
+    }
+    /* The whole of a tool output or a diff kept apart from the record, by the id its item's ref carries. */
+    readPayload(chatId, id) {
+        return this.payloads.read(chatId, id);
+    }
+    readDiff(chatId, id) {
+        return this.payloads.readDiff(chatId, id);
+    }
+    /*
+     * Removes the payloads the record written last no longer refers to, such as everything a clear
+     * emptied. Nothing before this process wrote the record, since only that write says what it holds.
+     */
+    async prunePayloads(chatId) {
+        const keep = this.referenced.get(chatId);
+        if (keep) {
+            await this.payloads.prune(chatId, keep);
+        }
     }
     /* Null for a chat with nothing on disk to make it of, and for one whose record does not parse (see `unreadable`). */
     async read(chatId) {
@@ -123,7 +154,8 @@ export class ChatStore {
             return null;
         }
         if (snapshot === null) {
-            return fromLogAlone(lines);
+            const rebuilt = fromLogAlone(lines);
+            return rebuilt && { ...rebuilt, items: await this.compact(chatId, rebuilt.items) };
         }
         const seq = snapshot.seq ?? 0;
         const thread = new ChatThread(snapshot.info, snapshot.items);
@@ -138,8 +170,11 @@ export class ChatStore {
                 resetSeq = line.seq;
             }
         }
+        const { info, items } = thread.snapshot();
         return {
-            ...thread.snapshot(),
+            info,
+            // A large output the log still holds whole goes apart now, so an open thread never holds one.
+            items: await this.compact(chatId, items),
             seq,
             resetSeq,
             preambles: snapshot.preambles ?? [],
@@ -188,13 +223,39 @@ export class ChatStore {
             }
         }
         const parsed = RecordSchema.safeParse(liftUiAccess(record));
-        return parsed.success ? parsed.data : UNREADABLE;
+        if (!parsed.success) {
+            return UNREADABLE;
+        }
+        const compacted = compactItems(parsed.data.items);
+        if (compacted.items.every((item, index) => item === parsed.data.items[index])) {
+            return parsed.data;
+        }
+        // A record from before payloads were kept apart moves its large ones out once. The payloads land
+        // first and the record is replaced whole, so a move cut short leaves the old record as it was.
+        const migrated = { ...parsed.data, items: compacted.items };
+        await this.payloads.ensure(chatId, onlyWritten(compacted.payloads));
+        await writeAtomic(join(this.dir, recordFileName(chatId)), JSON.stringify(migrated));
+        return migrated;
+    }
+    async compact(chatId, items) {
+        const compacted = compactItems(items);
+        await this.payloads.ensure(chatId, onlyWritten(compacted.payloads));
+        return compacted.items;
     }
     async delete(chatId) {
-        await Promise.all([rm(join(this.dir, recordFileName(chatId)), { force: true }), rm(this.logPath(chatId), { force: true })]);
+        this.referenced.delete(chatId);
+        await Promise.all([
+            rm(join(this.dir, recordFileName(chatId)), { force: true }),
+            rm(this.logPath(chatId), { force: true }),
+            this.payloads.remove(chatId)
+        ]);
     }
 }
 const UNREADABLE = Symbol('unreadable');
+/* The payloads this process holds the text of; a read leaves the ones a record already refers to for the next write to check. */
+function onlyWritten(payloads) {
+    return new Map([...payloads].filter(([, source]) => source !== null));
+}
 const RECORD_HEAD = Buffer.from('{"info":{');
 const HEAD_CHUNK_BYTES = 16384;
 const QUOTE = 0x22;

package/dist/chat/errors.d.ts

@@ -1,4 +1,4 @@
 import { CodedError } from '../coded-error.ts';
-export type ChatErrorCode = 'refused-query' | 'stale-ui-query' | 'history-expired' | 'chat-not-found' | 'chat-unreadable' | 'chat-busy' | 'request-not-found' | 'chat-unsupported' | 'project-config-unsupported' | 'invalid-attachments' | 'subagent-not-found' | 'subagent-stale' | 'task-not-found' | 'goal-not-found' | 'transcript-missing' | 'transcript-format' | 'fork-failed' | 'turn-not-found' | 'item-not-found' | 'bookmark-not-found' | 'too-many-bookmarks' | 'visual-invalid' | 'visual-too-large';
+export type ChatErrorCode = 'refused-query' | 'stale-ui-query' | 'history-expired' | 'chat-not-found' | 'chat-unreadable' | 'chat-busy' | 'request-not-found' | 'chat-unsupported' | 'project-config-unsupported' | 'invalid-attachments' | 'subagent-not-found' | 'subagent-stale' | 'task-not-found' | 'goal-not-found' | 'transcript-missing' | 'transcript-format' | 'fork-failed' | 'turn-not-found' | 'payload-missing' | 'item-not-found' | 'bookmark-not-found' | 'too-many-bookmarks' | 'visual-invalid' | 'visual-too-large';
 export declare class ChatError<TCode extends string = ChatErrorCode> extends CodedError<TCode> {
 }

package/dist/chat/payload-store.d.ts

@@ -0,0 +1,28 @@
+import { type ChatCheckpointDiff, type ChatItem } from '@adecore/agent-contracts';
+export declare const PAYLOAD_PREVIEW_BYTES: number;
+export type PayloadSources = Map<string, (() => string) | null>;
+export interface CompactedItems {
+    items: ChatItem[];
+    payloads: PayloadSources;
+}
+export declare function payloadFolderName(chatId: string): string;
+export declare function previewOf(text: string, maxBytes: number): string;
+export declare function compactItems(items: readonly ChatItem[]): CompactedItems;
+export declare function payloadRefsOf(items: readonly ChatItem[]): Set<string>;
+export declare class PayloadStore {
+    private readonly dir;
+    private readonly present;
+    private readonly writtenDuringPrune;
+    constructor(dir: string);
+    folder(chatId: string): string;
+    ensure(chatId: string, payloads: PayloadSources): Promise<void>;
+    ensureSync(chatId: string, payloads: PayloadSources): void;
+    read(chatId: string, id: string): Promise<string>;
+    readDiff(chatId: string, id: string): Promise<ChatCheckpointDiff>;
+    prune(chatId: string, keep: ReadonlySet<string>): Promise<void>;
+    remove(chatId: string): Promise<void>;
+    private presentIn;
+    private mark;
+    private otherFolders;
+    private otherFoldersSync;
+}

package/dist/chat/payload-store.js

@@ -0,0 +1,350 @@
+import { createHash } from 'node:crypto';
+import { constants, copyFileSync, mkdirSync, readdirSync, statSync } from 'node:fs';
+import { copyFile, mkdir, readdir, readFile, rm, stat } from 'node:fs/promises';
+import { join } from 'node:path';
+import { promisify } from 'node:util';
+import { gunzip, gzip, gzipSync } from 'node:zlib';
+import { CHAT_PAYLOAD_INLINE_BYTES, ChatCheckpointDiffSchema } from '@adecore/agent-contracts';
+import { isNotFound, writeAtomic, writeAtomicSync } from '../fs.js';
+import { ChatError } from './errors.js';
+/* How much of a value stored apart the item keeps: what a timeline shows before anyone asks for the rest. */
+export const PAYLOAD_PREVIEW_BYTES = 8 * 1024;
+const FOLDER_SUFFIX = '.payloads';
+const ID_PATTERN = /^[0-9a-f]{64}$/;
+const CONTINUATION_MASK = 0xc0;
+const CONTINUATION = 0x80;
+const gzipAsync = promisify(gzip);
+const gunzipAsync = promisify(gunzip);
+// Items never change in place, so an item compacted once answers the same for every write of every chat after it.
+const compactedItems = new WeakMap();
+/* The folder of a chat's payloads beside its record, which `ChatStore.list` passes over since it is no JSON. */
+export function payloadFolderName(chatId) {
+    return `${encodeURIComponent(chatId)}${FOLDER_SUFFIX}`;
+}
+function payloadId(text) {
+    return createHash('sha256').update(text).digest('hex');
+}
+function byteLength(text) {
+    return Buffer.byteLength(text, 'utf8');
+}
+/* Whether a text is past the inline limit, without encoding the short ones: a UTF-16 unit is at most three bytes. */
+function pastInline(text) {
+    return text.length * 3 > CHAT_PAYLOAD_INLINE_BYTES && byteLength(text) > CHAT_PAYLOAD_INLINE_BYTES;
+}
+/*
+ * The beginning of a text in at most `maxBytes` of UTF-8, never cut inside a character, and cut after
+ * the last line break when that keeps at least half of it, so a preview ends on a whole line.
+ */
+export function previewOf(text, maxBytes) {
+    let units = Math.min(text.length, maxBytes);
+    // Half a surrogate pair would encode as a replacement character.
+    if (units < text.length && isHighSurrogate(text.charCodeAt(units - 1))) {
+        units -= 1;
+    }
+    const head = Buffer.from(text.slice(0, units), 'utf8');
+    let end = Math.min(head.length, maxBytes);
+    while (end > 0 && end < head.length && (head[end] & CONTINUATION_MASK) === CONTINUATION) {
+        end -= 1;
+    }
+    const prefix = head.subarray(0, end).toString('utf8');
+    if (prefix.length === text.length) {
+        return text;
+    }
+    const lineEnd = prefix.lastIndexOf('\n');
+    return lineEnd >= prefix.length / 2 ? prefix.slice(0, lineEnd + 1) : prefix;
+}
+function isHighSurrogate(code) {
+    return code >= 0xd800 && code <= 0xdbff;
+}
+/* Every file of a diff, with the diffs that fit the preview in order and the rest held back as empty. */
+function diffPreview(diff) {
+    let budget = PAYLOAD_PREVIEW_BYTES;
+    const files = diff.files.map((file) => {
+        const size = byteLength(file.diff);
+        if (size <= budget) {
+            budget -= size;
+            return file;
+        }
+        budget = 0;
+        return { ...file, diff: '' };
+    });
+    return { ...diff, files };
+}
+function compactOne(item) {
+    if (item.kind === 'tool') {
+        if (item.outputRef) {
+            return { item, payloads: [[item.outputRef.id, null]] };
+        }
+        const output = item.output;
+        if (output === null || !pastInline(output)) {
+            return { item, payloads: [] };
+        }
+        const ref = { id: payloadId(output), bytes: byteLength(output) };
+        return { item: { ...item, output: previewOf(output, PAYLOAD_PREVIEW_BYTES), outputRef: ref }, payloads: [[ref.id, () => output]] };
+    }
+    if (item.kind === 'turn' && item.checkpointDiff) {
+        if (item.checkpointDiffRef) {
+            return { item, payloads: [[item.checkpointDiffRef.id, null]] };
+        }
+        const json = JSON.stringify(item.checkpointDiff);
+        if (!pastInline(json)) {
+            return { item, payloads: [] };
+        }
+        const ref = { id: payloadId(json), bytes: byteLength(json) };
+        const diff = item.checkpointDiff;
+        return { item: { ...item, checkpointDiff: diffPreview(diff), checkpointDiffRef: ref }, payloads: [[ref.id, () => JSON.stringify(diff)]] };
+    }
+    return { item, payloads: [] };
+}
+/*
+ * A thread with every output and diff past the inline limit cut to its beginning, and what has to be
+ * on disk for the rest. A payload is named by the hash of its text, so the same text written twice, or
+ * copied in from another chat, is one file.
+ */
+export function compactItems(items) {
+    const payloads = new Map();
+    const compacted = items.map((item) => {
+        let known = compactedItems.get(item);
+        if (known === undefined) {
+            known = compactOne(item);
+            compactedItems.set(item, known);
+        }
+        for (const [id, source] of known.payloads) {
+            if (source !== null || !payloads.has(id)) {
+                payloads.set(id, source);
+            }
+        }
+        return known.item;
+    });
+    return { items: compacted, payloads };
+}
+export function payloadRefsOf(items) {
+    const ids = new Set();
+    for (const item of items) {
+        if (item.kind === 'tool' && item.outputRef) {
+            ids.add(item.outputRef.id);
+        }
+        else if (item.kind === 'turn' && item.checkpointDiffRef) {
+            ids.add(item.checkpointDiffRef.id);
+        }
+    }
+    return ids;
+}
+/*
+ * The outputs and diffs of every chat that are too large to keep in its record, one gzip file per
+ * payload under `<chats>/<chat id>.payloads/<sha-256>.gz`. Each chat has its own folder, so removing
+ * a chat never reaches into a fork that copied from it.
+ */
+export class PayloadStore {
+    dir;
+    // What this process knows is on disk per chat, so a write checks a payload once and not every time.
+    present = new Map();
+    // What was written while a prune ran, which that prune must not take away again.
+    writtenDuringPrune = new Map();
+    constructor(dir) {
+        this.dir = dir;
+    }
+    folder(chatId) {
+        return join(this.dir, payloadFolderName(chatId));
+    }
+    /* Puts every payload on disk that is not there yet: from its text, or copied from another chat that has it. */
+    async ensure(chatId, payloads) {
+        const present = this.presentIn(chatId);
+        const folder = this.folder(chatId);
+        let others = null;
+        for (const [id, source] of payloads) {
+            if (present.has(id)) {
+                continue;
+            }
+            const path = join(folder, `${id}.gz`);
+            if (await existsAsync(path)) {
+                this.mark(chatId, id);
+                continue;
+            }
+            await mkdir(folder, { recursive: true, mode: 0o700 });
+            if (source !== null) {
+                await writeAtomic(path, await gzipAsync(source()));
+                this.mark(chatId, id);
+                continue;
+            }
+            others ??= await this.otherFolders(chatId);
+            if (await copyFromAny(others, id, path)) {
+                this.mark(chatId, id);
+            }
+        }
+    }
+    /* `ensure` without a turn of the event loop, for a write on the way out. */
+    ensureSync(chatId, payloads) {
+        const present = this.presentIn(chatId);
+        const folder = this.folder(chatId);
+        let others = null;
+        for (const [id, source] of payloads) {
+            if (present.has(id)) {
+                continue;
+            }
+            const path = join(folder, `${id}.gz`);
+            if (existsSync(path)) {
+                this.mark(chatId, id);
+                continue;
+            }
+            mkdirSync(folder, { recursive: true, mode: 0o700 });
+            if (source !== null) {
+                writeAtomicSync(path, gzipSync(source()));
+                this.mark(chatId, id);
+                continue;
+            }
+            others ??= this.otherFoldersSync(chatId);
+            if (copyFromAnySync(others, id, path)) {
+                this.mark(chatId, id);
+            }
+        }
+    }
+    async read(chatId, id) {
+        if (!ID_PATTERN.test(id)) {
+            throw new ChatError('payload-missing', `No stored payload ${id} in chat ${chatId}`);
+        }
+        let packed;
+        try {
+            packed = await readFile(join(this.folder(chatId), `${id}.gz`));
+        }
+        catch (e) {
+            if (isNotFound(e)) {
+                throw new ChatError('payload-missing', `The stored payload ${id} of chat ${chatId} is gone`);
+            }
+            throw e;
+        }
+        return (await gunzipAsync(packed)).toString('utf8');
+    }
+    async readDiff(chatId, id) {
+        const parsed = ChatCheckpointDiffSchema.safeParse(JSON.parse(await this.read(chatId, id)));
+        if (!parsed.success) {
+            throw new ChatError('payload-missing', `The stored diff ${id} of chat ${chatId} does not read`);
+        }
+        return parsed.data;
+    }
+    /* Removes the payloads of a chat its thread no longer refers to, such as everything before a clear. */
+    async prune(chatId, keep) {
+        const folder = this.folder(chatId);
+        let names;
+        try {
+            names = await readdir(folder);
+        }
+        catch (e) {
+            if (isNotFound(e)) {
+                return;
+            }
+            throw e;
+        }
+        const written = new Set();
+        this.writtenDuringPrune.set(chatId, written);
+        try {
+            for (const name of names) {
+                const id = name.replace(/\.gz$/, '');
+                if (keep.has(id) || written.has(id)) {
+                    continue;
+                }
+                this.present.get(chatId)?.delete(id);
+                await rm(join(folder, name), { force: true });
+            }
+        }
+        finally {
+            this.writtenDuringPrune.delete(chatId);
+        }
+    }
+    async remove(chatId) {
+        this.present.delete(chatId);
+        await rm(this.folder(chatId), { recursive: true, force: true });
+    }
+    presentIn(chatId) {
+        let present = this.present.get(chatId);
+        if (!present) {
+            present = new Set();
+            this.present.set(chatId, present);
+        }
+        return present;
+    }
+    mark(chatId, id) {
+        this.presentIn(chatId).add(id);
+        this.writtenDuringPrune.get(chatId)?.add(id);
+    }
+    async otherFolders(chatId) {
+        try {
+            return foldersOf(this.dir, await readdir(this.dir), chatId);
+        }
+        catch (e) {
+            if (isNotFound(e)) {
+                return [];
+            }
+            throw e;
+        }
+    }
+    otherFoldersSync(chatId) {
+        try {
+            return foldersOf(this.dir, readdirSync(this.dir), chatId);
+        }
+        catch (e) {
+            if (isNotFound(e)) {
+                return [];
+            }
+            throw e;
+        }
+    }
+}
+function foldersOf(dir, names, chatId) {
+    const own = payloadFolderName(chatId);
+    return names.filter((name) => name.endsWith(FOLDER_SUFFIX) && name !== own).map((name) => join(dir, name));
+}
+// A clone where the file system has one, so a fork of a large chat takes no space until either side changes.
+const COPY_MODE = constants.COPYFILE_FICLONE;
+async function copyFromAny(folders, id, target) {
+    for (const folder of folders) {
+        try {
+            await copyFile(join(folder, `${id}.gz`), target, COPY_MODE);
+            return true;
+        }
+        catch (e) {
+            if (!isNotFound(e)) {
+                throw e;
+            }
+        }
+    }
+    return false;
+}
+function copyFromAnySync(folders, id, target) {
+    for (const folder of folders) {
+        try {
+            copyFileSync(join(folder, `${id}.gz`), target, COPY_MODE);
+            return true;
+        }
+        catch (e) {
+            if (!isNotFound(e)) {
+                throw e;
+            }
+        }
+    }
+    return false;
+}
+async function existsAsync(path) {
+    try {
+        await stat(path);
+        return true;
+    }
+    catch (e) {
+        if (isNotFound(e)) {
+            return false;
+        }
+        throw e;
+    }
+}
+function existsSync(path) {
+    try {
+        statSync(path);
+        return true;
+    }
+    catch (e) {
+        if (isNotFound(e)) {
+            return false;
+        }
+        throw e;
+    }
+}

package/dist/chat/projector.js

@@ -222,7 +222,8 @@ export class ThreadProjector {
                 if (target?.kind === 'tool' && target.name === 'Workflow' && event.state === 'done' && event.output?.startsWith(WORKFLOW_LAUNCHED)) {
                     // The call only launched the workflow; the row runs on past the turn until the workflow's task ends.
                     this.backgroundCalls.add(target.id);
-                    events.push(this.thread.upsert({ ...target, output: event.output }));
+                    const { outputRef: _earlier, ...launched } = target;
+                    events.push(this.thread.upsert({ ...launched, output: event.output }));
                     break;
                 }
                 this.settleTool(generation, event, events);
@@ -521,6 +522,9 @@ export class ThreadProjector {
         if (previous?.progress) {
             item.progress = previous.progress;
         }
+        if (previous?.outputRef) {
+            item.outputRef = previous.outputRef;
+        }
         const changes = event.changes ?? previous?.changes;
         if (changes) {
             item.changes = changes;
@@ -542,6 +546,10 @@ export class ThreadProjector {
         // The result supersedes whatever progress said; a settled call carries none.
         const settled = { ...tool, output: event.output ?? tool.output, state: event.state };
         delete settled.progress;
+        // A stored whole of an earlier output would answer for this one.
+        if (event.output != null) {
+            delete settled.outputRef;
+        }
         if (event.changes) {
             settled.changes = event.changes;
         }

package/dist/host/handlers.js

@@ -61,6 +61,7 @@ export function chatHandlers(chats, providers) {
             return {};
         },
         'chat.turnDiff': async (payload) => ({ diff: await chats.turnDiff(payload.chatId, payload.turnId) }),
+        'chat.toolOutput': async (payload) => ({ output: await chats.toolOutput(payload.chatId, payload.itemId) }),
         'chat.fork': unsupported('fork chats'),
         'chat.forkInfo': unsupported('fork chats'),
         'chat.summarize': unsupported('fork chats'),

package/dist/usage/history-file.d.ts

@@ -0,0 +1,25 @@
+import { type UsageProvider } from '@adecore/agent-contracts';
+import { type UsageRecord } from './record.ts';
+export interface FileUsage {
+    provider: UsageProvider;
+    records: UsageRecord[];
+    tail: UsageRecord[];
+}
+export interface HistoryEntry {
+    path: string;
+    op: 'set' | 'add';
+    usage: FileUsage;
+}
+export interface HistoryHeader {
+    gen: string;
+    base: number;
+}
+export declare function encodeHeader(header: HistoryHeader): string;
+export declare function encodeEntry(entry: HistoryEntry): string;
+export declare function applyEntry(usage: Map<string, FileUsage>, entry: HistoryEntry): void;
+export interface DecodedHistory {
+    header: HistoryHeader | null;
+    usage: Map<string, FileUsage>;
+    complete: number;
+}
+export declare function decodeHistory(bytes: Uint8Array): DecodedHistory;