@adecore/agents 0.40.1 → 0.40.3

package/dist/async.d.ts

@@ -5,3 +5,6 @@ export interface DeadlineTimer {
 }
 export declare function withDeadline<T>(promise: Promise<T>, ms: number, message: string, timer?: DeadlineTimer): Promise<T>;
 export declare function withTimeout<T>(promise: Promise<T>, ms: number, message: string): Promise<T>;
+export type Timer = (ms: number, run: () => void) => () => void;
+export declare const cancellableTimeout: Timer;
+export declare const unrefTimeout: Timer;

package/dist/async.js

@@ -32,3 +32,13 @@ export function withDeadline(promise, ms, message, timer = SYSTEM_TIMER) {
 export function withTimeout(promise, ms, message) {
     return withDeadline(promise, ms, message);
 }
+export const cancellableTimeout = (ms, run) => {
+    const timer = setTimeout(run, ms);
+    return () => clearTimeout(timer);
+};
+/* The same, without holding the process open for it. */
+export const unrefTimeout = (ms, run) => {
+    const timer = setTimeout(run, ms);
+    timer.unref?.();
+    return () => clearTimeout(timer);
+};

package/dist/chat/chat-core.js

@@ -1,5 +1,5 @@
 import { join } from 'node:path';
-import { ChatAttachmentUploadsSchema, generatedImageAttachment, HOST_TASK_ORIGIN } from '@adecore/agent-contracts';
+import { ChatAttachmentUploadsSchema, generatedImageAttachment, holdsConversation, HOST_TASK_ORIGIN } from '@adecore/agent-contracts';
 import { ClientSinks } from '../client-sinks.js';
 import { errorText } from '../error-text.js';
 import { AccountError, definedEnv, isDefaultAccountOf, launchEnv, storedAccount } from '../providers/accounts/launch.js';
@@ -371,8 +371,7 @@ export class ChatCore {
         }
         // As named, so a switch to the default account is refused while it is turned off.
         this.requireAccount(kind, requested);
-        const spoke = session.info.agentSessionId !== null || session.info.usage.turns > 0;
-        if (spoke && !this.canContinue(kind, from, to)) {
+        if (holdsConversation(session.info) && !this.canContinue(kind, from, to)) {
             const label = this.accountLabel(kind, to);
             throw new AccountError('account-incompatible', `This conversation is kept by the account '${this.accountLabel(kind, from)}', which '${label}' cannot read. Fork the chat to go on under '${label}'.`);
         }

package/dist/client-sinks.d.ts

@@ -7,3 +7,11 @@ export declare class ClientSinks<TEvent> {
     to(clientId: string, event: TEvent): void;
     clientIds(): string[];
 }
+export declare class WatchedSinks<TEvent> {
+    private readonly sinks;
+    private readonly watching;
+    subscribe(clientId: string, sink: (event: TEvent) => void): () => void;
+    watch(clientId: string): void;
+    unwatch(clientId: string): void;
+    emit(event: TEvent): void;
+}

package/dist/client-sinks.js

@@ -32,3 +32,26 @@ export class ClientSinks {
         return [...this.sinks.keys()];
     }
 }
+/* The clients of a part that hear its events only after they asked for them with `<area>.watch`. */
+export class WatchedSinks {
+    sinks = new ClientSinks();
+    watching = new Set();
+    subscribe(clientId, sink) {
+        const unsubscribe = this.sinks.subscribe(clientId, sink);
+        return () => {
+            this.watching.delete(clientId);
+            unsubscribe();
+        };
+    }
+    watch(clientId) {
+        this.watching.add(clientId);
+    }
+    unwatch(clientId) {
+        this.watching.delete(clientId);
+    }
+    emit(event) {
+        for (const clientId of this.watching) {
+            this.sinks.to(clientId, event);
+        }
+    }
+}

package/dist/fs.d.ts

@@ -11,3 +11,4 @@ export declare function removeFile(path: string, remove?: (path: string, options
     force: true;
 }) => Promise<void>): Promise<void>;
 export declare function fileExists(path: string): Promise<boolean>;
+export declare function entryExists(path: string): Promise<boolean>;

package/dist/fs.js

@@ -1,5 +1,5 @@
 import { renameSync, writeFileSync } from 'node:fs';
-import { open, rename, rm, stat, writeFile } from 'node:fs/promises';
+import { lstat, open, rename, rm, stat, writeFile } from 'node:fs/promises';
 import { dirname } from 'node:path';
 import { wait } from './async.js';
 // Windows can refuse a rename while a watcher or an indexer holds the target; a few short retries cover it.
@@ -120,3 +120,13 @@ export async function fileExists(path) {
         return false;
     }
 }
+/* Whether anything is at the path, a link that leads nowhere included, where `fileExists` follows the link. */
+export async function entryExists(path) {
+    try {
+        await lstat(path);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/host/index.d.ts

@@ -3,5 +3,5 @@ export { RUIMTE_SESSION_VARIABLES, cliEnvironment, type CliEnvironmentPolicy } f
 export { type AgentHandler, type AgentHandlers, chatHandlers, accountHandlers, usageHandlers, type AgentRequestMap, type ChatRequestType } from './handlers.ts';
 export { memoryPortPair } from './memory-port.ts';
 export { type AgentWiring, wireAgents, type AgentWiringOptions } from './wiring.ts';
-export { ClientSinks } from '../client-sinks.ts';
+export { ClientSinks, WatchedSinks } from '../client-sinks.ts';
 export type { AgentEvent, AgentEventMap, AgentSink } from '../events.ts';

package/dist/host/index.js

@@ -4,4 +4,4 @@ export { RUIMTE_SESSION_VARIABLES, cliEnvironment } from './environment.js';
 export { chatHandlers, accountHandlers, usageHandlers } from './handlers.js';
 export { memoryPortPair } from './memory-port.js';
 export { wireAgents } from './wiring.js';
-export { ClientSinks } from '../client-sinks.js';
+export { ClientSinks, WatchedSinks } from '../client-sinks.js';

package/dist/index.d.ts

@@ -1,9 +1,10 @@
-export { wait, withTimeout } from './async.ts';
+export { wait, withTimeout, cancellableTimeout, unrefTimeout, type Timer } from './async.ts';
 export { CodedError } from './coded-error.ts';
 export { describeError, setErrorStacks, errorText } from './error-text.ts';
-export { tempNameFor, writeAtomic, replaceSync, writeAtomicSync, isNotFound, fileExists, type WriteAtomicOptions } from './fs.ts';
+export { tempNameFor, writeAtomic, replaceSync, writeAtomicSync, hasErrorCode, isNotFound, fileExists, entryExists, type WriteAtomicOptions } from './fs.ts';
 export { RecordDirectory, type RecordDirectoryOptions } from './record-directory.ts';
 export { runProcess, type ProcessResult, type RunProcessOptions } from './run-process.ts';
 export { Serializer, KeyedSerializer } from './serializer.ts';
+export { SingleFlight } from './single-flight.ts';
 export { cleanTitle, readLines } from './title-file.ts';
 export { type DirectoryWatcher, type WatchSeams, supportsRecursive, SYSTEM_WATCH, type Settled, settled, PerClientWatches, type WatchDirectory, type Schedule } from './watch-seam.ts';

package/dist/index.js

@@ -1,10 +1,11 @@
 // Public API: exports.test.ts snapshots this list, so a name added or dropped here is an API change.
-export { wait, withTimeout } from './async.js';
+export { wait, withTimeout, cancellableTimeout, unrefTimeout } from './async.js';
 export { CodedError } from './coded-error.js';
 export { describeError, setErrorStacks, errorText } from './error-text.js';
-export { tempNameFor, writeAtomic, replaceSync, writeAtomicSync, isNotFound, fileExists } from './fs.js';
+export { tempNameFor, writeAtomic, replaceSync, writeAtomicSync, hasErrorCode, isNotFound, fileExists, entryExists } from './fs.js';
 export { RecordDirectory } from './record-directory.js';
 export { runProcess } from './run-process.js';
 export { Serializer, KeyedSerializer } from './serializer.js';
+export { SingleFlight } from './single-flight.js';
 export { cleanTitle, readLines } from './title-file.js';
 export { supportsRecursive, SYSTEM_WATCH, settled, PerClientWatches } from './watch-seam.js';

package/dist/single-flight.d.ts

@@ -0,0 +1,6 @@
+export declare class SingleFlight<T> {
+    private readonly flights;
+    get(key: string): Promise<T> | undefined;
+    has(key: string): boolean;
+    run(key: string, work: () => Promise<T>): Promise<T>;
+}

package/dist/single-flight.js

@@ -0,0 +1,27 @@
+/*
+ * Work that runs once per key at a time: a caller that asks while it runs shares its outcome, and
+ * a key that settled leaves nothing behind.
+ */
+export class SingleFlight {
+    flights = new Map();
+    /* The run in flight for `key`, if any. */
+    get(key) {
+        return this.flights.get(key);
+    }
+    has(key) {
+        return this.flights.has(key);
+    }
+    run(key, work) {
+        const running = this.flights.get(key);
+        if (running !== undefined) {
+            return running;
+        }
+        const flight = work().finally(() => {
+            if (this.flights.get(key) === flight) {
+                this.flights.delete(key);
+            }
+        });
+        this.flights.set(key, flight);
+        return flight;
+    }
+}

package/package.json

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

package/src/async.ts

@@ -50,3 +50,20 @@ export function withDeadline<T>(promise: Promise<T>, ms: number, message: string
 export function withTimeout<T>(promise: Promise<T>, ms: number, message: string): Promise<T> {
     return withDeadline(promise, ms, message);
 }
+
+/* Runs `run` after `ms` and answers how to call it off. */
+export type Timer = (ms: number, run: () => void) => () => void;
+
+export const cancellableTimeout: Timer = (ms, run) => {
+    const timer = setTimeout(run, ms);
+
+    return () => clearTimeout(timer);
+};
+
+/* The same, without holding the process open for it. */
+export const unrefTimeout: Timer = (ms, run) => {
+    const timer = setTimeout(run, ms);
+    timer.unref?.();
+
+    return () => clearTimeout(timer);
+};

package/src/chat/chat-core.ts

@@ -2,6 +2,7 @@ import { join } from 'node:path';
 import {
     ChatAttachmentUploadsSchema,
     generatedImageAttachment,
+    holdsConversation,
     HOST_TASK_ORIGIN,
     type AgentKind,
     type ChatAttachment,
@@ -612,9 +613,7 @@ export class ChatCore {
 
         // As named, so a switch to the default account is refused while it is turned off.
         this.requireAccount(kind, requested);
-        const spoke = session.info.agentSessionId !== null || session.info.usage.turns > 0;
-
-        if (spoke && !this.canContinue(kind, from, to)) {
+        if (holdsConversation(session.info) && !this.canContinue(kind, from, to)) {
             const label = this.accountLabel(kind, to);
 
             throw new AccountError(

package/src/client-sinks.ts

@@ -39,3 +39,32 @@ export class ClientSinks<TEvent> {
         return [...this.sinks.keys()];
     }
 }
+
+/* The clients of a part that hear its events only after they asked for them with `<area>.watch`. */
+export class WatchedSinks<TEvent> {
+    private readonly sinks = new ClientSinks<TEvent>();
+    private readonly watching = new Set<string>();
+
+    subscribe(clientId: string, sink: (event: TEvent) => void): () => void {
+        const unsubscribe = this.sinks.subscribe(clientId, sink);
+
+        return () => {
+            this.watching.delete(clientId);
+            unsubscribe();
+        };
+    }
+
+    watch(clientId: string): void {
+        this.watching.add(clientId);
+    }
+
+    unwatch(clientId: string): void {
+        this.watching.delete(clientId);
+    }
+
+    emit(event: TEvent): void {
+        for (const clientId of this.watching) {
+            this.sinks.to(clientId, event);
+        }
+    }
+}

package/src/fs.ts

@@ -1,5 +1,5 @@
 import { renameSync, writeFileSync } from 'node:fs';
-import { open, rename, rm, stat, writeFile } from 'node:fs/promises';
+import { lstat, open, rename, rm, stat, writeFile } from 'node:fs/promises';
 import { dirname } from 'node:path';
 import { wait } from './async.ts';
 
@@ -143,3 +143,14 @@ export async function fileExists(path: string): Promise<boolean> {
         return false;
     }
 }
+
+/* Whether anything is at the path, a link that leads nowhere included, where `fileExists` follows the link. */
+export async function entryExists(path: string): Promise<boolean> {
+    try {
+        await lstat(path);
+
+        return true;
+    } catch {
+        return false;
+    }
+}

package/src/host/index.ts

@@ -4,5 +4,5 @@ export { RUIMTE_SESSION_VARIABLES, cliEnvironment, type CliEnvironmentPolicy } f
 export { type AgentHandler, type AgentHandlers, chatHandlers, accountHandlers, usageHandlers, type AgentRequestMap, type ChatRequestType } from './handlers.ts';
 export { memoryPortPair } from './memory-port.ts';
 export { type AgentWiring, wireAgents, type AgentWiringOptions } from './wiring.ts';
-export { ClientSinks } from '../client-sinks.ts';
+export { ClientSinks, WatchedSinks } from '../client-sinks.ts';
 export type { AgentEvent, AgentEventMap, AgentSink } from '../events.ts';

package/src/index.ts

@@ -1,11 +1,12 @@
 // Public API: exports.test.ts snapshots this list, so a name added or dropped here is an API change.
-export { wait, withTimeout } from './async.ts';
+export { wait, withTimeout, cancellableTimeout, unrefTimeout, type Timer } from './async.ts';
 export { CodedError } from './coded-error.ts';
 export { describeError, setErrorStacks, errorText } from './error-text.ts';
-export { tempNameFor, writeAtomic, replaceSync, writeAtomicSync, isNotFound, fileExists, type WriteAtomicOptions } from './fs.ts';
+export { tempNameFor, writeAtomic, replaceSync, writeAtomicSync, hasErrorCode, isNotFound, fileExists, entryExists, type WriteAtomicOptions } from './fs.ts';
 export { RecordDirectory, type RecordDirectoryOptions } from './record-directory.ts';
 export { runProcess, type ProcessResult, type RunProcessOptions } from './run-process.ts';
 export { Serializer, KeyedSerializer } from './serializer.ts';
+export { SingleFlight } from './single-flight.ts';
 export { cleanTitle, readLines } from './title-file.ts';
 
 export {

package/src/single-flight.ts

@@ -0,0 +1,33 @@
+/*
+ * Work that runs once per key at a time: a caller that asks while it runs shares its outcome, and
+ * a key that settled leaves nothing behind.
+ */
+export class SingleFlight<T> {
+    private readonly flights = new Map<string, Promise<T>>();
+
+    /* The run in flight for `key`, if any. */
+    get(key: string): Promise<T> | undefined {
+        return this.flights.get(key);
+    }
+
+    has(key: string): boolean {
+        return this.flights.has(key);
+    }
+
+    run(key: string, work: () => Promise<T>): Promise<T> {
+        const running = this.flights.get(key);
+
+        if (running !== undefined) {
+            return running;
+        }
+
+        const flight = work().finally(() => {
+            if (this.flights.get(key) === flight) {
+                this.flights.delete(key);
+            }
+        });
+        this.flights.set(key, flight);
+
+        return flight;
+    }
+}