@leuduan/lagent 0.0.0-stage → 0.1.2

package/dist/testing/index.js

@@ -0,0 +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};

package/dist/testing/processes.d.ts

@@ -0,0 +1,13 @@
+import { type ChildProcess } from 'node:child_process';
+/** The URL of a source module, such as `sys/spawn.ts`, for a {@link lagentProcess} script to import. */
+export declare const sourceModule: (path: string) => string;
+/**
+ * Another lagent process, running `script` as an ES module against the TypeScript sources, for
+ * tests of what happens when a process ends — which a test cannot do to its own. Only for tests
+ * run from the sources. The caller kills it.
+ */
+export declare function lagentProcess(script: string): {
+    child: ChildProcess;
+    line: () => Promise<string>;
+    exited: () => Promise<number | null>;
+};

package/dist/testing/sandbox.d.ts

@@ -0,0 +1,71 @@
+import type { Fiber } from '@leuduan/cordis';
+import { type LLMClient } from '../llm/index.js';
+import type { ToolResult } from '../models/index.js';
+import { type SandboxConfigInput } from '../sandbox/index.js';
+import type { Launched, LaunchOptions } from '../services/launches.js';
+import type { SandboxService } from '../sandbox/service.js';
+import { type TestRoot } from './helpers.js';
+/**
+ * A root with the OS sandbox mounted over real sandbox-runtime, for the sandbox's tests. The sandbox
+ * starts once per process, so a test file starts one harness and every test in it shares the service.
+ */
+/** Whether this machine can run the sandbox: macOS with Seatbelt. */
+export declare const sandboxSupported: boolean;
+type RunOptions = {
+    signal?: AbortSignal;
+    workdir?: string;
+    root?: string;
+    /** Keys the launch's scratch directory. */
+    threadId?: string;
+    /** The thread the launch serves, which must exist: its conversation's mode decides it. */
+    subject?: string;
+    beforeRelease?: LaunchOptions['beforeRelease'];
+};
+type RunOutcome = {
+    launched: Launched;
+    output: string;
+    result: Awaited<Launched['spawned']['result']>;
+    report: string | null;
+};
+export type SandboxHarness = {
+    readonly root: TestRoot;
+    /** Canonical, like every path the sandbox judges. */
+    readonly base: string;
+    readonly workspace: string;
+    /** The extra writable root, when the harness was started with one. */
+    readonly extraRoot: string;
+    readonly data: string;
+    readonly tmpRoot: string;
+    readonly config: SandboxConfigInput;
+    readonly fiber: Fiber;
+    readonly service: SandboxService;
+    readonly environment: Record<string, string>;
+    /** Calls a `commands` tool as a thread's model would; needs the harness started with `commands`. */
+    tool(name: string, args: Record<string, unknown>, options?: {
+        threadId?: string;
+        callSeq?: number;
+    }): Promise<ToolResult>;
+    /**
+     * Launches `command` through `ctx.launches` as `commands` does:
+     * resolves once it runs, with output attached, and `done` settles when it has ended.
+     */
+    launch(command: string, options?: RunOptions): Promise<{
+        launched: Launched;
+        done: Promise<RunOutcome>;
+    }>;
+    /** {@link launch}, then waits for the end. */
+    run(command: string, options?: RunOptions): Promise<RunOutcome>;
+    dispose(): Promise<void>;
+};
+export declare function startSandboxHarness(options?: {
+    config?: Partial<SandboxConfigInput>;
+    /** The model the root's threads run on; one with no script unless a test drives turns. */
+    llm?: LLMClient;
+    /** Mount `commands` over it, as a host does. */
+    commands?: boolean;
+    /** Lists `<workspace>/cache` as an extra writable root, created. */
+    extraRoot?: boolean;
+    /** The worker entry; the sources' `worker.ts` unless a test needs another. */
+    worker?: URL;
+}): Promise<SandboxHarness>;
+export {};

package/dist/testing/settlement.d.ts

@@ -0,0 +1,6 @@
+import type { StreamingLLMResponse } from '../llm/index.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.
+ */
+export declare function settlementNeverEarly(stream: StreamingLLMResponse, closing: Promise<unknown>): Promise<void>;

package/dist/testing/tmpDirs.d.ts

@@ -0,0 +1,17 @@
+import type { Context } from '@leuduan/cordis';
+/**
+ * A temporary directory that lives as long as the test that made it, in its body or a
+ * `beforeEach`: removed once that test finishes, after any root made after it is disposed.
+ */
+export declare function tmpWorkspace(prefix?: string): {
+    root: string;
+};
+/** A temporary directory removed when `ctx` is disposed. */
+export declare function ownedTmpDir(ctx: Context, prefix?: string): string;
+/**
+ * Removes every temporary directory made by `tmpWorkspace` or `ownedTmpDir` that nothing cleaned
+ * up, such as the data directory of a root a test never disposed. The vitest setup file calls it
+ * after each test file, so no directory outlives the file that made it. Kept apart from the
+ * helpers so that setup file imports nothing else.
+ */
+export declare function removeLeftoverTmpDirs(): void;

package/dist/util/async.d.ts

@@ -0,0 +1,8 @@
+/**
+ * `task`, or the signal's reason once it aborts: stops waiting, not the work, which keeps running.
+ * A signal aborted already rejects at once, even when `task` has settled: the abort is raced first.
+ * `task` is always observed, so its later failure is never an unhandled rejection.
+ */
+export declare function abortable<T>(task: Promise<T>, signal: AbortSignal): Promise<T>;
+/** The longest delay a Node timer honours; a longer one fires at once. The bound of every timer setting. */
+export declare const MAX_TIMER_MS: number;

package/dist/util/diff.d.ts

@@ -0,0 +1,25 @@
+/**
+ * A line diff between two texts, as unified diff text.
+ *
+ * Myers' algorithm over the lines left once the common head and tail are set aside, which is all
+ * that differs when an edit changed a few places. Its search is bounded: past
+ * {@link MAX_EDIT_DISTANCE} differing lines, or work proportional to it, the middle is given as
+ * removed and added whole, which is still a correct diff, only not the shortest.
+ */
+export type UnifiedDiff = {
+    /** The diff, with `---`/`+++` headers; empty when the texts have the same lines. */
+    readonly text: string;
+    readonly added: number;
+    readonly removed: number;
+};
+/**
+ * The unified diff from `before` to `after`, with `context` lines around each change. Lines split
+ * on `\n`, a carriage return right before it dropped, and a last line without a newline is marked
+ * as git marks it.
+ */
+export declare function unifiedDiff(before: string, after: string, labels: {
+    readonly from: string;
+    readonly to: string;
+}, context?: number): UnifiedDiff;
+/** How many lines a text has: a last line without a newline counts. */
+export declare function lineCount(text: string): number;

package/dist/util/dispatch.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Calls every listener with `event`, synchronously and in order, and never awaits one. A throw, or
+ * the rejection of anything a listener returns with a `then`, is reported, and the other listeners
+ * still run. A returned thenable is adopted, so its `then` is called once. The one rule for "a
+ * listener failed"; the caller owns the event, freezing it when the listeners must not change what
+ * the others see.
+ */
+export declare function dispatch<T>(listeners: Iterable<(event: T) => unknown>, event: T, report: (error: unknown) => void): void;

package/dist/util/errors.d.ts

@@ -0,0 +1,28 @@
+import { z } from 'zod';
+export declare const formatError: (error: unknown) => string;
+/**
+ * `formatError` followed by the `cause` chain. A transport failure's own message says nothing (the
+ * OpenAI SDK's is just `Connection error.`); what actually broke is in its causes.
+ */
+export declare function formatErrorWithCauses(error: unknown): string;
+/** The Node system-error code of `error`, such as `ENOENT`, when it has one. */
+export declare const errnoCode: (error: unknown) => string | undefined;
+/** Whether `error` is a Node system error with one of `codes`. */
+export declare const hasErrnoCode: (error: unknown, ...codes: string[]) => boolean;
+/** A zod failure as one line per bad field, in the form the calling model is told about. */
+export declare function formatValidationError(error: z.ZodError): string;
+/** What a failure says in the journal: a validation error as its fields, anything else with its causes. */
+export declare const failureText: (error: unknown) => string;
+/**
+ * Whether `error` is how work stops on `signal`: its reason, or one wrapping it as Node's abortable
+ * APIs do (`cause`), possibly again (`Promise.any` over them), a few levels down. A failure that only
+ * coincided with the abort is not.
+ */
+export declare function stoppedOn(signal: AbortSignal, error: unknown, depth?: number): boolean;
+/**
+ * Whether `error` is the cancellation of work on `signal`, not a failure that coincided with it: its
+ * reason (see {@link stoppedOn}), or the `AbortError` a platform transport (`fetch`, a stream) throws
+ * when the signal it was handed fired. Either needs the signal to have fired. An adapter whose SDK
+ * throws an abort error of its own turns it into the signal's reason.
+ */
+export declare function isCancellation(signal: AbortSignal, error: unknown): boolean;

package/dist/util/foldState.d.ts

@@ -0,0 +1,17 @@
+import type { JsonValue, ReadonlyJsonValue } from './json.js';
+/**
+ * A fold's state as a reader sees it: read-only all the way down. Arrays become `readonly`, `Map`
+ * and `Set` their read-only forms, and records map property by property. Fold state is plain data
+ * (primitives, arrays, records, `Map` and `Set`), so a function-typed member becomes `never`: the
+ * state cannot hand a reader a way to change it. A field typed exactly `JsonValue` becomes
+ * {@link ReadonlyJsonValue}, as in `DeepReadonly`, since mapping the recursive alias does not
+ * terminate. This is cooperative authoring, not a sandbox: reducers keep the mutable state and
+ * nothing is copied or frozen on read, so a cast, or a narrowing TypeScript widens, can still reach
+ * the mutable value. `Array.isArray` is the known one: it narrows a read-only array to `any[]`, so
+ * `push` on a JSON array payload compiles. The type does not exclude every cast-free mutation.
+ */
+export type ReadonlyState<S> = [S] extends [JsonValue] ? [JsonValue] extends [S] ? ReadonlyJsonValue : ReadonlyStateOf<S> : [S] extends [ReadonlyJsonValue] ? [ReadonlyJsonValue] extends [S] ? S : ReadonlyStateOf<S> : ReadonlyStateOf<S>;
+type ReadonlyStateOf<S> = S extends (...args: never[]) => unknown ? never : S extends ReadonlyMap<infer K, infer V> ? ReadonlyMap<ReadonlyState<K>, ReadonlyState<V>> : S extends ReadonlySet<infer T> ? ReadonlySet<ReadonlyState<T>> : S extends object ? {
+    readonly [K in keyof S]: ReadonlyState<S[K]>;
+} : S;
+export {};

package/dist/util/freeze.d.ts

@@ -0,0 +1,2 @@
+/** Recursively freezes a tree of data values. Call on an owned copy, never a live service. */
+export declare function freezeData<T>(value: T): T;

package/dist/util/ids.d.ts

@@ -0,0 +1,2 @@
+/** A prefixed unique id, for things a reader has to tell apart at a glance in a journal. */
+export declare const nextId: (prefix: string) => string;

package/dist/util/json.d.ts

@@ -0,0 +1,37 @@
+import { z } from 'zod';
+/**
+ * Recursively drops `null` object values, so a field left unset and one set to null compare equal.
+ *
+ * This is for comparing, not for storing: the session journal writes events as they stand, because
+ * a row that read back differently from the event in memory made a live session and a resumed one
+ * disagree about their own history.
+ */
+export declare function stripNone<T>(value: T): T;
+/**
+ * JSON with object keys sorted at every level, so equal values produce equal strings. Like
+ * `JSON.stringify`, it leaves out properties whose value is `undefined`, so a value compares equal
+ * to itself read back from storage.
+ */
+export declare function stableStringify(value: unknown): string;
+export declare const JsonValueSchema: z.ZodJSONSchema;
+export type JsonValue = z.infer<typeof JsonValueSchema>;
+/** A {@link JsonValue} no reader may change: what a frozen fact holds. */
+export type ReadonlyJsonValue = string | number | boolean | null | readonly ReadonlyJsonValue[] | {
+    readonly [key: string]: ReadonlyJsonValue;
+};
+/**
+ * `T` with every property and array readonly, all the way down: the type of a frozen fact. A field
+ * typed exactly `JsonValue` or `ReadonlyJsonValue` becomes {@link ReadonlyJsonValue}, since mapping
+ * the recursive alias itself does not terminate; so a type that is already deeply readonly maps to
+ * itself.
+ */
+export type DeepReadonly<T> = [T] extends [ReadonlyJsonValue] ? [ReadonlyJsonValue] extends [T] ? ReadonlyJsonValue : [JsonValue] extends [T] ? ReadonlyJsonValue : DeepReadonlyObject<T> : DeepReadonlyObject<T>;
+type DeepReadonlyObject<T> = T extends object ? {
+    readonly [K in keyof T]: DeepReadonly<T[K]>;
+} : T;
+/**
+ * A mutable copy of a read-only JSON value: for a payload read from a fold that a row or a public
+ * result is made of, which must not share what the fold holds.
+ */
+export declare function copyJson(value: ReadonlyJsonValue): JsonValue;
+export {};

package/dist/util/log.d.ts

@@ -0,0 +1,6 @@
+/** Minimal logger: warnings and errors go to stderr, debug output only with LAGENT_DEBUG set. */
+export declare const log: {
+    debug(message: string, ...args: unknown[]): void;
+    warn(message: string, ...args: unknown[]): void;
+    error(message: string, ...args: unknown[]): void;
+};

package/dist/util/text.d.ts

@@ -0,0 +1,21 @@
+export type RenderTagOptions = {
+    attrs?: Record<string, string>;
+    namespace?: string;
+};
+/** The XML-ish block format prompts and tool results are written in. */
+export declare function renderTag(name: string, content: string, options?: RenderTagOptions): string;
+/**
+ * Text that a section's author did not write, with every opening and closing tag of the named
+ * sections defused, `<name` into `<\name` and `</name` into `<\/name`, so it can neither end one of
+ * them early nor open a second. Matching ignores case and the space after `<` or `</`, as a lenient
+ * reader would; a tag of any other name is left alone.
+ */
+export declare function neutralizeTags(text: string, names: readonly string[]): string;
+/**
+ * `index` moved off the middle of a surrogate pair, so a slice never holds half of one: the end of a
+ * slice goes back to before the pair, the start of one forward past it. Any other index is returned
+ * as it is; the caller keeps its own policy for where it cuts.
+ */
+export declare function cutAt(text: string, index: number, edge: 'start' | 'end'): number;
+/** Code-unit order, not locale order, so listings are stable across machines. */
+export declare const sortStrings: (values: Iterable<string>) => string[];

package/dist/util/version.d.ts

@@ -0,0 +1,2 @@
+/** The package version, for client/server identification strings. */
+export declare function lagentVersion(): string;

package/package.json

@@ -1,6 +1,178 @@
 {
   "name": "@leuduan/lagent",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.1.2",
+  "description": "Plugin-based agent execution engine built on @leuduan/cordis",
+  "license": "SEE LICENSE IN LICENSE",
+  "author": "Duan Leu",
+  "files": [
+    "dist",
+    "!dist/**/*.map"
+  ],
+  "type": "module",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./models": {
+      "types": "./dist/models/door.d.ts",
+      "import": "./dist/models/door.js"
+    },
+    "./llm": {
+      "types": "./dist/llm/door.d.ts",
+      "import": "./dist/llm/door.js"
+    },
+    "./providers": {
+      "types": "./dist/plugins/providers/door.d.ts",
+      "import": "./dist/plugins/providers/door.js"
+    },
+    "./sqlite": {
+      "types": "./dist/plugins/store/sqlite.d.ts",
+      "import": "./dist/plugins/store/sqlite.js"
+    },
+    "./durable-object": {
+      "types": "./dist/plugins/store/durableObject.d.ts",
+      "import": "./dist/plugins/store/durableObject.js"
+    },
+    "./sandbox": {
+      "types": "./dist/sandbox/index.d.ts",
+      "import": "./dist/sandbox/index.js"
+    },
+    "./plugin": {
+      "types": "./dist/plugin.d.ts",
+      "import": "./dist/plugin.js"
+    },
+    "./testing": {
+      "types": "./dist/testing/index.d.ts",
+      "import": "./dist/testing/index.js"
+    },
+    "./plugins/agentsMd": {
+      "types": "./dist/plugins/agentsMd.d.ts",
+      "import": "./dist/plugins/agentsMd.js"
+    },
+    "./plugins/ask": {
+      "types": "./dist/plugins/ask/index.d.ts",
+      "import": "./dist/plugins/ask/index.js"
+    },
+    "./plugins/commands": {
+      "types": "./dist/plugins/commands/index.d.ts",
+      "import": "./dist/plugins/commands/index.js"
+    },
+    "./plugins/compaction": {
+      "types": "./dist/plugins/compaction/index.d.ts",
+      "import": "./dist/plugins/compaction/index.js"
+    },
+    "./plugins/dateAndBranch": {
+      "types": "./dist/plugins/dateAndBranch.d.ts",
+      "import": "./dist/plugins/dateAndBranch.js"
+    },
+    "./plugins/delegations": {
+      "types": "./dist/plugins/delegations/index.d.ts",
+      "import": "./dist/plugins/delegations/index.js"
+    },
+    "./plugins/diagnostics": {
+      "types": "./dist/plugins/diagnostics/index.d.ts",
+      "import": "./dist/plugins/diagnostics/index.js"
+    },
+    "./plugins/historyRecall": {
+      "types": "./dist/plugins/historyRecall/index.d.ts",
+      "import": "./dist/plugins/historyRecall/index.js"
+    },
+    "./plugins/mcp": {
+      "types": "./dist/plugins/mcp/index.d.ts",
+      "import": "./dist/plugins/mcp/index.js"
+    },
+    "./plugins/routeContext": {
+      "types": "./dist/plugins/routeContext.d.ts",
+      "import": "./dist/plugins/routeContext.js"
+    },
+    "./plugins/schedules": {
+      "types": "./dist/plugins/schedules/index.d.ts",
+      "import": "./dist/plugins/schedules/index.js"
+    },
+    "./plugins/skills": {
+      "types": "./dist/plugins/skills/index.d.ts",
+      "import": "./dist/plugins/skills/index.js"
+    },
+    "./plugins/subAgents": {
+      "types": "./dist/plugins/subAgents/index.d.ts",
+      "import": "./dist/plugins/subAgents/index.js"
+    },
+    "./plugins/tools": {
+      "types": "./dist/plugins/tools/index.d.ts",
+      "import": "./dist/plugins/tools/index.js"
+    },
+    "./plugins/toolPolicy": {
+      "types": "./dist/plugins/toolPolicy/index.d.ts",
+      "import": "./dist/plugins/toolPolicy/index.js"
+    },
+    "./plugins/truncateToolOutput": {
+      "types": "./dist/plugins/truncateToolOutput.d.ts",
+      "import": "./dist/plugins/truncateToolOutput.js"
+    },
+    "./plugins/usage": {
+      "types": "./dist/plugins/usage/index.d.ts",
+      "import": "./dist/plugins/usage/index.js"
+    },
+    "./plugins/verify": {
+      "types": "./dist/plugins/verify/index.d.ts",
+      "import": "./dist/plugins/verify/index.js"
+    },
+    "./plugins/workflows": {
+      "types": "./dist/plugins/workflows/index.d.ts",
+      "import": "./dist/plugins/workflows/index.js"
+    },
+    "./plugins/workspaceContext": {
+      "types": "./dist/plugins/workspaceContext.d.ts",
+      "import": "./dist/plugins/workspaceContext.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "1.30.0",
+    "openai": "7.10.0",
+    "yaml": "2.9.0",
+    "zod": "4.5.4",
+    "@leuduan/cordis": "1.0.3"
+  },
+  "peerDependencies": {
+    "@anthropic-ai/sandbox-runtime": "0.0.79",
+    "vitest": "4.1.5"
+  },
+  "peerDependenciesMeta": {
+    "@anthropic-ai/sandbox-runtime": {
+      "optional": true
+    },
+    "vitest": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@anthropic-ai/sandbox-runtime": "0.0.79",
+    "@cloudflare/vitest-plugin": "1.3.6",
+    "@types/node": "22.19.1",
+    "esbuild": "0.28.1",
+    "typescript": "^6.0.3",
+    "vitest": "4.1.5",
+    "@local/tsconfig": "1.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/leuduan/luna.git",
+    "directory": "js/packages/lagent"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=22.13"
+  },
+  "scripts": {
+    "clean": "rm -rf dist tsconfig.tsbuildinfo tsconfig.build.tsbuildinfo",
+    "ts-check": "tsc --noEmit && tsc --noEmit -p tsconfig.workers.json",
+    "build": "tsc --build tsconfig.build.json",
+    "test": "vitest run",
+    "test:workers": "vitest run --config vitest.workers.config.ts"
+  }
 }