@leuduan/lagent 0.1.2 → 44.0.0

package/dist/llm/door.d.ts

@@ -1,21 +0,0 @@
-/**
- * `@leuduan/lagent/llm`: the model and provider contracts as the package offers them, for a provider
- * written outside it and a host that calls a model. Every type the contract mentions, and the values
- * a consumer uses; the schemas and helpers the engine uses itself stay inside (`index.ts`).
- *
- * It depends on `zod` alone, so a provider client built on it works in any harness.
- */
-export { ContextOverflowError, ProviderUnsupportedError, ResponseInterruptedError, ResponseSettlementError, StreamIdleError, } from './client.js';
-export type { LLMClient, ModelCapacity, ModelOption, ResponseSettlementKind, StreamingLLMResponse } from './client.js';
-export { contentText } from './content.js';
-export { ModelCallError } from './failure.js';
-export type { FailureClassification, FailureKind, ModelCallClient, ModelCallHandle } from './failure.js';
-export type { DeepReadonly, ReadonlyJsonValue } from '../util/json.js';
-export type { ContentPart, ContentPartInput, ContentPartKind } from './content.js';
-export { conversationMessage, LLMStreamChunkSchema, messageText, ThinkingEffortSchema } from './primitives.js';
-export type { ConversationMessage, JsonObject, LLMStreamChunk, LLMUsage, MalformedToolCall, MessageRole, ModelResponse, ParsedToolCall, ProviderCall, ProviderState, ResponseFinish, ThinkingEffort, ToolCall, ToolSpec, } from './primitives.js';
-export { renderPromptBlocks } from './prompt.js';
-export type { PromptBlock } from './prompt.js';
-export { defaultRoute } from './provider.js';
-export type { LLMProvider, ModelRoute } from './provider.js';
-export type { ModelRequest, RequestPurpose, ResponseFormat, ToolChoice } from './request.js';

package/dist/llm/door.js

@@ -1 +0,0 @@
-import{b as p,f as d}from"../chunks/TYTQRLTX.js";import{A as l,a as r,b as e,c as o,d as t,e as n,i as m,k as s,t as f,v as a,w as x}from"../chunks/D7E6EWIE.js";export{e as ContextOverflowError,f as LLMStreamChunkSchema,p as ModelCallError,r as ProviderUnsupportedError,n as ResponseInterruptedError,o as ResponseSettlementError,t as StreamIdleError,s as ThinkingEffortSchema,m as contentText,a as conversationMessage,d as defaultRoute,x as messageText,l as renderPromptBlocks};

package/dist/loop/projections.d.ts

@@ -1,307 +0,0 @@
-import type { InboxTarget, InstallationLifetime, InterruptionPolicy, JournalEvent, QueuedInput, Seq, ThreadEnvironment, ThreadFork, ThreadOrigin, TurnEndReason } from '../models/index.js';
-import type { ReadonlyState } from '../util/foldState.js';
-import type { DeepReadonly, JsonValue, ReadonlyJsonValue } from '../util/json.js';
-import type { ConversationMessage, ModelRoute, ParsedToolCall, PromptBlock, ResponseFinish, ToolCall, ToolSpec } from '../llm/index.js';
-import type { Journal } from '../journal/index.js';
-import type { Reducer } from './threadState.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>;
-/**
- * Calls dispatched and not yet answered, and the row that recorded the dispatch.
- *
- * Bookkeeping, not truth: what a turn still owes answers for is {@link unansweredToolCalls}, read
- * off the conversation. This exists so a re-dispatched call can cite its original `tool/call` rather
- * than recording a second one.
- */
-export declare const dispatchedCalls: Reducer<Map<string, Seq>>;
-/** One dispatch attempt of a call: its `tool/authorization` row, and what became of it. */
-export type DispatchAttempt = {
-    /** The `tool/authorization` row: the attempt itself. */
-    seq: Seq;
-    /** The `tool/call` row the attempt dispatched. */
-    call_seq: Seq;
-    turn: number;
-    decision: JournalEvent<'tool/authorization'>['data']['decision'];
-    /** What the tool declared, at this attempt, a re-dispatch may do if the attempt is interrupted. */
-    policy: InterruptionPolicy;
-};
-/**
- * The latest dispatch attempt of every call that has no result yet, by call id.
- *
- * An attempt is written immediately before the tool is invoked, so an allowed attempt with no
- * result, from a turn that has since closed, of a call that did not suspend, is a call the process
- * was cut off in: the tool may have begun. {@link abandonedAttempt} reads that; the policy recorded with the attempt
- * decides what a re-dispatch may do. A new `tool/call` under a reused provider id starts a new call
- * with no attempt; a result clears the call's attempt.
- */
-export declare const dispatchAttempts: Reducer<Map<string, DispatchAttempt>>;
-/**
- * The attempt of `callId` that was abandoned, if any: allowed, so the tool may have begun;
- * unanswered; of the `tool/call` row being dispatched now, not of an earlier call that reused the
- * provider's id; of a call that is not suspended (`waits`), since a waiting call returned on purpose
- * and one whose wait resolved is dispatched again from its recorded value, however often a crash
- * cuts that dispatch off; and from a turn before `currentTurn`, so the process that made it is gone —
- * every earlier turn is closed before a new one opens. Read before a new attempt is recorded, so the
- * judgment is about the attempt that was cut off.
- */
-export declare function abandonedAttempt(state: ReadonlyMap<string, DispatchAttempt>, waits: ReadonlyMap<Seq, WaitEntry>, callId: string, callSeq: Seq, currentTurn: number): DispatchAttempt | undefined;
-/** 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[];
-/**
- * Tool calls on the last assistant message that have no result yet.
- *
- * Derived from the conversation, not from `tool/call` rows, because the conversation is what a
- * provider validates: a message holding calls must be followed by a result for each one. Calls are
- * recorded one row at a time, so a hard kill part-way through that burst leaves a thread with fewer
- * `tool/call` rows than the model asked for — nothing "pending", and a conversation nothing could
- * answer. Reading the assistant message instead makes the two agree by construction.
- */
-export declare function unansweredToolCalls(messages: readonly DeepReadonly<ConversationMessage>[]): DeepReadonly<ToolCall>[];
-export type ConfirmationState = {
-    request_id: string;
-    thread_id: string;
-    /** The `tool/call` row this request was raised for — the dispatch it belongs to. */
-    call_seq: Seq | null;
-    tool_call: ParsedToolCall;
-    reason: string;
-    resolution: {
-        approved: boolean;
-        rejection_message: string | null;
-    } | null;
-};
-/**
- * A thread's confirmation requests and their answers, keyed by request id. Thread-scoped: an answer
- * is written on the thread that asked, so a thread's confirmations are a function of its own rows.
- * A fork starts with none: a fork is never cut with a request still open, and an inherited answer
- * belongs to a call the source already finished.
- */
-export declare const confirmations: Reducer<Map<string, ConfirmationState>>;
-/** Requests still waiting on the user on one thread. */
-export declare const outstandingConfirmations: (state: ReadonlyMap<string, ReadonlyState<ConfirmationState>>, threadId: string) => ReadonlyState<ConfirmationState>[];
-/**
- * Calls one thread must not dispatch now, by call id: those waiting on a user's answer, and those
- * whose wait has not resolved. Neither is turn-bound: dispatching again before the answer or the
- * value would only raise a second request, or declare the wait twice.
- */
-export declare const parkedCallIds: (confirmationState: ReadonlyMap<string, ReadonlyState<ConfirmationState>>, waitState: ReadonlyMap<Seq, WaitEntry>, threadId: string) => Set<string>;
-/**
- * How a dispatch was answered, if it was ever asked about. `undefined` means nobody has been asked —
- * which is what tells a re-dispatched call to go through authorization again rather than assume.
- *
- * Matched on the `tool/call` row rather than the provider's call id: two threads, or two turns of
- * one thread, may legitimately see the same id, and an approval must not carry across.
- */
-export declare const approvalFor: (state: Map<string, ConfirmationState>, dispatch: {
-    threadId: string;
-    callId: string;
-    callSeq: Seq | null;
-}) => {
-    approved: boolean;
-    rejection_message: string | null;
-} | undefined;
-export type ThreadRecord = {
-    thread_id: string;
-    agent_name: string;
-    metadata: JournalEvent<'thread/spawned'>['data']['metadata'];
-    /** The source thread and row this thread was forked at; `null` unless it is a fork. */
-    fork: ThreadFork | null;
-    origin: ThreadOrigin | null;
-    environment: ThreadEnvironment;
-    /** The constraint owners the thread's runs are under. */
-    requires: readonly string[];
-    /** The `thread/spawned` row. */
-    seq: Seq;
-};
-/**
- * A thread's identity, lineage and environment, from its spawn row. A fork's lineage replays its
- * source's spawn row first and its own after it, so the fork's record is its own. The set of all
- * threads is the journal's catalog, not a fold.
- */
-export declare const threadRecord: Reducer<ThreadRecord | null>;
-/** The thread's latest `confirm/resolved` row, or `null`: what tells a parked caller an answer landed under it. */
-export declare const lastAnswer: Reducer<Seq | null>;
-/**
- * The thread's route: the one its spawn row was born with, replaced by each cause that changed it.
- * A lineage fold: a fork, born with none of its own, goes on with the route its inherited rows fold
- * to at the cut, which keeps it on the model whose cache holds its history. Nothing else changes it:
- * not turns, settlements, cancels or compaction. `null` only before a spawn row, which no thread lacks.
- */
-export declare const threadRoute: Reducer<ModelRoute | null>;
-/**
- * The system prompt a thread sends: the latest `thread/prompt` row, or none yet. A fork inherits
- * it and never renders its own, so it sends its source's exact prompt.
- */
-export declare const threadPrompt: Reducer<PromptBlock[] | null>;
-/**
- * The tool specifications a thread's requests send: the latest `thread/tools` row, or none before
- * its first request. Read at a request's seq, what that request sent. A fork inherits it.
- */
-export declare const threadTools: Reducer<readonly ToolSpec[] | null>;
-/**
- * Whether a fork has yet to claim the task it was created with. A fork cut at a request inherits a
- * conversation that ends on input its source is answering. Created to regenerate that answer, the
- * fork owes it; created with a task, it owes only the task. So a task discarded before it was
- * claimed — by `cancel()` — leaves the fork with nothing to do, rather than answering its source's
- * request. Any input the fork records settles it.
- */
-export declare const forkTask: Reducer<{
-    spawnSeq: Seq | null;
-    unclaimed: boolean;
-}>;
-export type InboxState = Record<InboxTarget, QueuedInput[]>;
-/**
- * Input waiting for a turn or a step boundary. Durable, so a crash does not lose a queued message.
- * A fork starts with nothing queued: its source's queued input is not the fork's.
- */
-export declare const inbox: Reducer<InboxState>;
-/** Where one input id's life is recorded: the row that queued it, and the step's row that claimed it. */
-export type InputRows = {
-    readonly queuedAt: Seq;
-    readonly claimedAt: Seq | null;
-};
-/**
- * Every input id this thread was ever handed: the row that queued it and, once a step took it, the
- * `input/message` that claimed it. Never forgets: this is what makes `send` with an explicit id
- * idempotent across a re-dispatch or a restart, and why a withdrawn or cancelled id stays
- * spent. A fork starts over: the ids its source was handed are the source's.
- */
-export declare const inputs: Reducer<Map<string, InputRows>>;
-/**
- * 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;
-/** One installation a thread holds, as its folds read it. */
-export type InstallationRecord = {
-    readonly installationId: string;
-    readonly presetId: string;
-    /** The validated configuration, defaults included: exactly what `setup` receives. */
-    readonly config: JsonValue;
-    /**
-     * `defining` for one recorded as such in its thread's spawn row, on this thread or on the one a
-     * fork inherited it from, which cannot be removed; `configurable` for any other, one applied
-     * later included.
-     */
-    readonly lifetime: InstallationLifetime;
-};
-/** A thread's installations: the current ones in application order, and every id it ever used. */
-export type InstallationsState = {
-    readonly current: Map<string, InstallationRecord>;
-    readonly used: Set<string>;
-};
-/**
- * The preset installations that define a thread's plugins. A fork inherits its source's
- * installations and reserved ids at the cut: its own spawn row carries none, and the source's spawn
- * row, which it folds through lineage, keeps a defining installation defining on every fork.
- * Installations never move, so application order is also the order they are restored in.
- */
-export declare const installations: Reducer<InstallationsState>;

package/dist/loop/state.d.ts

@@ -1,70 +0,0 @@
-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/summary.d.ts

@@ -1,3 +0,0 @@
-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/models/config/agent.d.ts

@@ -1,18 +0,0 @@
-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

@@ -1,18 +0,0 @@
-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.js

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

@@ -1,7 +0,0 @@
-/** `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/plugins/commands/foreground.d.ts

@@ -1,4 +0,0 @@
-import type { Tool } from '../../loop/index.js';
-import { type CommandsConfig } from './service.js';
-/** `run_command`: one shell command, run to completion under `config`. */
-export declare const runCommandTool: (config: CommandsConfig) => Tool;

package/dist/plugins/compaction/preset.d.ts

@@ -1,86 +0,0 @@
-/**
- * The compaction plugin, a `thread` preset with two placements, which keeps a thread's surface
- * within its route's window by the strategy its configuration names. Mounted on the root for an
- * agent selector, `mountPreset(root, compaction, config, { agents })`, it serves every thread whose
- * agent `agents` selects: each matching activation gets its own strategy, provided in the thread's
- * scope, until the mount is disposed. Installed on one thread through the presets service, it
- * serves that thread, recorded so a reopen and a fork keep it.
- *
- * Both strategies act on three triggers: **pressure**, before every model step whose request is
- * estimated above `threshold` of the window (a route whose provider declares no window is never
- * compacted for pressure, which is reported once per route); **overflow**, when the provider
- * refuses a step's request as too long, after which the step is asked again if anything was
- * replaced; and **request**, `thread.compact()`, whatever the pressure.
- *
- * - **`summarize`**, the default. It replaces one span, after the pinned opening and between direct
- *   developer inputs, with one `user` checkpoint: notes a summary call wrote from the surface
- *   through the span, the person's latest input copied from its row when the span held it, and a
- *   footer naming the messages replaced. It measures from the last usage the provider reported on
- *   the same provider and model plus an estimate of what came since, calibrates its estimates by
- *   an overflow, and recovers once per overflow sequence: a new turn or a completed reply allows
- *   another. Three unusable summaries in a row stop pressure compaction until its next
- *   checkpoint or a change of the thread's configuration; the count is recorded, so a reopen and a
- *   fork keep it. On request, `options` may say what the summary should `focus` on.
- * - **`prune`**. It rewrites old tool results in place, keeping each one's role and call id, to a
- *   one-line stand-in, `[tool result pruned: <tool>, <n> characters and <k> attachments; message
- *   <number>]`, the attachments named only when it had some, followed by where to read it back when
- *   the agent has both `historyRecall` tools; no model is called. A result is pruned when it is an
- *   original, never a stand-in, outside the `keepRecent` most recent tool results, and estimated at
- *   `minTokens` or more, images and files included; every such result goes in one atomic group.
- *   Pressure is estimated by characters, uncalibrated. Nothing eligible is `skipped`, reported once
- *   per activation, trigger, route and latest replacement on pressure and overflow. It takes no
- *   request options and ignores any.
- *
- * Plugins whose notices a replacement took away tell them again at the next model step.
- *
- * Disposing a root mount stops new dispatches on the threads it serves, live ones included; a
- * dispatch already in flight finishes, and may still record its replacement. A mount added later
- * reaches activations from then on, not threads already live: they get it at their next activation.
- *
- * A thread runs one strategy, and a second on it, from another mount of this plugin or any other
- * strategy that claims its thread, is refused when the thread activates, naming the one already
- * there. To choose per agent, mount this on the root more than once with disjoint selectors and the
- * strategy each should run; to choose per thread, mount none on the root and install it on each
- * thread instead.
- *
- * ```ts
- * await mountPreset(root, compaction, {}, { agents: ['main'] }) // summarize, with every default
- * await mountPreset(root, compaction, { strategy: { kind: 'prune', keepRecent: 4 } }, { agents: ['worker'] })
- * ```
- */
-export declare const compaction: import("../../services/preset.js").Preset<import("zod").ZodObject<{
-    threshold: import("zod").ZodDefault<import("zod").ZodNumber>;
-    strategy: import("zod").ZodPrefault<import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
-        kind: import("zod").ZodLiteral<"summarize">;
-        target: import("zod").ZodDefault<import("zod").ZodNumber>;
-        tail: import("zod").ZodDefault<import("zod").ZodNumber>;
-        opening: import("zod").ZodDefault<import("zod").ZodNumber>;
-        summaryCap: import("zod").ZodDefault<import("zod").ZodNumber>;
-        summaryFloor: import("zod").ZodDefault<import("zod").ZodNumber>;
-        reasoningAllowance: import("zod").ZodDefault<import("zod").ZodNumber>;
-        replyReserve: import("zod").ZodDefault<import("zod").ZodNumber>;
-        checkpointRatio: import("zod").ZodDefault<import("zod").ZodNumber>;
-        copiedInputChars: import("zod").ZodDefault<import("zod").ZodNumber>;
-        boundaryQuoteChars: import("zod").ZodDefault<import("zod").ZodNumber>;
-        breaker: import("zod").ZodDefault<import("zod").ZodNumber>;
-        withoutWindow: import("zod").ZodDefault<import("zod").ZodObject<{
-            tailTokens: import("zod").ZodDefault<import("zod").ZodNumber>;
-            openingTokens: import("zod").ZodDefault<import("zod").ZodNumber>;
-        }, import("zod/v4/core").$strict>>;
-        summarizer: import("zod").ZodDefault<import("zod").ZodObject<{
-            provider: import("zod").ZodOptional<import("zod").ZodString>;
-            model: import("zod").ZodOptional<import("zod").ZodString>;
-            thinkingEffort: import("zod").ZodDefault<import("zod").ZodEnum<{
-                low: "low";
-                high: "high";
-                none: "none";
-                medium: "medium";
-                max: "max";
-            }>>;
-        }, import("zod/v4/core").$strict>>;
-    }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
-        kind: import("zod").ZodLiteral<"prune">;
-        keepRecent: import("zod").ZodDefault<import("zod").ZodNumber>;
-        minTokens: import("zod").ZodDefault<import("zod").ZodNumber>;
-    }, import("zod/v4/core").$strict>], "kind">>;
-}, import("zod/v4/core").$strict>>;

package/dist/plugins/compaction/shared.d.ts

@@ -1,14 +0,0 @@
-import { type Context } from '@leuduan/cordis';
-import type { SurfacePrepareInput } from '../../loop/index.js';
-/**
- * A reporter that says each condition once for as long as the strategy lives, one activation. `key`
- * names the condition (its cause, the route, the latest replacement), so a step that finds it again
- * stays quiet.
- */
-export declare function onceReporter(ctx: Context): (key: string, message: string) => void;
-/** Whether the thread's agent has both recall tools granted now, so a stand-in or a footer may point at them. */
-export declare function recallGranted(ctx: Context, agentName: string): boolean;
-/** What the next request sends ahead of its messages: the recorded prompt and the tools the agent has now. */
-export declare function estimateThreadHead(ctx: Context, threadId: string, agentName: string): number;
-/** The input a step claims, which the request sends after the surface. */
-export declare const estimateClaimed: (prepare: SurfacePrepareInput) => number;

package/dist/plugins/delegations/testing.d.ts

@@ -1,16 +0,0 @@
-import type { Context } from '@leuduan/cordis';
-import type { ToolReply } from '../../kit/tool.js';
-import { type InvocationContext } from '../../loop/index.js';
-import type { Seq } from '../../models/index.js';
-import type { Thread } from '../../services/thread.js';
-import { type DelegationRequest } from './request.js';
-/** The caller's `tool/call` row that created `thread`, for tests: off the plugin's door. */
-export declare function openingCallSeqOf(thread: Thread): Seq;
-/** The task the call that created `thread` opened on it, for tests: off the plugin's door. */
-export declare const openingTaskOf: (thread: Thread) => string;
-/**
- * Runs a delegating call as the loop would, for tests that call `ctx.delegations.delegate` as a
- * host: a blocking call's wait is declared on its caller, delegations resolves it, and the call is
- * dispatched again with the value, whose reply is returned. Any other reply is returned as it is.
- */
-export declare function delegateThrough(root: Context, context: InvocationContext, request: DelegationRequest): Promise<ToolReply>;

package/dist/plugins/providers/door.d.ts

@@ -1,61 +0,0 @@
-/**
- * `@leuduan/lagent/providers`: the shipped providers, their configuration types and the Codex login
- * helpers a host resolves a credential with. The package's own entry point to this folder is
- * `index.ts`, which adds what the package keeps private.
- */
-import type { LLMProvider } from '../../llm/index.js';
-import { type CodexConfig } from './codex.js';
-import { type OpenAIChatConfig } from './openaiChat.js';
-import { type OpenAIResponsesConfig } from './openaiResponses.js';
-import { type DeepSeekResponsesConfig } from './deepseek.js';
-import { type OpenCodeGoConfig } from './opencodeGo.js';
-/**
- * A provider's configuration with its credential named: the host resolves it, from wherever it keeps
- * it, and says so even when it has none. A provider without one can still be described, its defaults
- * and models read; building a client for it then fails, naming what is missing.
- */
-type WithCredential<Config> = Config & {
-    readonly apiKey: string | undefined;
-};
-/**
- * The OpenAI Responses provider, at OpenAI's endpoint unless `baseURL` names another. Building one
- * registers nothing, so a host can read its defaults and models first (see `defaultRoute`);
- * `registerProvider(ctx, openaiResponsesProvider(config), { retry })` registers it.
- */
-export declare const openaiResponsesProvider: (config: WithCredential<OpenAIResponsesConfig>) => LLMProvider;
-/** DeepSeek's Responses API provider, at DeepSeek's endpoint unless `baseURL` names another. */
-export declare const deepseekProvider: (config: WithCredential<DeepSeekResponsesConfig>) => LLMProvider;
-/**
- * The Codex provider: the same Responses API, reached with the ChatGPT login that `codex login`
- * leaves in the file `authPath` names instead of an API key, reread per request and refreshed in
- * place when it nears expiry.
- */
-export declare const codexProvider: (config: CodexConfig & {
-    readonly authPath: string;
-    readonly refreshTimeoutMs: number;
-}) => LLMProvider;
-/**
- * The OpenAI Chat Completions provider, and with a `baseURL` any gateway that speaks it. It declares
- * no models and no windows of its own: a gateway serves whatever ids its operator configured, so the
- * windows it declares are the ones `contextWindows` configures. It replays reasoning text but no
- * opaque reasoning state, and provider-executed tools are refused.
- */
-export declare const openaiChatProvider: (config: WithCredential<OpenAIChatConfig>) => LLMProvider;
-/**
- * The OpenCode Go gateway (`https://opencode.ai/zen/go/v1`): one subscription key in front of many
- * vendors' models, each answering on one protocol: OpenAI Responses, Chat Completions or Anthropic
- * Messages, each served by its own client. The host names itself with a
- * `User-Agent` in `defaultHeaders`; each request carries its thread as Go's session header.
- */
-export declare const opencodeGoProvider: (config: WithCredential<OpenCodeGoConfig>) => LLMProvider;
-export { CODEX_PROVIDER_NAME } from './codex.js';
-export type { CodexConfig } from './codex.js';
-export type { OpenAIChatConfig } from './openaiChat.js';
-export { codexAuthPath, CodexCredentialError } from './codexAuth.js';
-export type { OpenAIResponsesConfig } from './openaiResponses.js';
-export { DEEPSEEK_RESPONSES_PROVIDER_NAME } from './deepseek.js';
-export { OPENCODE_GO_PROVIDER_NAME } from './opencodeGo.js';
-export type { OpenCodeGoConfig } from './opencodeGo.js';
-export type { DeepSeekResponsesConfig } from './deepseek.js';
-export { OPENCODE_COPILOT_PROVIDER_NAME, opencodeCopilotProvider } from './opencodeCopilot.js';
-export type { OpenCodeCopilotConfig } from './opencodeCopilot.js';