@leuduan/lagent 0.0.0-stage → 0.1.2

package/dist/loop/state.d.ts

@@ -0,0 +1,70 @@
+import type { Journal, PluginJournal } from '../journal/index.js';
+import type { ReadonlyState } from '../util/foldState.js';
+import type { InboxTarget, Seq } from '../models/index.js';
+import { type DecisionView } from './decide.js';
+import type { TurnLimits } from './limits.js';
+import type { ConversationMessage } from '../llm/index.js';
+import type { ConfirmationState } from './projections.js';
+import type { ReplacementRefusal, RowRef } from './surface.js';
+import { type ThreadState } from './threadState.js';
+/**
+ * A journal view, usable without constructing an execution runtime or activating plugins.
+ * `sentBack` says a stop check sent back the answer of a turn that opened by answering calls, so
+ * input waiting for a turn joins it batch by batch (`Inbox.peek`).
+ */
+export declare function decisionView(journal: Journal, threadId: string, target: InboxTarget, step: number, turn: number, sentBack?: boolean): DecisionView;
+export declare function hasThreadWork(journal: Journal, threadId: string, limits: TurnLimits): boolean;
+/**
+ * Close a process-interrupted turn from journal state, including when no new execution is needed.
+ * Decided inside the write, so a turn something else closed meanwhile is not closed twice.
+ */
+export declare function closeInterruptedTurn(journal: Journal, threadId: string, limits: TurnLimits): Promise<void>;
+/**
+ * What became of the input id a thread was handed: `unknown` when it never was; `queued` while it
+ * waits, for `target`; `claimed` once a step took it; `discarded` when it left the queue unclaimed,
+ * withdrawn or cleared by a cancel. Each names the row that queued it, and a claim the
+ * `input/message` that took it. A discarded or claimed id stays spent: it is never queued again.
+ */
+export type InputFate = {
+    readonly state: 'unknown';
+} | {
+    readonly state: 'queued';
+    readonly queuedAt: Seq;
+    readonly target: InboxTarget;
+} | {
+    readonly state: 'claimed';
+    readonly queuedAt: Seq;
+    readonly claimedAt: Seq;
+} | {
+    readonly state: 'discarded';
+    readonly queuedAt: Seq;
+};
+/**
+ * The fate of input `id` from a thread's state: the one answer to "what became of input X", read
+ * inside a write or a contributor from the state the journal folds, or through `ThreadView.input`.
+ * A fork's own ids only: its source's are the source's.
+ */
+export declare function inputFate(state: ReadonlyState<Pick<ThreadState, 'inputs' | 'inbox'>>, id: string): InputFate;
+/**
+ * Confirmations on one thread whose call has no result yet and was not rejected: still waiting on the
+ * user, or approved. An approval lasts until the call's result: the call runs at the next turn, and
+ * one that waits or is cut off runs again on the same approval, against whatever tool answers to its
+ * name by then.
+ */
+export declare function unfinishedConfirmations(journal: Pick<PluginJournal, 'state'>, threadId: string): ReadonlyState<ConfirmationState>[];
+/**
+ * The first replacement `threadId`'s surface refused, or `null`: a thread that has one carries
+ * history no execution may continue from, which every entry that executes checks.
+ */
+export declare function refusedReplacement(journal: Pick<Journal, 'state'>, threadId: string): {
+    readonly row: RowRef;
+    readonly refusal: ReplacementRefusal;
+} | null;
+/**
+ * The last thing the model said on a thread, if anything: the message of the last
+ * `assistant/message` row on its lineage that the stream did not cut off. Found through the rows
+ * behind the surface, not by role, so an assistant-role stand-in is never reported as the model's
+ * last word; a reply a replacement took off the surface is still found, through the rows its
+ * stand-in replaced.
+ */
+export declare function lastAssistantMessage(journal: Pick<PluginJournal, 'eventAt' | 'state'>, threadId: string): ReadonlyState<ConversationMessage> | null;

package/dist/loop/strategy.d.ts

@@ -0,0 +1,71 @@
+import type { ExtensionRecord, QueuedInput, ReplacementTrigger } from '../models/index.js';
+import type { JsonValue } from '../util/json.js';
+import type { ModelRoute } from '../llm/index.js';
+import type { AuxiliaryCall, AuxiliaryReply } from './auxiliary.js';
+import type { ReplacementInput } from './replace.js';
+/** What a strategy is told about one request to prepare the surface. */
+export type SurfacePrepareInput = {
+    readonly threadId: string;
+    /** The turn and step it runs in; both `null` for a request between turns. */
+    readonly turn: number | null;
+    readonly step: number | null;
+    /** The route the turn recorded, or for a request between turns, the thread's route. */
+    readonly route: ModelRoute;
+    /**
+     * `pressure` on every due model step, `overflow` inside a step whose request the provider refused
+     * as longer than the window, `request` when a caller asked through `thread.compact()`.
+     */
+    readonly trigger: ReplacementTrigger;
+    /**
+     * Input queued for this step, which the step records after the replacement unless it was
+     * withdrawn meanwhile. Empty on `overflow`, whose input is already recorded, and on `request`.
+     */
+    readonly queued: readonly QueuedInput[];
+    /** On `request`, the options the caller gave, opaque to the engine; otherwise `null`. */
+    readonly options: JsonValue | null;
+    /** The turn's signal, or on `request` the caller's. */
+    readonly signal: AbortSignal;
+};
+/**
+ * How a request to prepare the surface ends, as a strategy decides it: nothing to do, a failure,
+ * or replacements the engine records as one atomic group. A failure may name facts the strategy
+ * wants recorded with it, as `ext` rows on the thread, such as an unusable reply it counts.
+ */
+export type FinalPlan = {
+    readonly kind: 'skip';
+    readonly reason: string;
+} | {
+    readonly kind: 'fail';
+    readonly reason: string;
+    readonly facts?: readonly ExtensionRecord[];
+} | {
+    readonly kind: 'replace';
+    readonly replacements: readonly ReplacementInput[];
+    readonly reason?: string;
+};
+/** What came of the one model call a plan asked for. */
+export type AuxiliaryAnswer = {
+    readonly reply: AuxiliaryReply;
+} | {
+    readonly failure: unknown;
+};
+/**
+ * What a strategy returns for a request: a final plan, or one model call beside the conversation
+ * (`ask`) whose answer `finish` turns into the final plan. At most one call per request. (Not
+ * `then`: a plan with one would be awaited as a promise.)
+ */
+export type SurfacePlan = FinalPlan | {
+    readonly kind: 'ask';
+    readonly call: AuxiliaryCall;
+    finish(answer: AuxiliaryAnswer): FinalPlan | Promise<FinalPlan>;
+};
+/**
+ * A thread's one way to replace part of its surface. It reads what it needs and returns a plan;
+ * the engine makes the model call it asks for, records the replacement or the facts, and derives
+ * how the request ended from what committed. It holds no binding that outlives the request.
+ */
+export interface SurfaceStrategy {
+    /** How a refusal and a report name it, such as `compaction (summarize)`. */
+    readonly name: string;
+    plan(input: SurfacePrepareInput): SurfacePlan | Promise<SurfacePlan>;
+}

package/dist/loop/summary.d.ts

@@ -0,0 +1,3 @@
+import type { Journal, ThreadSummaryCore } from '../journal/index.js';
+import type { TurnLimits } from './limits.js';
+export declare function summarizeThread(journal: Journal, threadId: string, limits: TurnLimits): ThreadSummaryCore;

package/dist/loop/surface.d.ts

@@ -0,0 +1,153 @@
+import type { Journal } from '../journal/index.js';
+import type { Reducer } from './threadState.js';
+import type { ConversationMessage } from '../llm/index.js';
+import type { JournalEvent, ReplacementKind, Seq, SurfaceEventType } from '../models/index.js';
+import type { ReadonlyState } from '../util/foldState.js';
+/** A journal row, named by the thread that owns it. Inherited rows belong to a fork's source lineage. */
+export type RowRef = {
+    readonly threadId: string;
+    readonly seq: Seq;
+};
+/**
+ * One message on the surface, with the row behind it.
+ *
+ * An original message is behind its own `input/message`, `assistant/message` or `tool/result` row;
+ * a stand-in is behind the `surface/replaced` row that put it there, whose `source_seqs` name what
+ * it replaced (see {@link replacedOriginals}). A `ConversationMessage` alone does not say which, nor
+ * whether a host sent it, and the replacement rules need both.
+ */
+export type SurfaceEntry = {
+    readonly row: RowRef;
+    readonly type: SurfaceEventType;
+    /**
+     * An `input/message` in role `developer` with no `source`: the host speaking. No replacement
+     * may touch one, since no plugin could bring it back in its place.
+     */
+    readonly directDeveloperInput: boolean;
+    readonly message: ConversationMessage;
+} | {
+    readonly row: RowRef;
+    readonly type: 'surface/replaced';
+    readonly kind: ReplacementKind;
+    readonly directDeveloperInput: false;
+    readonly message: ConversationMessage;
+};
+/** A surface entry as a plugin reads it from the fold: read-only all the way down, its message included. */
+export type SurfaceEntryView = ReadonlyState<SurfaceEntry>;
+export type SurfaceState = {
+    /** What the model sees, in order. */
+    readonly entries: SurfaceEntry[];
+    /**
+     * `surface/replaced` rows this fold skipped, with why. `replaceSurface` writes none that would be
+     * skipped, so an entry here is a row written past it: a bug or a hand-edited store. The fold
+     * records it rather than throwing, since a throwing core fold would leave every thread unopenable;
+     * such a thread is read and forked before the row, and never executed on (`CorruptHistoryError`).
+     */
+    readonly refused: {
+        readonly row: RowRef;
+        readonly refusal: ReplacementRefusal;
+    }[];
+};
+/**
+ * What the model sees, in journal order, with the row behind each message.
+ *
+ * The system prompt is not here: it is recorded once per thread on `thread/prompt` and sent beside
+ * the conversation. Content that has to come back byte-identical belongs here, as a thread's
+ * opening messages.
+ *
+ * A reply the stream cut off is not here either. It is journaled for the record, but as far as the
+ * conversation is concerned the model has not replied: the thread still owes an answer, recovery
+ * sees work left, and a delegating caller sees nothing to take. One rule, read by all three.
+ *
+ * A `surface/replaced` row is folded by splicing: a `span` puts its stand-in where the run it
+ * replaces was, a `rewrite` puts its stand-in in place of the one message it names. Every row it
+ * meets is judged by {@link judgeReplacement}, live or replayed, and `replaceSurface` judges a group
+ * the same way inside its write, so the engine writes no row that the fold would skip.
+ *
+ * A fork inherits all of it: the conversation is exactly what a fork continues. Inherited entries
+ * are named by their original rows, which belong to the source's lineage.
+ */
+export declare const surface: Reducer<SurfaceState>;
+/**
+ * Judges a group of replacements against `entries`, each against the surface the previous one
+ * left, without changing `entries`: the first refused, with its position, or `null` when the whole
+ * group may land.
+ */
+export declare function judgeGroup(entries: readonly SurfaceEntry[], group: readonly JournalEvent<'surface/replaced'>[]): {
+    readonly index: number;
+    readonly refusal: ReplacementRefusal;
+} | null;
+/**
+ * Whether a row put a message of its own on the surface: an `input/message`, a reply that was not
+ * cut off, or a tool result. The one predicate for it: the surface fold, {@link historyMessage} and
+ * history's numbering all gate on it. A `surface/replaced` row's stand-in is derived and never counts.
+ */
+export declare const isHistoryRow: (event: JournalEvent) => boolean;
+/**
+ * The message a row puts on a conversation, or `null` for a row that puts none there
+ * ({@link isHistoryRow}). The one row-to-message logic: the surface fold builds its entries from it
+ * and recall renders history from it, so the model reads what the model saw.
+ */
+export declare function historyMessage(event: JournalEvent): ConversationMessage | null;
+/** A replacement as the rules judge it: the row's data and the rows it cites. A journal row is one. */
+export type ReplacementCandidate = Pick<JournalEvent<'surface/replaced'>, 'data' | 'source_seqs'>;
+/** Which rule a refused replacement breaks; see {@link judgeReplacement}. */
+export type ReplacementRule = 'empty' | 'not-current' | 'developer-input' | 'newest-message' | 'unbalanced' | 'rewrite-target';
+export type ReplacementRefusal = {
+    readonly accepted: false;
+    readonly rule: ReplacementRule;
+    readonly message: string;
+};
+/**
+ * A judgment of one replacement against a surface. An accepted one says where it lands: the cited
+ * messages are `entries[start]` up to, not including, `entries[start + count]`.
+ */
+export type ReplacementVerdict = {
+    readonly accepted: true;
+    readonly start: number;
+    readonly count: number;
+} | ReplacementRefusal;
+/**
+ * Whether a replacement may land on a surface, as it stands. The one predicate for replacements:
+ * the surface fold runs it on every row it folds, `replaceSurface` on every group it writes, and a
+ * strategy may run it on a plan before it asks for anything.
+ *
+ * - **Not empty**: a `span` names at least one row; a `rewrite` names exactly one.
+ * - **Contiguous and current**: the cited rows are, in order, a contiguous run of the rows behind the
+ *   surface. A message already replaced is not current; its stand-in's row is.
+ * - **No direct developer input** is inside a span or rewritten: the host's instruction stays where
+ *   it was, in order with what surrounds it, with no plugin needed to restore it.
+ * - **A `span` keeps the newest message**, so what the thread owes is unchanged. It is also
+ *   **balanced**: no tool call on one side of either edge with its result on the other, and no tool
+ *   result straight after the stand-in (see {@link isBalancedCut}).
+ * - **A `rewrite` targets** a tool result, a `user`-role input, or a rewrite's stand-in: never an
+ *   assistant message, whose recorded provider state the Responses adapters replay in place of its
+ *   content; never a `developer` message, which speaks as the harness; never a span's stand-in, whose
+ *   text the strategy that wrote it owns. It may name the newest message. Its stand-in takes the role
+ *   and tool call id of what it rewrites, so balance and what is owed hold by identity.
+ *
+ * The roles a `span` stand-in may take are the row schema's to enforce, and are. Changing what this
+ * accepts changes what recorded rows mean on replay, so it bumps the journal format version.
+ */
+export declare function judgeReplacement(entries: readonly SurfaceEntry[], candidate: ReplacementCandidate): ReplacementVerdict;
+/**
+ * Whether the surface can be cut just before `entries[at]` (`at` from 0 to `entries.length`)
+ * without separating a tool call from its result: no tool result after the cut answers a call before
+ * it, and no call before it is still owed one. What a span's edges must be, and what a request built
+ * from a prefix of the surface must end on.
+ *
+ * Results are paired with the latest assistant message that called tools before them, as a
+ * provider pairs them and as `unansweredToolCalls` reads them, never by call id across the surface:
+ * providers reuse call ids from one turn to the next.
+ */
+export declare function isBalancedCut(entries: readonly SurfaceEntryView[], at: number): boolean;
+/**
+ * The original rows behind a row on the surface, in surface order: the row itself when it is an
+ * original, or for a `surface/replaced` row, the originals behind every row it cites, followed down
+ * through chains of spans and rewrites. Where any message came from, for whatever asks: recall's
+ * numbering, a checkpoint's range, the copied input.
+ *
+ * Every row a replacement the engine wrote cites was on the surface when it was written, so the walk
+ * meets only replacements that took effect; one the surface refused is not asked about here.
+ */
+export declare function replacedOriginals(journal: Pick<Journal, 'eventAt'>, row: RowRef): RowRef[];

package/dist/loop/threadState.d.ts

@@ -0,0 +1,72 @@
+import type { CoreFold } from '../journal/index.js';
+import type { JournalEvent } from '../models/index.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.
+ */
+export type Reducer<S> = {
+    init(): S;
+    apply(state: S, event: JournalEvent): S;
+};
+/** Every concern of core's state, by the field it fills in {@link ThreadState}. */
+declare const REDUCERS: {
+    readonly surface: Reducer<import("./surface.js").SurfaceState>;
+    readonly turnBoundary: Reducer<{
+        lastTurn: number;
+        step: number;
+        lastReason: import("../models/index.js").TurnEndReason | null;
+        turnOpen: boolean;
+        concludedTurn: number | null;
+    }>;
+    readonly answerCheck: Reducer<import("./projections.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 threadRoute: Reducer<{
+        provider: string;
+        model: string;
+        thinking_effort: "low" | "high" | "none" | "medium" | "max" | null;
+    } | null>;
+    readonly threadPrompt: Reducer<{
+        kind: "base" | "instruction" | "context";
+        tag: string | null;
+        text: string;
+    }[] | null>;
+    readonly threadTools: Reducer<readonly {
+        input_schema: import("../llm/primitives.js").JsonObject;
+        name: string;
+        description: string;
+    }[] | null>;
+    readonly forkTask: Reducer<{
+        spawnSeq: import("../models/index.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 lastAnswer: Reducer<number | null>;
+    readonly requests: Reducer<import("./requests.js").RequestsState>;
+    readonly chain: Reducer<import("./chain.js").ChainState>;
+};
+type Concern = keyof typeof REDUCERS;
+type StateOf<K extends Concern> = ReturnType<(typeof REDUCERS)[K]['init']>;
+/** A thread's state as core folds it: one field per concern. */
+export type ThreadState = {
+    [K in Concern]: StateOf<K>;
+};
+/**
+ * Core's one fold: a thread's {@link ThreadState}, every concern reduced from the same rows. Fatal,
+ * as all of core's state is, and registered by the journal plugin before the journal opens. Read it
+ * with `journal.state(threadState, threadId).inbox`, and so on; a plugin reads it the same way but
+ * cannot register or make a fold of this kind.
+ */
+export declare const threadState: CoreFold<ThreadState>;
+/**
+ * One field of {@link ThreadState} as a reducer of its own, with the same fork rule, for a replay
+ * that folds only what it reads: `journal.stateAt` to a row, or a walk along a lineage. A reducer,
+ * not a projection, so it can never be registered as a second fold.
+ */
+export declare function subState<K extends Concern>(key: K): Reducer<StateOf<K>>;
+export {};

package/dist/loop/tool.d.ts

@@ -0,0 +1,101 @@
+import type { Context } from '@leuduan/cordis';
+import type { InterruptionPolicy, JsonValue, Seq, ThreadEnvironment, ToolResult } from '../models/index.js';
+import type { ReadonlyJsonValue } from '../util/json.js';
+import type { ModelRoute, ParsedToolCall, ToolSpec } from '../llm/index.js';
+/**
+ * How a tool's calls may overlap. `exclusive` forms a barrier: it starts only once the calls before
+ * it have settled, and nothing starts beside it.
+ */
+export type ToolExecutionMode = 'parallel' | 'exclusive';
+/**
+ * A call that suspends instead of answering now: it waits on a dependency outside this loop, a
+ * delegated thread's answer or a person's reply, which the constraint owner named `owner` alone
+ * interprets and resolves (`OwnerHandle.resolveWait`). Core records the declaration, the
+ * thread is held `wait` without a run slot, and once the owner records a value the call is
+ * dispatched again with `InvocationContext.wait`, where the tool returns its ordinary result from
+ * it. A cancel answers a waiting call instead. `dependency` is a JSON object the owner versions;
+ * `deadlineAt` (epoch milliseconds, or `null`) is the owner's to act on; `reason` says why in words.
+ */
+export type WaitRequest = {
+    readonly kind: 'wait';
+    readonly owner: string;
+    readonly dependency: {
+        readonly [key: string]: JsonValue;
+    };
+    readonly deadlineAt: number | null;
+    readonly reason: string;
+};
+export type ToolOutcome = ToolResult | WaitRequest;
+/** Suspends the call on `owner`'s dependency; see {@link WaitRequest}. */
+export declare const waitFor: (request: Omit<WaitRequest, "kind">) => WaitRequest;
+export declare const isWaitRequest: (outcome: object) => outcome is WaitRequest;
+/** A dispatch of a suspended call whose wait resolved: what it waited on, and the value it resolved with. */
+export type ResolvedWait = {
+    readonly dependency: {
+        readonly [key: string]: ReadonlyJsonValue;
+    };
+    readonly value: {
+        readonly [key: string]: ReadonlyJsonValue;
+    };
+};
+/**
+ * What a tool implements. `defineTool` in `kit/tool.ts` builds one, with validation and timing; this
+ * is the contract underneath it.
+ */
+export interface Tool {
+    readonly name: string;
+    /**
+     * Whether a call may run beside the others of its response. `parallel` for a tool whose calls do
+     * not depend on each other's effects, `exclusive` for one that changes state: an exclusive call
+     * runs alone, after every call before it and before any after it. A barrier within one response's
+     * batch only: it does not isolate threads that share a workspace, nor a process a call left
+     * running. Every tool says which; there is no default.
+     */
+    readonly executionMode: ToolExecutionMode;
+    /**
+     * What a re-dispatch may do with a call of this tool that may have begun when its turn was
+     * interrupted. Every tool says which; there is no default. `rerun` for a tool that is read-only or
+     * idempotent under the call's identity (`InvocationContext.threadId` and `callSeq`); `report` for
+     * anything whose second execution would be a second effect in the world.
+     */
+    readonly onInterrupted: InterruptionPolicy;
+    buildSpec(): ToolSpec;
+    /** Never throws: validation and execution failures become `is_error` results. */
+    invoke(call: ParsedToolCall, context: InvocationContext): Promise<ToolOutcome>;
+}
+/**
+ * What a tool is handed. `ctx` is the live thread context, with its scoped tool layer,
+ * `ctx.threads`, and the services plugins provide, such as `ctx.delegations` and `ctx.ask`.
+ */
+export interface InvocationContext {
+    readonly ctx: Context;
+    /** Aborts when this turn is cancelled or the root closes. */
+    readonly signal: AbortSignal;
+    readonly agentName: string;
+    readonly threadId: string;
+    readonly callId: string;
+    /**
+     * The `tool/call` row this invocation answers. The durable identity of the dispatch: unique in the
+     * journal and kept across a re-dispatch, where a provider's `callId` may be neither.
+     */
+    readonly callSeq: Seq;
+    /**
+     * The `llm/request` row that produced this call: exactly what the model was sent when it asked.
+     * Where a tool that forks this thread cuts, so the fork shares that request's cached prefix.
+     * `null` only for a reply recorded without its request, which the loop never writes.
+     */
+    readonly requestSeq: Seq | null;
+    /** Where this thread's work happens. */
+    readonly environment: ThreadEnvironment;
+    /**
+     * The route of the turn running the call, as its `turn/start` recorded it: the one its result is
+     * sent on next, and the route a new sub-agent the call starts inherits. `ctx.llm.capacity(route)`
+     * says what that result may carry.
+     */
+    readonly route: ModelRoute;
+    /**
+     * `null` on a first dispatch; on a dispatch of a call whose wait resolved, what it waited on and
+     * the value it resolved with, from which the tool returns its result without doing the work again.
+     */
+    readonly wait: ResolvedWait | null;
+}

package/dist/loop/toolCalls.d.ts

@@ -0,0 +1,42 @@
+import type { ExtensionRecord, ThreadEnvironment, ToolResult } from '../models/index.js';
+import type { ModelRoute, ToolCall } from '../llm/index.js';
+import type { LoopRuntime } from './runtime.js';
+export type ExecuteToolCallsOptions = {
+    runtime: LoopRuntime;
+    threadId: string;
+    agentName: string;
+    environment: ThreadEnvironment;
+    /** The turn's route, handed to each call. */
+    route: ModelRoute;
+    turn: number;
+    step: number;
+    calls: readonly ToolCall[];
+    signal: AbortSignal;
+};
+/** An error result for a call. */
+export declare const errorResult: (call: ToolCall, output: string) => ToolResult;
+/**
+ * Runs one step's tool calls.
+ *
+ * Dispatch overlaps inside a bounded pool, but results are appended in **model order**: the journal
+ * is what the next request is built from, so the order calls happen to settle in must not be able
+ * to reorder the conversation. A call that suspends leaves a hole: its group goes on, since its calls
+ * were declared independent, but no later group starts, and its result comes in a later turn, after
+ * its siblings'. Providers pair results by call id, so the conversation stays valid.
+ *
+ * Every result is appended only while its call is still unanswered, checked inside its write: a
+ * cancel answers a suspended call in its own write, perhaps while that call runs again.
+ *
+ * Returns nothing: what happened is in the journal. A call held for the user left a
+ * `confirm/requested`, a call whose tool suspended left a `wait/declared`, a call that ended the turn
+ * left it on its result, and a call that was never answered is simply missing a `tool/result`. The
+ * decider reads all of them from there, so there is no outcome to hand back and no chance of the two
+ * disagreeing.
+ */
+export declare function executeToolCalls(options: ExecuteToolCallsOptions): Promise<void>;
+/**
+ * Declares the `ext` rows of one plugin event state a `lagent/tool/authorize` listener decides
+ * from: one that lands while a call is authorized sends the decision round again, which no other
+ * `ext` row does. `defineExtensionEvent({ policyState: true })` is the way in.
+ */
+export declare function declarePolicyState(record: Pick<ExtensionRecord, 'plugin' | 'instance_id' | 'kind'>): void;

package/dist/loop/wake.d.ts

@@ -0,0 +1,32 @@
+import type { AppendEntry } from '../journal/index.js';
+import type { RunChain } from '../models/index.js';
+import type { PendingRun } from './requests.js';
+import { type RouteAuthority, type RouteStatement } from './route.js';
+/**
+ * How a write asks its thread to run: the cause it records beside what it brings. A person's wake
+ * names no authority: it releases the failure, cancellation and startup holds, and its turns are a
+ * person's. A plugin's names its own: `releases` whether it releases those holds, a person's or a
+ * host's authority, and `chain` how a turn it opens counts. Either may state the route it runs on
+ * (`RouteStatement`).
+ */
+export type Wake = {
+    readonly route?: RouteStatement;
+} & ({
+    readonly releases?: undefined;
+    readonly chain?: undefined;
+} | {
+    readonly releases: boolean;
+    readonly chain: RunChain;
+});
+/**
+ * The rows that record `wake` on a thread whose pending request is `pending`, built inside the
+ * write that brings it, which read `pending` there: a `run/requested` when none is pending, then
+ * the cause, naming the input it brought, if any, and the route it changed the thread to, if it did;
+ * and the run the cause joins or opens. A route statement is checked by `routes`, the thread owner,
+ * which is the one guard on every route-changing write; a refusal throws, refusing the whole write.
+ * A write with no `routes` (a thread's opening group, a plugin's resolution) takes no statement.
+ */
+export declare function causeRows(threadId: string, pending: PendingRun | null, wake: Wake, inputId: string | null, routes?: RouteAuthority): {
+    readonly runId: string;
+    readonly rows: AppendEntry[];
+};

package/dist/models/config/agent.d.ts

@@ -0,0 +1,18 @@
+import { z } from 'zod';
+/**
+ * One agent: its name and the base of its prompt. Registered programmatically with
+ * `ctx.agents.register` (usually through `registerAgent`); the name is how threads
+ * and other agents refer to it.
+ *
+ * Strict: an agent says who it is, and nothing else. What it may call is granted to it by name
+ * (`grantTool`) by the plugins that compose the application; instruction and context sections come
+ * from plugins through `ctx.prompts`; how callers see it, a description and guidance, belongs to the
+ * `subAgents` endpoint that offers it. A plugin that needs per-agent configuration keys it by agent
+ * name in its own config, so a misspelled key is rejected here instead of silently ignored there.
+ */
+export declare const AgentDefinitionSchema: z.ZodObject<{
+    name: z.ZodString;
+    basePrompt: z.ZodDefault<z.ZodString>;
+}, z.core.$strict>;
+export type AgentDefinition = z.infer<typeof AgentDefinitionSchema>;
+export type AgentDefinitionInput = z.input<typeof AgentDefinitionSchema>;

package/dist/models/config/prompt.d.ts

@@ -0,0 +1,18 @@
+import type { PromptBlock } from '../../llm/index.js';
+export type TaggedSection = {
+    tag: string;
+    content: string;
+};
+/**
+ * A prompt as `ctx.prompts` assembles it: the agent's base prompt, then instruction sections, then
+ * context sections, so a section's bucket is what decides its position. The rendered result is
+ * recorded per thread.
+ */
+export type SystemPrompt = {
+    basePrompt: string;
+    instructions: TaggedSection[];
+    contextSections: TaggedSection[];
+};
+/** The prompt as ordered blocks — the one place its order is decided. */
+export declare function systemPromptBlocks(prompt: SystemPrompt): PromptBlock[];
+export declare const renderSystemPrompt: (prompt: SystemPrompt) => string;

package/dist/models/door.d.ts

@@ -0,0 +1,12 @@
+/**
+ * `@leuduan/lagent/models`: the serialized contract, what a reader of the journal or a plugin writing
+ * rows needs. Journal rows, the types a row mentions, the helpers that read and write them and the
+ * JSON types they are written in. The Zod schemas, the tables the types derive from and the
+ * hand-written agent and prompt configuration stay inside (`index.ts`).
+ */
+export { isForkSpawn, isSurfaceEvent, parseJournalEvent, queuedInput, stepContribution } from './wire/journal.js';
+export type { CancelIntent, ConfirmationDescriptor, ExtensionRecord, InboxTarget, InitialInstallation, InputRole, Installation, InstallationLifetime, InterruptionPolicy, JournalEvent, JournalEventData, JournalEventInput, JournalEventType, OriginCause, QueuedInput, ReplacementKind, ReplacementTrigger, RunChain, RunOutcomeKind, RunSettledReason, Seq, StepContribution, StepContributionInput, SurfaceEventType, ThreadEnvironment, ThreadFork, ThreadInput, ThreadOrigin, ThreadSummary, TurnEndReason, TurnRejection, WaitDescriptor, } from './wire/journal.js';
+export { toolResultMessageContent } from './wire/primitives.js';
+export type { ToolResult, ToolResultPayload, ToolResultPayloadInput } from './wire/primitives.js';
+export { toJsonSchema } from './jsonSchema.js';
+export type { DeepReadonly, JsonValue, ReadonlyJsonValue } from '../util/json.js';

package/dist/models/door.js

@@ -0,0 +1 @@
+import{a as e}from"../chunks/UKXMCHHT.js";import{f as o,l as t,m as r,q as n,r as s,s as p}from"../chunks/KESCTXGO.js";import"../chunks/TYTQRLTX.js";import"../chunks/D7E6EWIE.js";export{s as isForkSpawn,p as isSurfaceEvent,n as parseJournalEvent,t as queuedInput,r as stepContribution,e as toJsonSchema,o as toolResultMessageContent};

package/dist/models/index.d.ts

@@ -0,0 +1,7 @@
+/** `wire/` is what gets serialized (snake_case); `config/` is what you write by hand (camelCase). */
+export * from './config/agent.js';
+export * from './config/prompt.js';
+export * from './jsonSchema.js';
+export * from './wire/journal.js';
+export * from './wire/primitives.js';
+export type { DeepReadonly, JsonValue, ReadonlyJsonValue } from '../util/json.js';

package/dist/models/jsonSchema.d.ts

@@ -0,0 +1,7 @@
+import { z } from 'zod';
+/**
+ * JSON Schema for a validation schema, as advertised to the model. Uses the input shape, so
+ * defaulted fields stay optional, and every advertised schema is derived from the one that
+ * actually validates — the two can never drift.
+ */
+export declare function toJsonSchema(schema: z.ZodType): Record<string, unknown>;