@leuduan/lagent 0.1.2 → 44.0.0

package/dist/{loop/threadState.d.ts → state/thread.d.ts}

@@ -1,5 +1,5 @@
 import type { CoreFold } from '../journal/index.js';
-import type { JournalEvent } from '../models/index.js';
+import type { JournalEvent } from '../records/journal.js';
 /**
  * One concern of a thread's state: where it starts, and what a row does to it. `apply` may mutate
  * `state` and return it, or return a fresh value; it never reads another concern.
@@ -14,16 +14,17 @@ declare const REDUCERS: {
     readonly turnBoundary: Reducer<{
         lastTurn: number;
         step: number;
-        lastReason: import("../models/index.js").TurnEndReason | null;
+        lastReason: import("../records/journal.js").TurnEndReason | null;
         turnOpen: boolean;
         concludedTurn: number | null;
     }>;
-    readonly answerCheck: Reducer<import("./projections.js").AnswerCheck>;
+    readonly answerCheck: Reducer<import("./turns.js").AnswerCheck>;
     readonly dispatchedCalls: Reducer<Map<string, number>>;
-    readonly dispatchAttempts: Reducer<Map<string, import("./projections.js").DispatchAttempt>>;
-    readonly waits: Reducer<Map<number, import("./projections.js").WaitEntry>>;
-    readonly confirmations: Reducer<Map<string, import("./projections.js").ConfirmationState>>;
-    readonly threadRecord: Reducer<import("./projections.js").ThreadRecord | null>;
+    readonly dispatchAttempts: Reducer<Map<string, import("./dispatches.js").DispatchAttempt>>;
+    readonly waits: Reducer<Map<number, import("./waits.js").WaitEntry>>;
+    readonly confirmations: Reducer<Map<string, import("./confirmations.js").ConfirmationState>>;
+    readonly executions: Reducer<Map<number, import("./confirmations.js").RuntimeExecution>>;
+    readonly threadRecord: Reducer<import("./birth.js").ThreadRecord | null>;
     readonly threadRoute: Reducer<{
         provider: string;
         model: string;
@@ -40,12 +41,12 @@ declare const REDUCERS: {
         description: string;
     }[] | null>;
     readonly forkTask: Reducer<{
-        spawnSeq: import("../models/index.js").Seq | null;
+        spawnSeq: import("../records/journal.js").Seq | null;
         unclaimed: boolean;
     }>;
-    readonly inbox: Reducer<import("./projections.js").InboxState>;
-    readonly inputs: Reducer<Map<string, import("./projections.js").InputRows>>;
-    readonly installations: Reducer<import("./projections.js").InstallationsState>;
+    readonly inbox: Reducer<import("./inputs.js").InboxState>;
+    readonly inputs: Reducer<Map<string, import("./inputs.js").InputRows>>;
+    readonly installations: Reducer<import("./installations.js").InstallationsState>;
     readonly lastAnswer: Reducer<number | null>;
     readonly requests: Reducer<import("./requests.js").RequestsState>;
     readonly chain: Reducer<import("./chain.js").ChainState>;

package/dist/state/turns.d.ts

@@ -0,0 +1,87 @@
+import type { Seq, TurnEndReason } from '../records/journal.js';
+import { type ResponseFinish } from '../llm/primitives.js';
+import type { Journal } from '../journal/index.js';
+import type { Reducer } from './thread.js';
+/**
+ * Where a thread is in its turns: the highest one opened, how many steps it has taken, how it ended,
+ * and whether a tool asked it to stop.
+ *
+ * `step` counts `step/start` since the last `turn/start`, so it is only meaningful while that turn
+ * is in flight — a finished turn's count says nothing about the next one. It is folded rather than
+ * counted in memory so the loop's decision stays a function of the journal across a restart.
+ * `turnOpen` holds while a turn is in flight — including one whose process died, which the thread
+ * closes as `interrupted` before it opens another.
+ *
+ * A fork continues the turn numbering and inherits `concludedTurn`, so a fork taken after a
+ * concluding result is not owed a reply either. Everything else here describes the source's
+ * execution and resets: a fork has no turn in flight and no outcome of its own, even when it was cut
+ * inside one of its source's turns.
+ */
+export declare const turnBoundary: Reducer<{
+    lastTurn: number;
+    step: number;
+    /** How this thread's own last turn ended; `null` before its first ends, or while one is open. */
+    lastReason: TurnEndReason | null;
+    turnOpen: boolean;
+    /**
+     * The turn in which a tool result asked for the turn to end, until input arrives. Holds across
+     * the turn boundary: the concluding result is not a reply the model owes, so nothing happens until
+     * someone sends something new — but only the turn it landed in is cut short by it.
+     */
+    concludedTurn: number | null;
+}>;
+/** Whether a thread's latest answer has been judged by its stop checks. */
+export type AnswerCheck = {
+    status: 'none';
+} | ({
+    status: 'pending' | 'accepted' | 'rejected';
+    seq: Seq;
+    text: string;
+} & ({
+    kind: 'reply';
+    finish: ResponseFinish;
+} | {
+    kind: 'concluded';
+}));
+/**
+ * The conversation's latest answer — a reply with no tool calls, or a result that concluded the
+ * turn — and whether a stop check has judged it.
+ *
+ * An answer is `pending` from the moment it is recorded until its turn ends `completed` (accepted)
+ * or `rejected`. Every other ending leaves it pending, so a check a crash, an abort or a failing
+ * listener cut short is still owed; new input supersedes the answer altogether. Folded from rows
+ * the loop writes anyway, so there is no marker for a crash to fall in front of.
+ *
+ * A fork resets it (see `threadState`'s fork table); a fork is never cut where a check is still owed,
+ * so nothing is lost.
+ */
+export declare const answerCheck: Reducer<AnswerCheck>;
+/**
+ * How the run that began after a row ended, and what it answered, read from the thread's events
+ * after that row. A run's outcome, not a delegation task's: an `aborted` turn ends a run, while a
+ * task stays open across it (the delegations plugin's own fold).
+ */
+export type RunOutcome = {
+    /** The last turn ending seen for this run, if any. */
+    reason: TurnEndReason | null;
+    /**
+     * The accepted answer: the reply, or the output of the tool result that concluded the turn. Empty
+     * until the run has answered — a provisional or rejected answer is not one.
+     */
+    output: string;
+    /** Whether the conversation has reached an answer: a complete reply, or a result that concluded the turn. */
+    answered: boolean;
+};
+/**
+ * How the run that began after `fromSeq` ended, and what it answered.
+ *
+ * The `answerCheck` reducer folded over the rows after `fromSeq`: the same rule the loop and its stop
+ * checks read, so an answer is a complete reply with nothing left to call, or a tool result that
+ * concluded the turn, and it becomes the run's answer only at the `turn/end(completed)` that
+ * accepted it. A process that died before that ending leaves it unaccepted, and the scan goes on to
+ * the turn that checks it. Scanning stops at the first turn ending that settles the run, answered or
+ * failed outright, so a later turn of the same thread is never mistaken for this run's.
+ */
+export declare function outcomeSince(journal: Journal, threadId: string, fromSeq: Seq): RunOutcome;
+/** A turn ending after which the run will not produce an answer without new input. */
+export declare const isRunFailure: (reason: TurnEndReason | null) => boolean;

package/dist/state/waits.d.ts

@@ -0,0 +1,38 @@
+import type { Seq } from '../records/journal.js';
+import type { ReadonlyJsonValue } from '../util/json.js';
+import type { Reducer } from './thread.js';
+/** A call's `wait/declared` row, as the waits fold keeps it. */
+export type WaitDeclaration = {
+    /** The `wait/declared` row. */
+    readonly seq: Seq;
+    readonly turn: number;
+    readonly step: number;
+    readonly call_id: string;
+    readonly call_seq: Seq;
+    readonly owner: string;
+    readonly dependency: {
+        readonly [key: string]: ReadonlyJsonValue;
+    };
+    readonly deadline_at: number | null;
+    readonly reason: string;
+};
+/** One declared wait: its declaration, the value it resolved with, and whether its call was answered. */
+export type WaitEntry = {
+    readonly declaration: WaitDeclaration;
+    value: {
+        readonly [key: string]: ReadonlyJsonValue;
+    } | null;
+    /** The call's `tool/result` landed: by its dispatch from the value, or by a cancel. */
+    answered: boolean;
+};
+/**
+ * Every wait the thread declared, by `call_seq`, kept after its call is answered, so answer-once can
+ * report a value recorded before. A fork starts with none: it is never cut with a call unanswered.
+ */
+export declare const waits: Reducer<Map<Seq, WaitEntry>>;
+/** Declared, with no value and no answer: what holds the thread, and what its owner still resolves. */
+export declare const isUnresolved: (entry: WaitEntry | undefined) => boolean;
+/** Declared and unanswered, resolved or not: the waiting call's authority, which a cancel answers. */
+export declare const isSuspended: (entry: WaitEntry | undefined) => boolean;
+/** The thread's suspended waits, in declaration order. */
+export declare const suspendedWaits: (state: ReadonlyMap<Seq, WaitEntry>) => WaitEntry[];

package/dist/{loop → state}/wake.d.ts

@@ -1,5 +1,5 @@
 import type { AppendEntry } from '../journal/index.js';
-import type { RunChain } from '../models/index.js';
+import type { RunChain } from '../records/journal.js';
 import type { PendingRun } from './requests.js';
 import { type RouteAuthority, type RouteStatement } from './route.js';
 /**

package/dist/stores/durableObject.js

@@ -0,0 +1 @@
+import{a as c}from"../chunks/JCTBX33H.js";import{l as i}from"../chunks/BBCW2FZK.js";import"../chunks/MMNNZCBO.js";import"../chunks/G44LG6VL.js";import"../chunks/D4PQP5MA.js";function o(e){return{exec:t=>{e.sql.exec(t).toArray()},run:(t,...r)=>{e.sql.exec(t,...r).toArray()},all:(t,...r)=>e.sql.exec(t,...r).toArray(),transaction:async t=>{let r=e.transactionSync(t);return await e.sync(),r},close:()=>{}}}var n=new WeakMap;function s(e,t){if(n.has(e))throw new i(t);let r={};return n.set(e,r),{identity:t,release:()=>{n.get(e)===r&&n.delete(e)}}}var l=class extends c{storage;identity;constructor(t,r){super(r.identity),this.storage=t,this.identity=r.identity}connect(){return o(this.storage)}async exclusive(){return s(this.storage,this.identity)}};export{l as DurableObjectJournalStore};

package/dist/{plugins/store → stores}/memory.d.ts

@@ -1,5 +1,5 @@
-import type { JournalEvent, Seq, ThreadSummary } from '../../models/index.js';
-import { JournalStore, type AppendOutcome, type Attempt, type ThreadIndexEntry, type WriterLease } from '../../journal/index.js';
+import type { JournalEvent, Seq, ThreadSummary } from '../records/journal.js';
+import { JournalStore, type AppendOutcome, type Attempt, type ThreadIndexEntry, type WriterLease } from '../journal/index.js';
 /**
  * In-memory backing, keeping serialized rows so it exercises the same round trip as SQLite. Its
  * writer lease is exclusive within the process, which is as far as its rows reach.

package/dist/{plugins/store → stores}/sql.d.ts

@@ -1,5 +1,5 @@
-import type { JournalEvent, Seq, ThreadSummary } from '../../models/index.js';
-import { JournalStore, type AppendOutcome, type Attempt, type ThreadIndexEntry, type WriterLease } from '../../journal/index.js';
+import type { JournalEvent, Seq, ThreadSummary } from '../records/journal.js';
+import { JournalStore, type AppendOutcome, type Attempt, type ThreadIndexEntry, type WriterLease } from '../journal/index.js';
 export type SqlValue = string | number | null;
 /** A synchronous SQLite connection: what the two stores differ in, except exclusivity. */
 export type SqlConnection = {

package/dist/stores/sqlite.js

@@ -0,0 +1 @@
+import{a as m}from"../chunks/JCTBX33H.js";import{l as u,m as h}from"../chunks/BBCW2FZK.js";import"../chunks/MMNNZCBO.js";import"../chunks/G44LG6VL.js";import"../chunks/D4PQP5MA.js";import{closeSync as d,mkdirSync as c,openSync as w,realpathSync as f,statSync as p}from"node:fs";import{isAbsolute as M,join as n}from"node:path";import{DatabaseSync as y}from"node:sqlite";var b=class extends m{lockDirectory;busyTimeoutMs;directory;constructor(t,e){super(n(t,"journal.db")),this.directory=t;let{lockDirectory:r,busyTimeoutMs:s}=e;if(!M(r))throw new TypeError(`lockDirectory must be an absolute path: ${r}`);if(!Number.isFinite(s)||s<0)throw new TypeError(`busyTimeoutMs must be a finite number of milliseconds, zero or more: ${s}`);this.lockDirectory=r,this.busyTimeoutMs=s}get databasePath(){return n(this.directory,"journal.db")}connect(){return c(this.directory,{recursive:!0}),new a(this.databasePath,this.busyTimeoutMs)}async exclusive(){c(this.directory,{recursive:!0}),d(w(this.databasePath,"a",384));let t=f(this.databasePath),{dev:e,ino:r}=p(t,{bigint:!0});c(this.lockDirectory,{recursive:!0,mode:448});let s=new y(n(this.lockDirectory,`${e}-${r}.db`));try{s.exec("PRAGMA busy_timeout=0; BEGIN EXCLUSIVE")}catch(i){throw s.close(),l(i)?new u(t):i}return{identity:`sqlite:${e}:${r}`,release:()=>s.close()}}},a=class{db;path;busyTimeoutMs;statements=new Map;writes=Promise.resolve();constructor(t,e){this.path=t,this.busyTimeoutMs=e,this.db=new y(t);try{this.db.exec("PRAGMA journal_mode=WAL")}catch(r){throw this.db.close(),r}}exec(t){this.db.exec(t)}run(t,...e){this.statement(t).run(...e)}all(t,...e){return this.statement(t).all(...e)}transaction(t){let e=()=>this.write(t),r=this.writes.then(e,e);return this.writes=r.catch(()=>{}),r}close(){this.statements.clear(),this.db.close()}statement(t){let e=this.statements.get(t);return e===void 0&&(e=this.db.prepare(t),this.statements.set(t,e)),e}async write(t){await this.beginWrite();try{let e=t();return this.db.exec("COMMIT"),e}catch(e){throw this.rollback(),e}}async beginWrite(){let t=Date.now();for(let e=5;;e=Math.min(e*2,100))try{this.db.exec("BEGIN IMMEDIATE");return}catch(r){if(!l(r))throw r;let s=Date.now()-t;if(s>=this.busyTimeoutMs)throw new h(this.path,s);await new Promise(i=>setTimeout(i,Math.min(e,this.busyTimeoutMs-s)))}}rollback(){if(this.db.isTransaction)try{this.db.exec("ROLLBACK")}catch(t){console.error(t)}}},l=o=>{let t=o?.errcode;return typeof t=="number"&&(t&255)===5};export{b as SqliteJournalStore};

package/dist/sys/environment.d.ts

@@ -22,11 +22,6 @@ export type SpawnEnvironmentPolicy = {
     /** Set over what remains. */
     readonly set: Readonly<Record<string, string>>;
 };
-/**
- * Codex's policy: variables that look like credentials are dropped, the locale is fixed to UTF-8,
- * and the {@link NON_INTERACTIVE_ENVIRONMENT} overrides are set.
- */
-export declare const CODEX_ENVIRONMENT_POLICY: SpawnEnvironmentPolicy;
 /** `source` filtered and overridden by `policy`: the whole environment a spawned process gets. */
 export declare function buildSpawnEnvironment(source: Readonly<Record<string, string | undefined>>, policy: SpawnEnvironmentPolicy): Record<string, string>;
 /**

package/dist/sys/git.d.ts

@@ -31,19 +31,6 @@ export type RepositoryLocation = {
  * repository. `null` outside every repository.
  */
 export declare function findRepository(path: string): RepositoryLocation | null;
-/**
- * Read roots for a thread working in `cwd`: the top of the git repository holding it, when that is
- * above it, so the file tools reach the code around a package and every `AGENTS.md` from the
- * repository root down; none outside a repository, nor at its top. Never more than the repository: a
- * sibling checkout stays out of reach. A host's choice to record when it creates a thread; lagent
- * applies it nowhere itself.
- */
-export declare function repositoryReadRoots(cwd: string): string[];
-/**
- * `path` with its symbolic links resolved, the part that does not exist yet kept as named; the
- * lexical path when it cannot be resolved, such as behind a directory that may not be listed.
- */
-export declare function physical(path: string): string;
 /** What a repository's `HEAD` names: a branch, or a commit it is detached at. */
 export type GitHead = {
     readonly kind: 'branch';

package/dist/sys/paths.d.ts

@@ -1,50 +1,3 @@
-import type { InvocationContext } from '../loop/index.js';
-import type { ThreadEnvironment } from '../models/index.js';
-import type { DeepReadonly } from '../util/json.js';
-/**
- * What a file tool does with a path. `write` is for anything that can modify what the path reaches.
- */
-export type PathAccess = 'read' | 'write';
-/**
- * Where one call of a tool may reach: the thread's workspace and the application's data directory,
- * and for a read also the read roots its environment names.
- *
- * Every comparison is made between real locations: the roots and each path checked against them
- * have their symlinks resolved first, so a link inside a root cannot carry a read or a write
- * outside it. A path that does not exist yet, such as a file about to be created, is located
- * through its nearest existing ancestor, and a dangling link through its target.
- */
-export type PathBoundary = {
-    /** The thread's working directory, which relative paths are resolved against. */
-    readonly cwd: string;
-    /**
-     * `pathValue` resolved against the cwd: the path a tool then opens, without its symlinks
-     * resolved, so results name what the model named. Throws when its real location is outside
-     * every root.
-     */
-    resolve(pathValue: string): string;
-    /** Whether the real location of an absolute path is inside a root: for the entries a walk finds. */
-    contains(path: string): Promise<boolean>;
-    /** `contains` for a caller that cannot await, such as a step listener; tools use `contains`. */
-    containsSync(path: string): boolean;
-};
-/**
- * What a boundary is drawn from: a tool call's context, or the same facts about a thread for a
- * plugin that reads on the thread's behalf, as `agentsMd` does.
- */
-export type BoundaryScope = Pick<InvocationContext, 'ctx'> & {
-    readonly environment: DeepReadonly<ThreadEnvironment>;
-};
-export declare function pathBoundary(context: BoundaryScope, access: PathAccess): PathBoundary;
-/**
- * Where an absolute path really is: its symlinks resolved, for a path that exists. For one that
- * does not, its nearest existing ancestor's real location with the rest appended, following a
- * dangling link to its target, since opening it to write would create that target. What the
- * boundary compares, and what a tool that must tell two names of one file apart compares too.
- */
-export declare function realLocation(path: string): string;
-/** `realLocation` without blocking the event loop, for a walk that checks every entry it finds. */
-export declare function realLocationAsync(path: string): Promise<string>;
 /** Whether `candidate` is `root` or a path inside it, by whole segments: `/a/bc` is not inside `/a/b`. Both normalized. */
 export declare const isWithin: (candidate: string, root: string) => boolean;
 /** A path as results show it: relative to the cwd inside it, absolute outside it. */

package/dist/sys/spawn.d.ts

@@ -16,6 +16,14 @@ import type { Readable, Writable } from 'node:stream';
  */
 /** How long SIGTERM gets before SIGKILL, and SIGKILL before a stop is reported failed. */
 export declare const DEFAULT_KILL_GRACE_MS = 3000;
+/** A command never passed its startup gate; a wrapper group may still need cleanup. */
+export declare class CommandStartFailure extends Error {
+    readonly stopFailed: boolean;
+    readonly code: string | undefined;
+    constructor(cause: unknown, cleanup: {
+        readonly stopFailed: boolean;
+    });
+}
 /**
  * A process's whole environment; an `undefined` value leaves the variable unset. lagent never
  * builds one from its own: a host does (`sys/environment`), and every spawn passes one.
@@ -100,6 +108,8 @@ export interface SpawnedPipes extends SpawnedGroup {
  * Spawns a command in a process group of its own. Resolves once the group is registered,
  * `beforeRelease` has settled and the command released; rejects, having run nothing, when it cannot
  * be spawned or registered, when `beforeRelease` rejects, or when `signal` aborts first.
+ * Each rejection owns a `CommandStartFailure` recording cleanup of its gated wrapper, with the
+ * original failure as its cause.
  */
 export declare function spawnCommand(options: SpawnOptions & {
     stdio?: 'joined';
@@ -117,7 +127,7 @@ export declare function runToCompletion(options: SpawnOptions & {
 }): Promise<SpawnResult & {
     output: string;
 }>;
-/** How {@link runLines} hands a command's stdout over. */
+/** How {@link readLines} hands a command's stdout over. */
 export type LineReader = {
     /**
      * Called with each line of stdout, without its delimiter, as it arrives. Returning `false` stops the
@@ -133,12 +143,12 @@ export type LineReader = {
     maxLineChars: number;
 };
 /**
- * Runs a command and hands its stdout to `onLine` line by line, holding at most one line: for
- * output whose size is not bounded, such as a search's, where the caller stops the command once it
- * has what it needs. The command gets no input. stderr is read separately and kept as a bounded
- * tail, for diagnostics.
+ * Hands a spawned command's stdout to `onLine` line by line, holding at most one line, and waits for
+ * the command to end: for output whose size is not bounded, such as a search's, where the caller
+ * stops the command once it has what it needs. The command gets no input. stderr is read separately
+ * and kept as a bounded tail, for diagnostics.
  */
-export declare function runLines(options: Omit<SpawnOptions, 'stdio' | 'beforeRelease'> & LineReader): Promise<SpawnResult & {
+export declare function readLines(command: SpawnedPipes, reader: LineReader): Promise<SpawnResult & {
     stderr: string;
 }>;
 /** Whether any process remains in the group; a zombie still counts. */

package/dist/testing/clock.d.ts

@@ -1,4 +1,4 @@
-import type { Clock } from '../kit/timers.js';
+import type { Clock } from '../util/timers.js';
 /**
  * A {@link Clock} a test moves by hand. Wall time and elapsed time move apart: `advance` moves
  * both, as time passing does; `jump` sets the wall clock forward or back without any timer

package/dist/testing/fakeLlm.d.ts

@@ -1,6 +1,8 @@
 import type { z } from 'zod';
-import type { ConversationMessage, LLMClient, LLMStreamChunk, MalformedToolCall, ModelRequest, ModelResponse, ResponseFinish, StreamingLLMResponse } from '../llm/index.js';
-import { LLMStreamChunkSchema } from '../llm/index.js';
+import type { ConversationMessage, LLMStreamChunk, MalformedToolCall, ModelResponse, ResponseFinish } from '../llm/primitives.js';
+import type { LLMClient, StreamingLLMResponse } from '../llm/client.js';
+import type { ModelRequest } from '../llm/request.js';
+import { LLMStreamChunkSchema } from '../llm/primitives.js';
 /** A chunk as a test writes one: anything the schema defaults may be left out. */
 export type FakeChunk = z.input<typeof LLMStreamChunkSchema>;
 /** Every request the fake was handed, exactly as the loop built it. */

package/dist/testing/fedLlm.d.ts

@@ -1,4 +1,6 @@
-import type { ConversationMessage, LLMClient, ModelRequest, StreamingLLMResponse } from '../llm/index.js';
+import type { ConversationMessage } from '../llm/primitives.js';
+import type { LLMClient, StreamingLLMResponse } from '../llm/client.js';
+import type { ModelRequest } from '../llm/request.js';
 import { type FakeChunk } from './fakeLlm.js';
 /** One model call whose stream the test feeds: `push` chunks, then `finish` or `fail`. */
 export declare class FedCall {

package/dist/testing/helpers.d.ts

@@ -1,19 +1,27 @@
 import { Context, type Plugin } from '@leuduan/cordis';
 import { Journal, type CoreFold, type JournalStore, type PluginJournal, type Summarizer } from '../journal/index.js';
-import type { ConfirmationState, InvocationContext, RouteStatement, ResolvedWait, RowRef, SendOutcome, Tool, TurnLimits } from '../loop/index.js';
-import type { ConversationMessage, FailureClassification, LLMClient, ModelCapacity, ModelRequest, ModelRoute, PromptBlock, ThinkingEffort } from '../llm/index.js';
+import type { ConfirmationState, RouteStatement, RowRef, SendOutcome, TurnLimits } from '../state/index.js';
+import type { InvocationContext, ResolvedWait, Tool } from '../loop/index.js';
+import type { ConversationMessage, ThinkingEffort } from '../llm/primitives.js';
+import type { FailureClassification } from '../llm/failure.js';
+import type { LLMClient, ModelCapacity } from '../llm/client.js';
+import type { ModelRequest } from '../llm/request.js';
+import type { ModelRoute } from '../llm/provider.js';
+import type { PromptBlock } from '../llm/prompt.js';
 import type { DeepReadonly, ReadonlyJsonValue } from '../util/json.js';
-import type { AgentDefinitionInput, ExtensionRecord, JournalEvent, Seq, ThreadOrigin, ThreadSummary, TurnEndReason } from '../models/index.js';
+import type { AgentDefinitionInput } from '../loop/index.js';
+import type { ExtensionRecord, JournalEvent, Seq, ThreadOrigin, ThreadSummary, TurnEndReason } from '../records/journal.js';
 import { type TrustedPrograms } from '../sys/environment.js';
-import { MemoryJournalStore } from '../plugins/store/memory.js';
+import type { ConfinementService, Launched, LaunchOptions, LaunchRequest } from '../services/confinement/service.js';
+import { MemoryJournalStore } from '../stores/memory.js';
 import { type PromptContribution } from '../services/prompts.js';
 import { type RetryPolicy } from '../services/llm.js';
-import type { Thread } from '../services/thread.js';
-import type { BirthInput, CreateThreadOptions, Opening } from '../services/birth.js';
-import type { InitialInstallationInput } from '../services/presets.js';
-import type { OwnerHandle, StartOptions } from '../services/owner.js';
+import type { Thread } from '../services/threads/index.js';
+import type { BirthInput, CreateThreadOptions, Opening } from '../services/threads/index.js';
+import type { InitialInstallationInput } from '../services/presets/installations.js';
+import type { OwnerHandle, StartOptions } from '../services/threads/index.js';
 import type { DelegationsConfig } from '../plugins/delegations/service.js';
-import type { ThreadView } from '../services/threadView.js';
+import type { ThreadView } from '../services/threads/index.js';
 import { ownedTmpDir, tmpWorkspace } from './tmpDirs.js';
 /**
  * A provider plugin that hands out one fixed client, for tests and embedding. Like the real ones,
@@ -36,7 +44,10 @@ export type TestRootOptions = {
     /** Start from an existing journal, as reopening does. */
     store?: JournalStore;
     cwd?: string;
-    /** Where thread directories live; a temporary directory, removed with the root, when omitted; `null` for none. */
+    /**
+     * Where `threadDirs` keeps thread directories: a temporary directory, removed with the
+     * root, when omitted; `null` mounts no thread directories, as on a host with no file system.
+     */
     dataDir?: string | null;
     limits?: Partial<TurnLimits>;
     /** Agents to register, each granted its `tools`; one `main_agent` that can read files when omitted. */
@@ -122,7 +133,7 @@ export declare function createTestRoot(options: TestRootOptions): Promise<TestRo
 export declare const testEnvironment: () => Record<string, string>;
 /** The trusted programs tests run, found on this process's `PATH`. */
 export declare const testPrograms: () => TrustedPrograms;
-/** Minimal file reader so loop tests can exercise the tool path without the builtin tools. */
+/** Minimal file reader so loop tests can exercise the tool path without the file tools. */
 export declare const testReadFileTool: Tool;
 export type TestToolEntry = {
     name: string;
@@ -217,8 +228,6 @@ export declare function testInvocationContext(root: Context, options?: {
     callId?: string;
     callSeq?: number;
     cwd?: string;
-    /** The thread's read roots; none when omitted. */
-    readRoots?: string[];
     /** The turn's route; the fake provider's when omitted. */
     route?: ModelRoute;
     /** The resolved wait of a dispatch again; none when omitted. */
@@ -342,3 +351,12 @@ export declare function assignmentOrigin(root: Context, callerId: string, owner:
 export declare const testAgentPlugin: (agent: AgentDefinitionInput) => Plugin.Object<undefined>;
 /** Mounts one prompt contribution as a plugin, for tests that need it with a fiber of its own. */
 export declare const testPromptPlugin: (contribution: PromptContribution) => Plugin.Object<undefined>;
+/** One shell launch for `request.threadId` as its own operation: a snapshot, then the launch under it. */
+export declare function launchOnce(service: ConfinementService, { threadId, ...request }: LaunchRequest & {
+    threadId: string;
+    program: {
+        shell: string;
+    };
+}, options: LaunchOptions): Promise<Launched>;
+/** Makes every launch through `confinement` report that its stop could not be confirmed, as a launcher that cannot confirm the group ended. */
+export declare function failStops(confinement: ConfinementService): void;

package/dist/testing/index.js

@@ -1 +1 @@
-import{a as C,c as j,d as m}from"../chunks/2O7ZGEIT.js";import"../chunks/4XVRUSCQ.js";import{a as N}from"../chunks/OVZFGILJ.js";import{c as M,d as D}from"../chunks/UD3VJER6.js";import{b as R,c as B}from"../chunks/SGGMBSBA.js";import"../chunks/3QCW4WDJ.js";import{b as J}from"../chunks/J5S4URAW.js";import{c as F,d as W,f as $}from"../chunks/JPZFKSWT.js";import{b as I}from"../chunks/RK3VP2Q4.js";import{b as A}from"../chunks/74HKUGRR.js";import"../chunks/YIR5MYGU.js";import"../chunks/L3N4FIEN.js";import{a as z}from"../chunks/NAOUTU7A.js";import"../chunks/UKXMCHHT.js";import{a as v}from"../chunks/NDIM7MEW.js";import"../chunks/34KW6VNQ.js";import{a as L}from"../chunks/G6RXC3AL.js";import"../chunks/GQGNVSKB.js";import"../chunks/DXFXAYDN.js";import"../chunks/2OSESBIL.js";import{F as S,S as b,ha as P,o as E}from"../chunks/YLNJXQ3Z.js";import{f as O}from"../chunks/DDANMY45.js";import{w as q}from"../chunks/37YOGDGY.js";import"../chunks/KESCTXGO.js";import"../chunks/TYTQRLTX.js";import{t as T,v as p,w}from"../chunks/D7E6EWIE.js";var u=class{claimed=!1;ledger=new v;failure;chunks;settled;options;constructor(e,r,n={}){this.chunks=e,this.settled=r,this.options=n}[Symbol.asyncIterator](){if(this.claimed)throw new Error("A response is read once: it has been claimed already");this.claimed=!0;let e=this.read();return{next:()=>this.ledger.operation(()=>e.next()),return:r=>this.ledger.operation(()=>e.return(r),!0),throw:r=>this.ledger.operation(()=>e.throw(r),!0)}}async*read(){try{for await(let r of this.chunks)yield T.parse(r);let e=this.options.readFailure===!0?this.settlement():void 0;if(e instanceof Error)throw e}catch(e){throw this.failure={error:e},e}finally{this.ledger.finish()}}settlement(){return typeof this.settled=="function"?this.settled():this.settled}async completed(){if(this.claimed){if(!this.ledger.ended)throw new Error("A response is settled before its read or after it, not while the read is under way")}else for await(let r of this);if(this.failure!==void 0)throw this.failure.error;let e=this.settlement();if(e instanceof Error)throw e;return"finish"in e?e:{message:e,finish:this.options.finish??"completed",provider_metadata:{}}}},g=class t{providerName="fake";requests=[];handler;constructor(e){this.handler=e}static scripted(...e){let r=0;return new t(()=>{let n=e[r];if(n===void 0)throw new Error(`Unexpected LLM call #${r+1}`);return r+=1,n})}async chat(e){if(this.requests.push(e),e.signal?.aborted)throw e.signal.reason instanceof Error?e.signal.reason:new Error("aborted");let r=await this.handler(e.messages,e);return"failure"in r?new u(r.chunks,r.failure):"chunks"in r?new u(r.chunks,r.message):new u([],r)}},ie=(t,e={})=>p({role:"assistant",content:t,...e}),le=(t,e=null)=>p({role:"assistant",content:e,tool_calls:t.map(r=>r.arguments===void 0?{...r,arguments:{}}:r)});var y=class{request;queue=[];ended=null;text="";wake=null;constructor(e){this.request=e,e.signal?.addEventListener("abort",()=>{this.ended??={cutOff:!0},this.wake?.()},{once:!0})}push(e){this.queue.push(e),this.wake?.()}finish(e,r={}){this.ended??={message:p({role:"assistant",content:e,...r})},this.wake?.()}fail(e){this.ended??={error:e},this.wake?.()}stream=new u(this.feed(),()=>this.ended!==null&&"cutOff"in this.ended?{message:p({role:"assistant",content:this.text||null}),finish:"other",provider_metadata:{}}:this.ended!==null&&"message"in this.ended?this.ended.message:new Error("The stream did not finish"));async*feed(){for(;;){let e=this.queue.shift();if(e!==void 0){this.text+=e.text_delta??"",yield e;continue}if(this.ended!==null){if("error"in this.ended)throw this.ended.error;return}await new Promise(r=>this.wake=r),this.wake=null}}},x=class{providerName="fake";calls=[];waiting=[];taken=0;async chat(e){let r=new y(e);return this.calls.push(r),this.waiting.shift()?.(r),r.stream}next(){let e=this.taken++,r=this.calls[e];return r!==void 0?Promise.resolve(r):new Promise(n=>this.waiting.push(n))}};import{randomUUID as _}from"node:crypto";import{readFileSync as me}from"node:fs";import{Context as he,scopeOf as we}from"@leuduan/cordis";import{onTestFinished as ge,vi as tt}from"vitest";import{z as Q}from"zod";import{mkdtempSync as de,rmSync as ce}from"node:fs";import{tmpdir as ue}from"node:os";import{join as pe}from"node:path";import{onTestFinished as fe}from"vitest";var U=new Set;function H(t){let e=de(pe(ue(),t));return U.add(e),e}function V(t){U.delete(t),ce(t,{recursive:!0,force:!0})}function Y(t="lagent-test-"){let e=H(t);return fe(()=>V(e)),{root:e}}function G(t,e="lagent-test-"){let r=H(e);return t.effect(()=>()=>V(r)),r}var Z=(t,e="fake")=>({name:`test:provider:${e}`,inject:["llm"],apply:(r,n)=>C(r,{name:e,defaultModel:"test-model",...n?.thinkingEffort===void 0?{}:{defaultThinkingEffort:n.thinkingEffort},capacity:n?.capacity??(()=>({contextWindow:null,providerTools:!1,toolResultImages:!1})),createClient:()=>t,classify:n?.classify??(()=>({kind:"other"}))},{retry:n?.retry??xe})}),ye=Object.freeze({provider:"fake",model:"test-model",thinking_effort:null}),xe={maxAttempts:1,baseDelayMs:0,maxDelayMs:0},_e=10,K={resume:"all",startLimit:64};function ee(t={}){return{from:"defaults",route:ye,...t}}async function ke(t){let e=new he;return t.disposal!=="manual"&&ge(()=>e.fiber.dispose()),await e.plugin(j,{store:t.store??new m,cwd:t.cwd??process.cwd(),dataDir:t.dataDir===void 0?G(e,"lagent-data-"):t.dataDir,retention:t.retention??"keep",chainLimit:t.chainLimit??_e,...t.limits===void 0?{}:{limits:t.limits}}),await e.plugin(Z(t.llm),{...t.capacity===void 0?{}:{capacity:t.capacity},...t.classify===void 0?{}:{classify:t.classify},...t.retry===void 0?{}:{retry:t.retry}}),await e.plugin(te(t.agents??re())),await e.plugin({name:"test:tools",inject:["tools"],apply(r){for(let{name:n,tool:a}of t.tools??Se())r.effect(()=>r.tools.register(we(r),n,a))}}),e.appended=[],e.journal.subscribe(r=>e.appended.push(r)),e.newThread=({id:r=_(),agent:n="main_agent",...a}={})=>e.threads.create(n,{id:r,...a.birth===void 0?{reuse:"identity",birth:ee()}:{},...a}),t.start!=="defer"&&await e.threads.start(K),e}var Te=()=>{let t=W(process.env,F);for(let e of N)delete t[e];return t},ve=()=>$(process.env.PATH??""),qe=Q.strictObject({path:Q.string()}),Ee=z({name:"read_file",description:"Read a file from the workspace.",parameters:qe,onInterrupted:"rerun",executionMode:"parallel",async execute(t,e){let r=L(e,"read").resolve(t.path);return{output:me(r,"utf8")}}}),Se=()=>[{name:"read_file",tool:Ee}],te=t=>({name:"test:agents",inject:["agents","tools"],apply(e){for(let{tools:r=[],...n}of t){R(e,n);for(let a of r)B(e,a,[n.name])}}}),X=(t={})=>({name:"main_agent",tools:["read_file"],...t}),re=(...t)=>t.length>0?t.map(e=>X(e)):[X()];async function be(t,e={}){let{route:r,signal:n,untilWait:a=!1}=e,l=()=>t.cancel(n===void 0?"Turn cancelled":O(n.reason),{intent:"user"});if(n?.aborted)return await l(),{thread_id:t.id,ended:"cancelled",reason:null,pending_confirmations:null};let s,o=()=>{s=l(),s.catch(()=>{})};n?.addEventListener("abort",o,{once:!0});let d=t.service,h=t.summary.through_seq;try{let f=await t.resume(r===void 0?{}:{route:r});if(s!==void 0)return await s,{thread_id:t.id,ended:"cancelled",reason:null,pending_confirmations:null};let c=await M(d,t.id,f,i=>D(i)&&(a||i.state!=="held"||i.hold.reason!=="wait"));await s;let k=await t.read(i=>i.replay().filter(oe=>oe.seq>h)),se=n?.aborted===!0||c.state==="held"&&c.hold.reason==="shutdown"||c.state==="settled"&&(c.outcome==="cancelled"||c.outcome==="superseded");return{thread_id:t.id,ended:se?"cancelled":k.some(i=>i.type==="turn/start")?"turns":"none",reason:k.some(i=>i.type==="turn/end")?t.lastOutcome():null,pending_confirmations:await t.read(i=>i.pendingConfirmations())}}finally{n?.removeEventListener("abort",o)}}var Oe=(t={})=>({maxOpenTasks:8,clock:J,...t});async function Pe(t,e,r,n,a={}){let l=t,[s]=await P(l,e,{trigger:"request",turn:null,step:null},[{kind:"span",stand_in:{role:a.role??"user",content:n},source:a.source??{plugin:"test:strategy",kind:"checkpoint",version:1,data:null},source_seqs:r.map(o=>o.seq)}]);return l.eventAt(s.seq)}var Re=t=>t===void 0?"":w(t);var Ae=t=>{let e=[...t].reverse().find(r=>r.role==="tool");return e===void 0?null:w(e)},Ce=t=>t.service.view(t.id);function Ie(t=new m,e={}){return new q(t,{summarize:e.summarize??((r,n)=>b(r,n,S())),...e.onListenerError===void 0?{}:{onListenerError:e.onListenerError},coreFolds:e.coreFolds??(e.summarize===void 0?[E]:[])})}async function Le(t){let e=t;return await Promise.all(t.summaries().map(r=>e.load(r.thread_id))),t.summaries().flatMap(r=>t.rows(r.thread_id)).sort((r,n)=>r.seq-n.seq)}async function ne(t){let e=t.isOpen;e||await t.open();try{let r=await t.threads();return(await Promise.all(r.map(({threadId:a})=>t.read(a)))).flat().sort((a,l)=>a.seq-l.seq)}finally{e||await t.close()}}async function ae(t,e,r){let n=await t.acquireWriter();try{for(let a of e)await t.append({id:_(),baseHead:await t.head(),writer:n.acquisitionId,rows:[a]});await t.putSummaries(r,n.acquisitionId)}finally{await n.release()}}async function Me(t){let e=new m;await e.open();let r=t.isOpen;r||await t.open();try{await ae(e,await ne(t),await t.summaries())}finally{r||await t.close()}return e}async function De(t){let e=new m;await e.open(),await ae(e,t,[]);let r=Ie(e);return await r.open(),await r.close(),e}async function je(t,e){let r=await A(t).append("tool/call",{turn:1,step:1,call_id:`call-${_()}`,name:"test_call"},{threadId:e});return{caller_thread_id:e,source_seq:r.seq,cause:{kind:"call"}}}var Ne=t=>({name:`test:prompt:${t.tag}`,inject:["prompts"],apply:e=>I(e,t)});function Fe(t=Date.parse("2026-01-05T09:00:00Z")){let e=t,r=0,n=0,a=new Map,l=(s,o)=>{for(;;){let d;for(let c of a)c[1].due<=s&&(d===void 0||c[1].due<d[1].due)&&(d=c);if(d===void 0)break;let[h,f]=d;o&&(e+=f.due-r),r=f.due,a.delete(h),f.fire()}o&&(e+=s-r),r=s};return{now:()=>e,setTimer(s,o){let d=n++;return a.set(d,{due:r+Math.max(0,s),fire:o}),()=>{a.delete(d)}},advance:s=>l(r+s,!0),jump(s){e+=s},elapse:s=>l(r+s,!1),pending:()=>[...a.values()].map(s=>s.due-r).sort((s,o)=>s-o)}}export{g as FakeLLMClient,x as FedLLM,K as TEST_START,ie as assistant,je as callOrigin,Me as copyStore,ke as createTestRoot,be as drive,Z as fakeProvider,Le as journalRows,Ae as lastToolMessage,Fe as manualClock,Pe as replaceSpan,De as replayStore,ne as storeRows,re as testAgents,te as testAgentsPlugin,ee as testBirth,Oe as testDelegations,Te as testEnvironment,ve as testPrograms,Ne as testPromptPlugin,Re as textOf,Y as tmpWorkspace,Ce as viewOf,le as withToolCalls};
+import{a as B}from"../chunks/W57RW55W.js";import{a as E,b as I,c as N,f as J,h as m}from"../chunks/B4FXK5ER.js";import"../chunks/SS3B5W34.js";import"../chunks/IAAEP6VL.js";import"../chunks/OCBPT7KE.js";import"../chunks/2P47AHNK.js";import"../chunks/MHC6VPB4.js";import"../chunks/EMRB4KCN.js";import"../chunks/RCIHV3KG.js";import"../chunks/2GCIWSOA.js";import{a as z}from"../chunks/GGSVIIWJ.js";import{c as L,d as M}from"../chunks/CANPZYTH.js";import"../chunks/VYMT4TXD.js";import"../chunks/MNJ4SRF7.js";import"../chunks/JFZZXVWD.js";import{c as F,e as W}from"../chunks/N6IXG2VL.js";import"../chunks/6DRCKZ2C.js";import"../chunks/7LI64H5X.js";import"../chunks/3UMZMPWW.js";import{a as A}from"../chunks/Q75FUN7D.js";import"../chunks/PUSUPTAT.js";import"../chunks/34KW6VNQ.js";import"../chunks/KUZCL2SH.js";import"../chunks/CQEVREBT.js";import{b as $}from"../chunks/HK6ZSONF.js";import"../chunks/7VAPNE3L.js";import{b as C}from"../chunks/EPYQ5M3B.js";import{a as b,c as R}from"../chunks/5IRF47YB.js";import"../chunks/OL5A6ITQ.js";import{b as D,e as j}from"../chunks/JFX2MXBA.js";import"../chunks/S34ZA2R6.js";import"../chunks/6FRNHMCV.js";import{b as P}from"../chunks/CUK7CGC7.js";import{H as S,s as q}from"../chunks/BPRCULZH.js";import"../chunks/FJLU4UH3.js";import{f as O}from"../chunks/DDANMY45.js";import{w as v}from"../chunks/BBCW2FZK.js";import"../chunks/MMNNZCBO.js";import"../chunks/G44LG6VL.js";import{o as T,q as p,r as w}from"../chunks/D4PQP5MA.js";var u=class{claimed=!1;ledger=new A;failure;chunks;settled;options;constructor(e,n,r={}){this.chunks=e,this.settled=n,this.options=r}[Symbol.asyncIterator](){if(this.claimed)throw new Error("A response is read once: it has been claimed already");this.claimed=!0;let e=this.read();return{next:()=>this.ledger.operation(()=>e.next()),return:n=>this.ledger.operation(()=>e.return(n),!0),throw:n=>this.ledger.operation(()=>e.throw(n),!0)}}async*read(){try{for await(let n of this.chunks)yield T.parse(n);let e=this.options.readFailure===!0?this.settlement():void 0;if(e instanceof Error)throw e}catch(e){throw this.failure={error:e},e}finally{this.ledger.finish()}}settlement(){return typeof this.settled=="function"?this.settled():this.settled}async completed(){if(this.claimed){if(!this.ledger.ended)throw new Error("A response is settled before its read or after it, not while the read is under way")}else for await(let n of this);if(this.failure!==void 0)throw this.failure.error;let e=this.settlement();if(e instanceof Error)throw e;return"finish"in e?e:{message:e,finish:this.options.finish??"completed",provider_metadata:{}}}},g=class t{providerName="fake";requests=[];handler;constructor(e){this.handler=e}static scripted(...e){let n=0;return new t(()=>{let r=e[n];if(r===void 0)throw new Error(`Unexpected LLM call #${n+1}`);return n+=1,r})}async chat(e){if(this.requests.push(e),e.signal?.aborted)throw e.signal.reason instanceof Error?e.signal.reason:new Error("aborted");let n=await this.handler(e.messages,e);return"failure"in n?new u(n.chunks,n.failure):"chunks"in n?new u(n.chunks,n.message):new u([],n)}},ie=(t,e={})=>p({role:"assistant",content:t,...e}),le=(t,e=null)=>p({role:"assistant",content:e,tool_calls:t.map(n=>n.arguments===void 0?{...n,arguments:{}}:n)});var y=class{request;queue=[];ended=null;text="";wake=null;constructor(e){this.request=e,e.signal?.addEventListener("abort",()=>{this.ended??={cutOff:!0},this.wake?.()},{once:!0})}push(e){this.queue.push(e),this.wake?.()}finish(e,n={}){this.ended??={message:p({role:"assistant",content:e,...n})},this.wake?.()}fail(e){this.ended??={error:e},this.wake?.()}stream=new u(this.feed(),()=>this.ended!==null&&"cutOff"in this.ended?{message:p({role:"assistant",content:this.text||null}),finish:"other",provider_metadata:{}}:this.ended!==null&&"message"in this.ended?this.ended.message:new Error("The stream did not finish"));async*feed(){for(;;){let e=this.queue.shift();if(e!==void 0){this.text+=e.text_delta??"",yield e;continue}if(this.ended!==null){if("error"in this.ended)throw this.ended.error;return}await new Promise(n=>this.wake=n),this.wake=null}}},x=class{providerName="fake";calls=[];waiting=[];taken=0;async chat(e){let n=new y(e);return this.calls.push(n),this.waiting.shift()?.(n),n.stream}next(){let e=this.taken++,n=this.calls[e];return n!==void 0?Promise.resolve(n):new Promise(r=>this.waiting.push(r))}};import{randomUUID as _}from"node:crypto";import{resolve as me}from"node:path";import{Context as he,scopeOf as we}from"@leuduan/cordis";import{onTestFinished as ge,vi as tt}from"vitest";import{z as Q}from"zod";import{mkdtempSync as de,rmSync as ce}from"node:fs";import{tmpdir as ue}from"node:os";import{join as pe}from"node:path";import{onTestFinished as fe}from"vitest";var U=new Set;function H(t){let e=de(pe(ue(),t));return U.add(e),e}function V(t){U.delete(t),ce(t,{recursive:!0,force:!0})}function Y(t="lagent-test-"){let e=H(t);return fe(()=>V(e)),{root:e}}function G(t,e="lagent-test-"){let n=H(e);return t.effect(()=>()=>V(n)),n}var Z=(t,e="fake")=>({name:`test:provider:${e}`,inject:["llm"],apply:(n,r)=>I(n,{name:e,defaultModel:"test-model",...r?.thinkingEffort===void 0?{}:{defaultThinkingEffort:r.thinkingEffort},capacity:r?.capacity??(()=>({contextWindow:null,providerTools:!1,toolResultImages:!1})),createClient:()=>t,classify:r?.classify??(()=>({kind:"other"}))},{retry:r?.retry??xe})}),ye=Object.freeze({provider:"fake",model:"test-model",thinking_effort:null}),xe={maxAttempts:1,baseDelayMs:0,maxDelayMs:0},_e=10,K={resume:"all",startLimit:64};function ee(t={}){return{from:"defaults",route:ye,...t}}async function ke(t){let e=new he;t.disposal!=="manual"&&ge(()=>e.fiber.dispose()),await e.plugin(N,{store:t.store??new m,cwd:t.cwd??process.cwd(),retention:t.retention??"keep",chainLimit:t.chainLimit??_e,...t.limits===void 0?{}:{limits:t.limits}});let n=t.dataDir===void 0?G(e,"lagent-data-"):t.dataDir;return n!==null&&await e.plugin(B,{dataDir:n}),await e.plugin(Z(t.llm),{...t.capacity===void 0?{}:{capacity:t.capacity},...t.classify===void 0?{}:{classify:t.classify},...t.retry===void 0?{}:{retry:t.retry}}),await e.plugin(te(t.agents??ne())),await e.plugin({name:"test:tools",inject:["tools"],apply(r){for(let{name:s,tool:o}of t.tools??Se())r.effect(()=>r.tools.register(we(r),s,o))}}),e.appended=[],e.journal.subscribe(r=>e.appended.push(r)),e.newThread=({id:r=_(),agent:s="main_agent",...o}={})=>e.threads.create(s,{id:r,...o.birth===void 0?{reuse:"identity",birth:ee()}:{},...o}),t.start!=="defer"&&await e.threads.start(K),e}var Te=()=>{let t=F(process.env,J);for(let e of z)delete t[e];return t},ve=()=>W(process.env.PATH??""),qe=Q.strictObject({path:Q.string()}),Ee=D({name:"read_file",description:"Read a file from the workspace.",parameters:qe,onInterrupted:"rerun",executionMode:"parallel",async execute(t,e){let n=await e.operation.files.open(me(e.environment.cwd,t.path));try{return{output:(await n.readAll()).toString("utf8")}}finally{await n.close()}}}),Se=()=>[{name:"read_file",tool:Ee}],te=t=>({name:"test:agents",inject:["agents","tools"],apply(e){for(let{tools:n=[],...r}of t){P(e,r);for(let s of n)j(e,s,[r.name])}}}),X=(t={})=>({name:"main_agent",tools:["read_file"],...t}),ne=(...t)=>t.length>0?t.map(e=>X(e)):[X()];async function be(t,e={}){let{route:n,signal:r,untilWait:s=!1}=e,o=()=>t.cancel(r===void 0?"Turn cancelled":O(r.reason),{intent:"user"});if(r?.aborted)return await o(),{thread_id:t.id,ended:"cancelled",reason:null,pending_confirmations:null};let a,i=()=>{a=o(),a.catch(()=>{})};r?.addEventListener("abort",i,{once:!0});let d=t.service,h=t.summary.through_seq;try{let f=await t.resume(n===void 0?{}:{route:n});if(a!==void 0)return await a,{thread_id:t.id,ended:"cancelled",reason:null,pending_confirmations:null};let c=await L(d,t.id,f,l=>M(l)&&(s||l.state!=="held"||l.hold.reason!=="wait"));await a;let k=await t.read(l=>l.replay().filter(oe=>oe.seq>h)),se=r?.aborted===!0||c.state==="held"&&c.hold.reason==="shutdown"||c.state==="settled"&&(c.outcome==="cancelled"||c.outcome==="superseded");return{thread_id:t.id,ended:se?"cancelled":k.some(l=>l.type==="turn/start")?"turns":"none",reason:k.some(l=>l.type==="turn/end")?t.lastOutcome():null,pending_confirmations:await t.read(l=>l.pendingConfirmations())}}finally{r?.removeEventListener("abort",i)}}var Oe=(t={})=>({maxOpenTasks:8,clock:$,...t});async function Pe(t,e,n,r,s={}){let o=t,[a]=await S(o,e,{trigger:"request",turn:null,step:null},[{kind:"span",stand_in:{role:s.role??"user",content:r},source:s.source??{plugin:"test:strategy",kind:"checkpoint",version:1,data:null},source_seqs:n.map(i=>i.seq)}]);return o.eventAt(a.seq)}var Re=t=>t===void 0?"":w(t);var Ae=t=>{let e=[...t].reverse().find(n=>n.role==="tool");return e===void 0?null:w(e)},Ie=t=>t.service.view(t.id);function Ce(t=new m,e={}){return new v(t,{summarize:e.summarize??((n,r)=>b(n,r,E())),...e.onListenerError===void 0?{}:{onListenerError:e.onListenerError},coreFolds:e.coreFolds??(e.summarize===void 0?[q]:[])})}async function Le(t){let e=t;return await Promise.all(t.summaries().map(n=>e.load(n.thread_id))),t.summaries().flatMap(n=>t.rows(n.thread_id)).sort((n,r)=>n.seq-r.seq)}async function re(t){let e=t.isOpen;e||await t.open();try{let n=await t.threads();return(await Promise.all(n.map(({threadId:s})=>t.read(s)))).flat().sort((s,o)=>s.seq-o.seq)}finally{e||await t.close()}}async function ae(t,e,n){let r=await t.acquireWriter();try{for(let s of e)await t.append({id:_(),baseHead:await t.head(),writer:r.acquisitionId,rows:[s]});await t.putSummaries(n,r.acquisitionId)}finally{await r.release()}}async function Me(t){let e=new m;await e.open();let n=t.isOpen;n||await t.open();try{await ae(e,await re(t),await t.summaries())}finally{n||await t.close()}return e}async function De(t){let e=new m;await e.open(),await ae(e,t,[]);let n=Ce(e);return await n.open(),await n.close(),e}async function je(t,e){let n=await R(t).append("tool/call",{turn:1,step:1,call_id:`call-${_()}`,name:"test_call"},{threadId:e});return{caller_thread_id:e,source_seq:n.seq,cause:{kind:"call"}}}var Ne=t=>({name:`test:prompt:${t.tag}`,inject:["prompts"],apply:e=>C(e,t)});function Fe(t=Date.parse("2026-01-05T09:00:00Z")){let e=t,n=0,r=0,s=new Map,o=(a,i)=>{for(;;){let d;for(let c of s)c[1].due<=a&&(d===void 0||c[1].due<d[1].due)&&(d=c);if(d===void 0)break;let[h,f]=d;i&&(e+=f.due-n),n=f.due,s.delete(h),f.fire()}i&&(e+=a-n),n=a};return{now:()=>e,setTimer(a,i){let d=r++;return s.set(d,{due:n+Math.max(0,a),fire:i}),()=>{s.delete(d)}},advance:a=>o(n+a,!0),jump(a){e+=a},elapse:a=>o(n+a,!1),pending:()=>[...s.values()].map(a=>a.due-n).sort((a,i)=>a-i)}}export{g as FakeLLMClient,x as FedLLM,K as TEST_START,ie as assistant,je as callOrigin,Me as copyStore,ke as createTestRoot,be as drive,Z as fakeProvider,Le as journalRows,Ae as lastToolMessage,Fe as manualClock,Pe as replaceSpan,De as replayStore,re as storeRows,ne as testAgents,te as testAgentsPlugin,ee as testBirth,Oe as testDelegations,Te as testEnvironment,ve as testPrograms,Ne as testPromptPlugin,Re as textOf,Y as tmpWorkspace,Ie as viewOf,le as withToolCalls};

package/dist/testing/settlement.d.ts

@@ -1,4 +1,4 @@
-import type { StreamingLLMResponse } from '../llm/index.js';
+import type { StreamingLLMResponse } from '../llm/client.js';
 /**
  * Asks `stream` to settle at every turn of the microtask queue while `closing` is pending, and fails
  * when one settles with `closing` still pending at the moment it was asked: the read is not over.