@adecore/agents 0.46.1 → 0.46.3

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

@@ -82,6 +82,7 @@ export interface ChatCoreOptions {
     };
     accounts?: AccountLaunches;
     hooks?: ChatCoreHooks;
+    unloadAfterMs?: number;
 }
 export declare class ChatCore {
     protected readonly bookmarks: BookmarkStore | null;
@@ -123,6 +124,9 @@ export declare class ChatCore {
     private readonly nameChat;
     private readonly onInterruptedRun;
     private readonly limitResume;
+    private readonly unloadAfterMs;
+    private readonly unloadTimers;
+    private readonly unloadedInfo;
     constructor(options: ChatCoreOptions);
     codexProcess(info: Pick<ChatInfo, 'cwd' | 'account'>): CodexProcessSpec;
     claudeProjectsDirOf(info: Pick<ChatInfo, 'account'>): string;
@@ -257,6 +261,11 @@ export declare class ChatCore {
         updatedAt: number;
     }[];
     list(): ChatInfo[];
+    unloadIdle(chatId: string): Promise<boolean>;
+    private unloadable;
+    private scheduleUnload;
+    private cancelUnload;
+    private forgetLoaded;
     get(chatId: string): ChatSession | undefined;
     resumeRun(chatId: string, turnId: string, attempt: number): Promise<void>;
     takeUpAfterLimit(chatId: string, turnId: string): Promise<OutboxOutcome>;

package/dist/chat/chat-core.js

@@ -94,6 +94,10 @@ export class ChatCore {
     nameChat;
     onInterruptedRun;
     limitResume;
+    unloadAfterMs;
+    unloadTimers = new Map();
+    // The last info of each chat that left memory, so `list` still answers what it was doing.
+    unloadedInfo = new Map();
     constructor(options) {
         this.uiQueries = options.intelligentUi ? new ChatUiQueries(options.intelligentUi) : null;
         this.uiFenceLanguage = options.uiFenceLanguage;
@@ -111,6 +115,7 @@ export class ChatCore {
         this.nameChat = options.nameChat ?? null;
         this.onInterruptedRun = options.onInterruptedRun ?? null;
         this.limitResume = options.limitResume ?? null;
+        this.unloadAfterMs = options.store && options.unloadAfterMs !== undefined ? options.unloadAfterMs : null;
         this.hooks = options.hooks ?? {};
         this.commands = {
             ...(options.command ? { claude: options.command } : {}),
@@ -325,12 +330,15 @@ export class ChatCore {
             ...(this.limitResume ? { limitResume: limitHooks(this.limitResume, payload.chatId) } : {})
         });
         this.chats.set(session.id, session);
+        this.unloadedInfo.delete(session.id);
         if (stored) {
             session.settleStored(selection, resume);
             session.settleOwedResume();
             await session.settleOrphanedSubagents();
         }
         await this.hooks.opened?.(session, stored ?? null);
+        // A chat loaded for someone who never attaches, such as a host reading it, leaves again on its own.
+        this.scheduleUnload(session.id);
         return session.info;
     }
     async storedBackground(chatId) {
@@ -392,6 +400,7 @@ export class ChatCore {
         // client is on the list: the text is either in the snapshot or in the stream, never both.
         this.coalescers.get(chatId)?.flush();
         clients.add(clientId);
+        this.cancelUnload(chatId);
         const log = this.logs.get(chatId);
         const events = since === undefined ? null : log.after(since);
         if (events !== null) {
@@ -509,12 +518,14 @@ export class ChatCore {
     detach(chatId, clientId) {
         this.coalescers.get(chatId)?.flush();
         this.attached.get(chatId)?.delete(clientId);
+        this.scheduleUnload(chatId);
     }
     detachAll(clientId) {
         for (const [chatId, clients] of this.attached) {
             if (clients.has(clientId)) {
                 this.coalescers.get(chatId)?.flush();
                 clients.delete(clientId);
+                this.scheduleUnload(chatId);
             }
         }
         this.subagents.releaseClient(clientId);
@@ -613,6 +624,7 @@ export class ChatCore {
         if (this.chats.has(chatId) || this.creating.has(chatId)) {
             return false;
         }
+        this.unloadedInfo.delete(chatId);
         await Promise.all([
             this.store?.delete(chatId),
             this.attachments.removeAll(chatId),
@@ -897,21 +909,9 @@ export class ChatCore {
         // A write already out would put the record back after the delete.
         const writing = this.writes.get(chatId);
         const ended = session.dispose();
-        this.subagents.releaseChat(chatId);
-        this.uiQueries?.forget(chatId);
-        this.coalescers.get(chatId)?.dispose();
-        this.coalescers.delete(chatId);
-        this.logs.get(chatId)?.close();
-        this.logs.delete(chatId);
-        this.cancelWaiting(chatId);
-        this.sizes.delete(chatId);
-        this.unlogged.delete(chatId);
-        this.writes.delete(chatId);
-        this.activity.delete(chatId);
-        this.chats.delete(chatId);
+        this.forgetLoaded(chatId);
         this.attached.delete(chatId);
-        this.listChanges.delete(chatId);
-        this.announced.delete(chatId);
+        this.unloadedInfo.delete(chatId);
         const snapshot = session.thread.snapshot();
         this.hooks.forgotten?.(chatId);
         await writing;
@@ -944,7 +944,75 @@ export class ChatCore {
         return targets;
     }
     list() {
-        return [...this.chats.values()].map((session) => session.info);
+        return [...[...this.chats.values()].map((session) => session.info), ...this.unloadedInfo.values()];
+    }
+    /*
+     * Puts a chat nobody needs in memory back on disk alone: nobody reads it, it has no CLI, no turn,
+     * request, hold or move is under way, and no resume is owed. Answers whether it left. The next
+     * create, attach or note loads it again from its record, as after a restart.
+     */
+    async unloadIdle(chatId) {
+        this.cancelUnload(chatId);
+        if (!this.unloadable(chatId)) {
+            return false;
+        }
+        await this.persistNow(chatId, true);
+        const session = this.chats.get(chatId);
+        // Someone may have attached or sent while the record was written.
+        if (!session || !this.unloadable(chatId)) {
+            return false;
+        }
+        this.forgetLoaded(chatId);
+        this.attached.delete(chatId);
+        this.unloadedInfo.set(chatId, session.info);
+        await session.dispose();
+        return true;
+    }
+    unloadable(chatId) {
+        const session = this.chats.get(chatId);
+        return (session !== undefined &&
+            this.store !== null &&
+            (this.attached.get(chatId)?.size ?? 0) === 0 &&
+            !this.creating.has(chatId) &&
+            !this.relocations.has(chatId) &&
+            session.pid === null &&
+            session.relocatable &&
+            session.info.resumeAt === undefined &&
+            (session.info.requests?.length ?? 0) === 0);
+    }
+    scheduleUnload(chatId) {
+        if (this.unloadAfterMs === null || (this.attached.get(chatId)?.size ?? 0) > 0) {
+            return;
+        }
+        this.cancelUnload(chatId);
+        const timer = setTimeout(() => {
+            this.unloadTimers.delete(chatId);
+            void this.unloadIdle(chatId).catch((e) => console.error(`Unloading chat ${chatId} failed:`, errorText(e)));
+        }, this.unloadAfterMs);
+        timer.unref?.();
+        this.unloadTimers.set(chatId, timer);
+    }
+    cancelUnload(chatId) {
+        clearTimeout(this.unloadTimers.get(chatId));
+        this.unloadTimers.delete(chatId);
+    }
+    /* Drops what the core keeps of a loaded chat beside its session, which a kill and an unload share. */
+    forgetLoaded(chatId) {
+        this.subagents.releaseChat(chatId);
+        this.uiQueries?.forget(chatId);
+        this.coalescers.get(chatId)?.dispose();
+        this.coalescers.delete(chatId);
+        this.logs.get(chatId)?.close();
+        this.logs.delete(chatId);
+        this.cancelWaiting(chatId);
+        this.cancelUnload(chatId);
+        this.sizes.delete(chatId);
+        this.unlogged.delete(chatId);
+        this.writes.delete(chatId);
+        this.activity.delete(chatId);
+        this.chats.delete(chatId);
+        this.listChanges.delete(chatId);
+        this.announced.delete(chatId);
     }
     get(chatId) {
         return this.chats.get(chatId);
@@ -1032,6 +1100,7 @@ export class ChatCore {
         }
         for (const chatId of this.chats.keys()) {
             this.cancelWaiting(chatId);
+            this.cancelUnload(chatId);
         }
         // A thread that cannot be written still ends its CLI, whose process group would otherwise outlive the host.
         const written = await Promise.allSettled([...this.chats.keys()].map((chatId) => this.persistNow(chatId, true)));
@@ -1173,6 +1242,8 @@ export class ChatCore {
         for (const clientId of this.attached.get(chatId) ?? []) {
             this.sinks.to(clientId, { event: 'chat.event', payload });
         }
+        // A chat nobody reads counts its time from what it said last, such as its CLI going down.
+        this.scheduleUnload(chatId);
         // After the thread, so a client reading it has already had this info and the status is a no-op there.
         if (event.type === 'info' || event.type === 'reset') {
             this.announceStatus(chatId, event.info);

package/dist/chat/payload-store.js

@@ -8,7 +8,7 @@ import { CHAT_PAYLOAD_INLINE_BYTES, ChatCheckpointDiffSchema } from '@adecore/ag
 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;
+export const PAYLOAD_PREVIEW_BYTES = 2 * 1024;
 const FOLDER_SUFFIX = '.payloads';
 const ID_PATTERN = /^[0-9a-f]{64}$/;
 const CONTINUATION_MASK = 0xc0;

package/package.json

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

package/src/chat/chat-core.ts

@@ -215,6 +215,12 @@ export interface ChatCoreOptions {
     // The accounts a chat may run under; without them every chat runs under its CLI's default account.
     accounts?: AccountLaunches;
     hooks?: ChatCoreHooks;
+    /*
+     * How long a chat stays in memory once nobody reads it, its CLI is gone and nothing is under way;
+     * after that only its info stays, for `list`, until something loads it again. Without it, or
+     * without a store, a loaded chat stays until it is removed or the host stops.
+     */
+    unloadAfterMs?: number;
 }
 
 /*
@@ -272,6 +278,10 @@ export class ChatCore {
     private readonly nameChat: ChatCoreOptions['nameChat'] | null;
     private readonly onInterruptedRun: ChatCoreOptions['onInterruptedRun'] | null;
     private readonly limitResume: ChatCoreOptions['limitResume'] | null;
+    private readonly unloadAfterMs: number | null;
+    private readonly unloadTimers = new Map<string, ReturnType<typeof setTimeout>>();
+    // The last info of each chat that left memory, so `list` still answers what it was doing.
+    private readonly unloadedInfo = new Map<string, ChatInfo>();
 
     constructor(options: ChatCoreOptions) {
         this.uiQueries = options.intelligentUi ? new ChatUiQueries(options.intelligentUi) : null;
@@ -290,6 +300,7 @@ export class ChatCore {
         this.nameChat = options.nameChat ?? null;
         this.onInterruptedRun = options.onInterruptedRun ?? null;
         this.limitResume = options.limitResume ?? null;
+        this.unloadAfterMs = options.store && options.unloadAfterMs !== undefined ? options.unloadAfterMs : null;
         this.hooks = options.hooks ?? {};
 
         this.commands = {
@@ -549,6 +560,7 @@ export class ChatCore {
         });
 
         this.chats.set(session.id, session);
+        this.unloadedInfo.delete(session.id);
 
         if (stored) {
             session.settleStored(selection, resume);
@@ -557,6 +569,8 @@ export class ChatCore {
         }
 
         await this.hooks.opened?.(session, stored ?? null);
+        // A chat loaded for someone who never attaches, such as a host reading it, leaves again on its own.
+        this.scheduleUnload(session.id);
 
         return session.info;
     }
@@ -642,6 +656,7 @@ export class ChatCore {
         // client is on the list: the text is either in the snapshot or in the stream, never both.
         this.coalescers.get(chatId)?.flush();
         clients.add(clientId);
+        this.cancelUnload(chatId);
         const log = this.logs.get(chatId)!;
         const events = since === undefined ? null : log.after(since);
 
@@ -797,6 +812,7 @@ export class ChatCore {
     detach(chatId: string, clientId: string): void {
         this.coalescers.get(chatId)?.flush();
         this.attached.get(chatId)?.delete(clientId);
+        this.scheduleUnload(chatId);
     }
 
     detachAll(clientId: string): void {
@@ -804,6 +820,7 @@ export class ChatCore {
             if (clients.has(clientId)) {
                 this.coalescers.get(chatId)?.flush();
                 clients.delete(clientId);
+                this.scheduleUnload(chatId);
             }
         }
 
@@ -931,6 +948,8 @@ export class ChatCore {
             return false;
         }
 
+        this.unloadedInfo.delete(chatId);
+
         await Promise.all([
             this.store?.delete(chatId),
             this.attachments.removeAll(chatId),
@@ -1295,21 +1314,9 @@ export class ChatCore {
         // A write already out would put the record back after the delete.
         const writing = this.writes.get(chatId);
         const ended = session.dispose();
-        this.subagents.releaseChat(chatId);
-        this.uiQueries?.forget(chatId);
-        this.coalescers.get(chatId)?.dispose();
-        this.coalescers.delete(chatId);
-        this.logs.get(chatId)?.close();
-        this.logs.delete(chatId);
-        this.cancelWaiting(chatId);
-        this.sizes.delete(chatId);
-        this.unlogged.delete(chatId);
-        this.writes.delete(chatId);
-        this.activity.delete(chatId);
-        this.chats.delete(chatId);
+        this.forgetLoaded(chatId);
         this.attached.delete(chatId);
-        this.listChanges.delete(chatId);
-        this.announced.delete(chatId);
+        this.unloadedInfo.delete(chatId);
         const snapshot = session.thread.snapshot();
         this.hooks.forgotten?.(chatId);
         await writing;
@@ -1349,7 +1356,91 @@ export class ChatCore {
     }
 
     list(): ChatInfo[] {
-        return [...this.chats.values()].map((session) => session.info);
+        return [...[...this.chats.values()].map((session) => session.info), ...this.unloadedInfo.values()];
+    }
+
+    /*
+     * Puts a chat nobody needs in memory back on disk alone: nobody reads it, it has no CLI, no turn,
+     * request, hold or move is under way, and no resume is owed. Answers whether it left. The next
+     * create, attach or note loads it again from its record, as after a restart.
+     */
+    async unloadIdle(chatId: string): Promise<boolean> {
+        this.cancelUnload(chatId);
+
+        if (!this.unloadable(chatId)) {
+            return false;
+        }
+
+        await this.persistNow(chatId, true);
+        const session = this.chats.get(chatId);
+
+        // Someone may have attached or sent while the record was written.
+        if (!session || !this.unloadable(chatId)) {
+            return false;
+        }
+
+        this.forgetLoaded(chatId);
+        this.attached.delete(chatId);
+        this.unloadedInfo.set(chatId, session.info);
+        await session.dispose();
+
+        return true;
+    }
+
+    private unloadable(chatId: string): boolean {
+        const session = this.chats.get(chatId);
+
+        return (
+            session !== undefined &&
+            this.store !== null &&
+            (this.attached.get(chatId)?.size ?? 0) === 0 &&
+            !this.creating.has(chatId) &&
+            !this.relocations.has(chatId) &&
+            session.pid === null &&
+            session.relocatable &&
+            session.info.resumeAt === undefined &&
+            (session.info.requests?.length ?? 0) === 0
+        );
+    }
+
+    private scheduleUnload(chatId: string): void {
+        if (this.unloadAfterMs === null || (this.attached.get(chatId)?.size ?? 0) > 0) {
+            return;
+        }
+
+        this.cancelUnload(chatId);
+
+        const timer = setTimeout(() => {
+            this.unloadTimers.delete(chatId);
+            void this.unloadIdle(chatId).catch((e) => console.error(`Unloading chat ${chatId} failed:`, errorText(e)));
+        }, this.unloadAfterMs);
+
+        timer.unref?.();
+        this.unloadTimers.set(chatId, timer);
+    }
+
+    private cancelUnload(chatId: string): void {
+        clearTimeout(this.unloadTimers.get(chatId));
+        this.unloadTimers.delete(chatId);
+    }
+
+    /* Drops what the core keeps of a loaded chat beside its session, which a kill and an unload share. */
+    private forgetLoaded(chatId: string): void {
+        this.subagents.releaseChat(chatId);
+        this.uiQueries?.forget(chatId);
+        this.coalescers.get(chatId)?.dispose();
+        this.coalescers.delete(chatId);
+        this.logs.get(chatId)?.close();
+        this.logs.delete(chatId);
+        this.cancelWaiting(chatId);
+        this.cancelUnload(chatId);
+        this.sizes.delete(chatId);
+        this.unlogged.delete(chatId);
+        this.writes.delete(chatId);
+        this.activity.delete(chatId);
+        this.chats.delete(chatId);
+        this.listChanges.delete(chatId);
+        this.announced.delete(chatId);
     }
 
     get(chatId: string): ChatSession | undefined {
@@ -1460,6 +1551,7 @@ export class ChatCore {
 
         for (const chatId of this.chats.keys()) {
             this.cancelWaiting(chatId);
+            this.cancelUnload(chatId);
         }
 
         // A thread that cannot be written still ends its CLI, whose process group would otherwise outlive the host.
@@ -1649,6 +1741,9 @@ export class ChatCore {
             this.sinks.to(clientId, { event: 'chat.event', payload });
         }
 
+        // A chat nobody reads counts its time from what it said last, such as its CLI going down.
+        this.scheduleUnload(chatId);
+
         // After the thread, so a client reading it has already had this info and the status is a no-op there.
         if (event.type === 'info' || event.type === 'reset') {
             this.announceStatus(chatId, event.info);

package/src/chat/payload-store.ts

@@ -9,7 +9,7 @@ import { isNotFound, writeAtomic, writeAtomicSync } from '../fs.ts';
 import { ChatError } from './errors.ts';
 
 /* 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;
+export const PAYLOAD_PREVIEW_BYTES = 2 * 1024;
 
 const FOLDER_SUFFIX = '.payloads';
 const ID_PATTERN = /^[0-9a-f]{64}$/;