@leuduan/lagent 0.0.0-stage → 0.1.2

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

@@ -0,0 +1,71 @@
+import { z } from 'zod';
+export declare const LIST_AGENTS_TOOL = "list_agents";
+export declare const READ_AGENT_TOOL = "read_agent";
+export declare const STOP_AGENT_TOOL = "stop_agent";
+/**
+ * The tools the `delegations` plugin registers, granted to nobody: continuing, listing, reading and
+ * stopping the children a thread started, whichever tool started them. A preset grants them wherever
+ * it grants a start tool.
+ */
+export declare const DELEGATION_TOOLS: readonly ["message_agent", "list_agents", "read_agent", "stop_agent"];
+/**
+ * Validates a `message_agent` call, and is the source of the schema advertised to the model: one
+ * object, whose `kind` says which of the two gestures the call is. `background` and the route fields
+ * belong to `continue`; a steer naming one is refused as invalid arguments.
+ */
+export declare const MessageAgentParameters: z.ZodPreprocess<z.ZodObject<{
+    thread_id: z.ZodString;
+    kind: z.ZodEnum<{
+        continue: "continue";
+        steer: "steer";
+    }>;
+    message: z.ZodString;
+    background: z.ZodDefault<z.ZodBoolean>;
+    provider: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    model: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    thinking_effort: z.ZodDefault<z.ZodNullable<z.ZodEnum<{
+        low: "low";
+        high: "high";
+        none: "none";
+        medium: "medium";
+        max: "max";
+    }>>>;
+}, z.core.$strip>, unknown>;
+/**
+ * Messages a child this thread created, whichever start tool made it; `kind` is required and kept
+ * across a re-dispatch, so a correction never becomes a new assignment.
+ *
+ * `continue` opens the child's next task, queued as plain input with the task's `started` row under
+ * an id derived from this call, and the child runs on its own history; blocking, it waits for the
+ * answer, and with `background` it returns a receipt. A fork is not framed as a fork task again.
+ * Refused without a turn when the id names no thread, a thread this one did not create, or a child
+ * that stopped mid-work or still has a task open; a child a run holds is refused busy. A
+ * re-dispatch returns the recorded answer, or the receipt, without judging the route again.
+ *
+ * `steer` queues a correction into the task the call addresses, by row order as `read_agent` and
+ * `stop_agent` do, while that task's own drive runs the child (`ctx.delegations.steer`), and returns
+ * at once; it is refused, naming the outcome, on a task that has ended, and naming the state on one
+ * nothing runs now, a child whose run has not started yet included: the call never waits for a run
+ * to start, since the caller's own run slot may be what that run waits for, and its model tries
+ * again later. A re-dispatch reports what became of the message it sent.
+ */
+export declare const messageAgentTool: import("../../loop/tool.js").Tool;
+/** `list_agents`: this thread's children, however they were started, from the catalog. */
+export declare const listAgentsTool: import("../../loop/tool.js").Tool;
+/**
+ * `read_agent`: each named child's addressed task, its state and, once it settled, its answer or
+ * its failure (a background task's only when its notice does not carry it, or with `full`), or
+ * before that its recent activity; and the child's status now. Waits through `ctx.delegations.read`,
+ * a durable wait that releases the caller's run slot, for any named task to settle, or with
+ * `activity` for any named child to record anything, until nothing can advance them or the time is
+ * up; dispatched again once that wait resolves, it reports where the tasks stand then.
+ */
+export declare const readAgentTool: import("../../loop/tool.js").Tool;
+/**
+ * `stop_agent`: stops the addressed task of a child this thread started, by `ctx.delegations.stop`
+ * with this call's seq, and returns once the stop is durable. A settled task keeps its outcome, and
+ * a late turn its run still runs is cut off; a newer task of the child is never touched. A rerun
+ * repeats its own reply: the `stopped` row names the call that wrote it. The reply also says what
+ * the child is doing now.
+ */
+export declare const stopAgentTool: import("../../loop/tool.js").Tool;

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

@@ -0,0 +1,116 @@
+import type { Context } from '@leuduan/cordis';
+import { type Clock } from '../../kit/timers.js';
+import type { JournalEvent } from '../../models/index.js';
+import type { OwnerHandle } from '../../services/owner.js';
+import type { NoticeDelivery } from './notices.js';
+import { type ReadWait, type ReadWhy } from './waits.js';
+/**
+ * Why a read wait returns now, or `null` while it waits: a named task ended (`settled`); with
+ * `activity`, a named child recorded a row after the read looked; nothing can advance a named open
+ * task (`no_progress`): none of their children runs, waits to run, or is held for something that
+ * passes, such as an approval, a wait of its own, the startup policy, a missing owner or a
+ * constraint. Read from the catalog and the owner, synchronously.
+ */
+export declare function readCondition(ctx: Context, wait: ReadWait): ReadWhy | null;
+/** What the book is handed by the service that mounts it. */
+export type WaitBookOptions = {
+    /** The clock `read_agent`'s deadlines and the retries of failed decisions are kept on. */
+    readonly clock: Clock;
+    /** Resolves once the task state can be served: no decision is taken before. */
+    readonly ready: Promise<void>;
+    /** Whose notices a read that finds a task ended waits to be durable. */
+    readonly notices: NoticeDelivery;
+    /** The task constraint's registration, which resolves the waits; `undefined` while not registered. */
+    readonly constraint: () => OwnerHandle | undefined;
+};
+/**
+ * Every delegation wait, from its `wait/declared` row to its call's answer: the one owner of when a
+ * blocking call's or a `read_agent` call's wait resolves, and with what. A blocking call's wait
+ * resolves once its task's serving run settles, not handed on to a successor, or is held for a
+ * person's cancellation or a failure, with the answer chosen then; a read's once a named task ended,
+ * after that task's notice is durable, a named child recorded anything, nothing can advance them, or
+ * its deadline. The condition is read again inside the resolving write, which declines when it no
+ * longer holds.
+ *
+ * Its index is kept by rows alone, never by reading core's wait state: a declaration under
+ * delegations is booked, its resolution stops its deadline and its decisions, and its call's answer
+ * forgets it; any row or run event of a child a wait names decides that wait again. One decision at
+ * a time per wait: a trigger meanwhile is handed the one under way, and decides again after it. A
+ * decision that fails, reading or writing, is reported and taken again later, so a wait nothing else
+ * would trigger again is not lost with it. Its task's child is told whenever a blocking call starts
+ * or stops being its task's authority: as the wait is declared, and as the call is answered.
+ *
+ * The repair books every wait the catalog shows suspended on delegations, and decides at once those
+ * satisfied while the process was down; the drain stops deciding at shutdown, leaving what is due to
+ * the next startup's repair.
+ */
+export declare class WaitBook {
+    /** Every delegation wait whose call is not answered yet, by caller and call. */
+    private readonly waits;
+    /** The unresolved waits by each child they name. */
+    private readonly waitsOn;
+    /** The decision under way for each wait, and the waits to decide again once it is done. */
+    private readonly checking;
+    private readonly recheck;
+    /** Decisions that failed, by wait: each is taken again later (`retryLater`). */
+    private readonly retries;
+    /** `read_agent`'s deadlines. */
+    private readonly deadlines;
+    private closing;
+    private readonly ctx;
+    private readonly options;
+    constructor(ctx: Context, options: WaitBookOptions);
+    /**
+     * What a row does to the book: a declaration naming delegations is booked; a resolution stops
+     * deciding its wait, and a result of a booked call forgets it, telling a blocking call's task's
+     * child, whose authority the call was; any row of a child a wait names decides that wait again, so
+     * `until: 'activity'` sees the row and a task that ended is seen at once.
+     */
+    onRow(event: JournalEvent): void;
+    /** Decides again every unresolved wait naming `threadId`, after a run event of it. */
+    onRunEvent(threadId: string): void;
+    /**
+     * The startup repair of delegation waits: every caller the catalog shows suspended on delegations
+     * is read, its waits booked, and the unresolved ones decided, so a read's deadline that passed
+     * meanwhile times out and a wait whose child finished while the process was down resolves now.
+     * Resolves once those writes have landed, so the startup policy judges their causes.
+     */
+    repair(): Promise<void>;
+    /** Stops deciding, so the next startup's repair decides what is due; resolves once each decision under way has landed. */
+    drain(): Promise<void>;
+    /**
+     * Books a declared delegation wait: indexed by its caller's call and, until it resolves, by each
+     * child it names, a read's deadline armed, and its condition checked at once, since the child may
+     * have finished first. Its task's child is told: the call waiting is now its task's authority. A
+     * wait the repair finds resolved is only kept until its call is answered.
+     */
+    private book;
+    /** Stops deciding a wait whose value is recorded: its call waits only to be dispatched again. */
+    private resolved;
+    /** Forgets a wait whose call was answered, resolved or not; a blocking call's task's child is told. */
+    private answered;
+    private stopDeciding;
+    /** Checks every unresolved wait naming `childId`, after a row or a run event of it. */
+    private checkWaitsOn;
+    /** Resolves the wait under `key` if its condition holds, one decision at a time; see the class. */
+    private check;
+    /** One decision of `check`. */
+    private resolveIfDue;
+    /** Takes a failed decision again later, while its wait is still decided. */
+    private retryLater;
+    /**
+     * Where a blocking task's serving run stands once it lets its call's wait resolve, or `null` while
+     * the call keeps waiting: settled, not handed on to a successor (the task fold follows the run
+     * while the task is open, so a settled serving run is the last); or held for a person's
+     * cancellation or a failure. It keeps waiting through every hold that passes, an approval or a
+     * startup decline included. Read at the owner's published boundary, never from a raw row.
+     */
+    private taskRun;
+    /**
+     * What a blocking call is told once its task's serving run lets its wait resolve: the task's
+     * outcome once it settled; otherwise why the task did not end, which the call's result then ends
+     * it for: a person's cancel of the child, a failure it is held on, or a run that settled with the
+     * task still open.
+     */
+    private taskOutcome;
+}

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

@@ -0,0 +1,118 @@
+import { z } from 'zod';
+import type { ResolvedWait } from '../../loop/index.js';
+import type { TaskRef } from './record.js';
+import type { DelegationOutcome } from './request.js';
+export declare const TaskWaitSchema: z.ZodObject<{
+    task_id: z.ZodString;
+    child_id: z.ZodString;
+    v: z.ZodLiteral<1>;
+    kind: z.ZodLiteral<"task">;
+}, z.core.$strict>;
+export type TaskWait = z.output<typeof TaskWaitSchema>;
+export declare const ReadWaitSchema: z.ZodObject<{
+    v: z.ZodLiteral<1>;
+    kind: z.ZodLiteral<"read">;
+    tasks: z.ZodArray<z.ZodObject<{
+        task_id: z.ZodString;
+        child_id: z.ZodString;
+    }, z.core.$strict>>;
+    until: z.ZodEnum<{
+        settled: "settled";
+        activity: "activity";
+    }>;
+    since: z.ZodRecord<z.ZodString, z.ZodNumber>;
+}, z.core.$strict>;
+export type ReadWait = z.output<typeof ReadWaitSchema>;
+/**
+ * What a delegating call waits on, as its `wait/declared` row records it, versioned by delegations:
+ * a blocking call waits on its `task`; `read_agent` on the first of its named tasks to settle, or
+ * with `until: 'activity'` to record anything after `since` (each child's `through_seq` as the call
+ * looked), until its deadline.
+ */
+export declare const DelegationWaitSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    task_id: z.ZodString;
+    child_id: z.ZodString;
+    v: z.ZodLiteral<1>;
+    kind: z.ZodLiteral<"task">;
+}, z.core.$strict>, z.ZodObject<{
+    v: z.ZodLiteral<1>;
+    kind: z.ZodLiteral<"read">;
+    tasks: z.ZodArray<z.ZodObject<{
+        task_id: z.ZodString;
+        child_id: z.ZodString;
+    }, z.core.$strict>>;
+    until: z.ZodEnum<{
+        settled: "settled";
+        activity: "activity";
+    }>;
+    since: z.ZodRecord<z.ZodString, z.ZodNumber>;
+}, z.core.$strict>], "kind">;
+export type DelegationWait = z.output<typeof DelegationWaitSchema>;
+/**
+ * A blocking call's value: the answer chosen as its task's serving run settled, not handed on to a
+ * successor, or was held for a cancellation or a failure; and that run's state then. A later change
+ * of the task's state cannot change an answer recorded.
+ */
+export declare const TaskValueSchema: z.ZodObject<{
+    v: z.ZodLiteral<1>;
+    kind: z.ZodLiteral<"task">;
+    outcome: z.ZodObject<{
+        status: z.ZodEnum<{
+            completed: "completed";
+            failed: "failed";
+        }>;
+        output: z.ZodString;
+    }, z.core.$strict>;
+    run_id: z.ZodString;
+    state: z.ZodEnum<{
+        settled: "settled";
+        held: "held";
+    }>;
+    reason: z.ZodString;
+    error_text: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>;
+export type TaskValue = z.output<typeof TaskValueSchema>;
+/**
+ * Why a `read_agent` wait returned: a named task ended (`settled`); a named child recorded anything,
+ * with `until: 'activity'`; nothing can advance a named open task (`no_progress`); or the deadline.
+ */
+export declare const ReadWhySchema: z.ZodEnum<{
+    timeout: "timeout";
+    settled: "settled";
+    activity: "activity";
+    no_progress: "no_progress";
+}>;
+export type ReadWhy = z.output<typeof ReadWhySchema>;
+export declare const ReadValueSchema: z.ZodObject<{
+    v: z.ZodLiteral<1>;
+    kind: z.ZodLiteral<"read">;
+    why: z.ZodEnum<{
+        timeout: "timeout";
+        settled: "settled";
+        activity: "activity";
+        no_progress: "no_progress";
+    }>;
+}, z.core.$strict>;
+/** A blocking call's dependency. */
+export declare const taskWait: (task: TaskRef) => TaskWait;
+/** A blocking call's value. */
+export declare const taskValue: (outcome: DelegationOutcome, run: {
+    readonly runId: string;
+    readonly state: "settled" | "held";
+    readonly reason: string;
+    readonly errorText: string | null;
+}) => TaskValue;
+/** The children a wait names: a blocking call's task's, or each a read names. */
+export declare const waitedOn: (wait: DelegationWait) => string[];
+/** The tasks a read wait names, as task references. */
+export declare const readTasks: (wait: ReadWait) => TaskRef[];
+/** A blocking call's recorded answer, from the wait it resolved; throws on a payload of another version or kind. */
+export declare function taskAnswer(wait: ResolvedWait): {
+    readonly childId: string;
+    readonly outcome: DelegationOutcome;
+};
+/** A `read_agent` call's resolved wait: the tasks it named, and why it returned. */
+export declare function readAnswer(wait: ResolvedWait): {
+    readonly tasks: TaskRef[];
+    readonly why: ReadWhy;
+};

package/dist/plugins/diagnostics/digest.d.ts

@@ -0,0 +1,14 @@
+import type { ConversationMessage } from '../../llm/index.js';
+import { type DeepReadonly } from '../../util/json.js';
+import type { SentModelRequest } from '../../loop/index.js';
+/** Enough of a fingerprint to tell one value from another across restarts. */
+export declare const digestOf: (text: string) => string;
+/**
+ * A digest of everything a request sends ahead of its messages: the prompt,
+ * the tools and every option, the model included. Correlation, the ids and the purpose, is left
+ * out, so two threads sending the same head get the same digest — which is what a fork's prefix
+ * check compares.
+ */
+export declare function headDigest(request: SentModelRequest): string;
+/** A digest of a message list; a prefix of it digests the same as the same messages sent alone. */
+export declare const messagesDigest: (messages: readonly DeepReadonly<ConversationMessage>[]) => string;

package/dist/plugins/diagnostics/index.d.ts

@@ -0,0 +1,68 @@
+import type { Plugin } from '@leuduan/cordis';
+import { z } from 'zod';
+import type { PluginJournal } from '../../journal/index.js';
+import type { RowRef } from '../../loop/index.js';
+/**
+ * How a fork's first request compares with its source's request at the cut: whether it sent the
+ * same head and route, and extended the same messages. `unavailable` when there is nothing to
+ * compare with: the fork was cut before its source asked the model, or that request was never
+ * measured. Measured, not enforced: nothing sent is altered.
+ */
+export declare const PrefixCheckSchema: z.ZodObject<{
+    status: z.ZodEnum<{
+        unavailable: "unavailable";
+        matched: "matched";
+        mismatched: "mismatched";
+    }>;
+    differs: z.ZodArray<z.ZodEnum<{
+        route: "route";
+        head: "head";
+        messages: "messages";
+    }>>;
+    replaced: z.ZodNullable<z.ZodNumber>;
+}, z.core.$strict>;
+export type PrefixCheck = z.infer<typeof PrefixCheckSchema>;
+declare const MeasuresSchema: z.ZodObject<{
+    purpose: z.ZodEnum<{
+        step: "step";
+        auxiliary: "auxiliary";
+    }>;
+    system_prompt_chars: z.ZodNumber;
+    system_prompt_digest: z.ZodString;
+    head_digest: z.ZodString;
+    messages_digest: z.ZodString;
+    prefix_check: z.ZodNullable<z.ZodObject<{
+        status: z.ZodEnum<{
+            unavailable: "unavailable";
+            matched: "matched";
+            mismatched: "mismatched";
+        }>;
+        differs: z.ZodArray<z.ZodEnum<{
+            route: "route";
+            head: "head";
+            messages: "messages";
+        }>>;
+        replaced: z.ZodNullable<z.ZodNumber>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+/** What the plugin measured of one request. */
+export type RequestMeasures = z.output<typeof MeasuresSchema>;
+/**
+ * Measures every model request a thread sends, through `lagent/llm/sent`, and records it as an `ext`
+ * row citing the request row: the prompt's size and digest, a digest of the head, one of the
+ * messages, and on a fork's first model step how it compares with its source's request at the cut,
+ * which tells whether it can reuse the source's cached prefix. A mismatch with no replacement since
+ * the reference is reported. Mount it on the untagged application context.
+ *
+ * ```ts
+ * await root.plugin(diagnostics)
+ * ```
+ */
+export declare const diagnostics: Plugin.Object<undefined>;
+/**
+ * What was measured of the request recorded at `row`, or `undefined` when it was not: the plugin
+ * was not mounted then, or the request row is not loaded. Found on the request's own thread, by
+ * the citation, wherever it lies, since a fork cut at a request row is cut before its measures.
+ */
+export declare function requestMeasures(journal: Pick<PluginJournal, 'rowsAfter'>, row: RowRef): RequestMeasures | undefined;
+export {};

package/dist/plugins/diagnostics/index.js

@@ -0,0 +1 @@
+import{b as q}from"../../chunks/DRYAN665.js";import{d as y}from"../../chunks/2OSESBIL.js";import"../../chunks/YLNJXQ3Z.js";import"../../chunks/DDANMY45.js";import{d as c}from"../../chunks/37YOGDGY.js";import"../../chunks/KESCTXGO.js";import"../../chunks/TYTQRLTX.js";import{A as _}from"../../chunks/D7E6EWIE.js";import{z as r}from"zod";import{createHash as I}from"node:crypto";var m=e=>I("sha256").update(e).digest("hex").slice(0,12);function b(e){let{messages:s,agentName:t,threadId:a,llmCallId:o,purpose:n,...u}=e;return m(c(u))}var f=e=>m(c(e));var S=r.strictObject({status:r.enum(["matched","mismatched","unavailable"]),differs:r.array(r.enum(["head","route","messages"])),replaced:r.number().int().positive().nullable()}),j=r.strictObject({purpose:r.enum(["step","auxiliary"]),system_prompt_chars:r.number().int().nonnegative(),system_prompt_digest:r.string(),head_digest:r.string(),messages_digest:r.string(),prefix_check:S.nullable()}),x=q({plugin:"lagent:diagnostics",kind:"request",version:1,schema:j}),L={name:"lagent:diagnostics",inject:["journal"],apply(e){y(e,"diagnostics"),e.on("lagent/llm/sent",async({request:s,row:t})=>{let a=_(s.systemPrompt),o=b(s),n=t.type==="llm/request"?E(e.journal,t,o,s.messages):null;await x.append(e.journal,{purpose:s.purpose,system_prompt_chars:a.length,system_prompt_digest:m(a),head_digest:o,messages_digest:f(s.messages),prefix_check:n},{threadId:t.thread_id,sourceSeqs:[t.seq]}),n?.status==="mismatched"&&n.replaced===null&&e.reportError(new Error(`Thread ${t.thread_id}: a fork's first request differs from its source's in ${n.differs.join(", ")}`))})}};function D(e,s){for(let t of e.rowsAfter(s.threadId,s.seq)){if(!t.source_seqs.includes(s.seq))continue;let a=x.read(t);if(a!==void 0)return a}}function E(e,s,t,a){let o=e.rows(s.thread_id),n=o[0];if(n?.type!=="thread/spawned"||n.data.fork===null||o.some(i=>i.type==="llm/request"&&i.seq!==s.seq))return null;let{thread_id:u,seq:v}=n.data.fork,d=e.lineage(u,v).findLast(i=>i.type==="llm/request");if(d===void 0||d.type!=="llm/request")return k;let p=D(e,{threadId:d.thread_id,seq:d.seq});if(p===void 0)return k;let l=[];t!==p.head_digest&&l.push("head"),c(s.data.route)!==c(d.data.route)&&l.push("route");let g=d.data.message_count,h=null;return(a.length<g||f(a.slice(0,g))!==p.messages_digest)&&(l.push("messages"),h=e.lineage(s.thread_id).find(i=>i.type==="surface/replaced"&&i.seq>d.seq&&i.seq<s.seq)?.seq??null),{status:l.length===0?"matched":"mismatched",differs:l,replaced:h}}var k={status:"unavailable",differs:[],replaced:null};export{S as PrefixCheckSchema,L as diagnostics,D as requestMeasures};

package/dist/plugins/historyRecall/history.d.ts

@@ -0,0 +1,9 @@
+import type { Journal } from '../../journal/index.js';
+import type { Seq } from '../../models/index.js';
+/**
+ * Every message that has ever been on a thread's surface, numbered from 1 in lineage order, by the
+ * row behind it. Stand-ins are not numbered, so a number never moves: not across compactions,
+ * reopening or forks, which share their source's numbers up to the cut. The one numbering a
+ * checkpoint's footer names messages by and recall reads them back by, so the two always agree.
+ */
+export declare function historyNumbers(journal: Pick<Journal, 'lineage'>, threadId: string): Map<Seq, number>;

package/dist/plugins/historyRecall/index.d.ts

@@ -0,0 +1,31 @@
+import type { Plugin } from '@leuduan/cordis';
+import { z } from 'zod';
+import { HISTORY_RECALL_TOOLS } from './tools.js';
+export { HISTORY_RECALL_TOOLS };
+/** Message numbering, which compaction's checkpoints and stand-ins cite as recall reads it back. */
+export { historyNumbers } from './history.js';
+/**
+ * The line a stand-in ends on when its agent has both tools: where to read the `count` replaced
+ * messages back, `first` being the number of the first of them. Written here, beside the tools it
+ * names, so the pointer and what it points at change together. The form for several is the longer.
+ */
+export declare const renderRecall: (first: number, count: number) => string;
+export declare const HistoryRecallConfigSchema: z.ZodObject<{
+    agents: z.ZodUnion<readonly [z.ZodArray<z.ZodString>, z.ZodLiteral<"global">, z.ZodLiteral<"all">]>;
+}, z.core.$strict>;
+export type HistoryRecallConfig = z.input<typeof HistoryRecallConfigSchema>;
+/**
+ * Registers `history_read` and `history_search`: read-only tools over the journal that bring back
+ * what a replacement condensed, by the message numbers a checkpoint names. Each reads the calling
+ * thread's own lineage, a fork's inherited rows included, and nothing of any other thread. They are
+ * advertised to the selected agents from a thread's first request, and answer that nothing has been
+ * condensed until something has. Independent of any strategy: it reads the journal, not how the
+ * surface was replaced. A strategy that sees `history_read` granted points its checkpoints at it.
+ *
+ * Mounted on the untagged application context only: the tools are one grant for every thread.
+ *
+ * ```ts
+ * await root.plugin(historyRecall, { agents: ['main_agent'] })
+ * ```
+ */
+export declare const historyRecall: Plugin.Object<HistoryRecallConfig>;

package/dist/plugins/historyRecall/index.js

@@ -0,0 +1 @@
+import{a,b,c,d,e}from"../../chunks/UC3FVVJ2.js";import"../../chunks/NAOUTU7A.js";import"../../chunks/UKXMCHHT.js";import"../../chunks/2OSESBIL.js";import"../../chunks/YLNJXQ3Z.js";import"../../chunks/DDANMY45.js";import"../../chunks/37YOGDGY.js";import"../../chunks/KESCTXGO.js";import"../../chunks/TYTQRLTX.js";import"../../chunks/D7E6EWIE.js";export{b as HISTORY_RECALL_TOOLS,d as HistoryRecallConfigSchema,a as historyNumbers,e as historyRecall,c as renderRecall};

package/dist/plugins/historyRecall/render.d.ts

@@ -0,0 +1,34 @@
+import type { PluginJournal } from '../../journal/index.js';
+import { type MessageRole } from '../../llm/index.js';
+/** One message that has been on a thread's surface, as recall shows it. */
+export type HistoryMessage = {
+    /** Its history number: 1 for the first message the thread's conversation ever held. */
+    readonly number: number;
+    readonly role: MessageRole;
+    /** The tool a result answers; `null` for any other message. */
+    readonly name: string | null;
+    /** The message as rendered, without its header. */
+    readonly body: string;
+    /**
+     * Whether the surface no longer holds this message as itself: a replacement stands for it, as a
+     * span's checkpoint or a rewrite's shorter text.
+     */
+    readonly condensed: boolean;
+};
+/**
+ * Every message that has ever been on a thread's surface, in lineage order, numbered as
+ * `historyNumbers` numbers them and rendered as the model saw it: the same row-to-message logic the
+ * surface fold uses, with replacements ignored. A pure read over the journal: nothing here depends
+ * on how, or whether, the surface was ever replaced, except which messages `condensed` marks.
+ *
+ * A fork reads its source's rows up to its cut as its own, so it shares their numbers and text.
+ */
+export declare function history(journal: Pick<PluginJournal, 'lineage' | 'state'>, threadId: string): HistoryMessage[];
+/**
+ * A message in a transcript: its body in an envelope the code writes, which names its number, role
+ * and, for a result, its tool. A body cannot end the envelope or fake another, since every closing
+ * `</message` in it is turned into `<\/message`: nothing a message said speaks as the harness.
+ */
+export declare const renderMessage: (message: HistoryMessage) => string;
+/** A message named in a listing: `Message 5 (user)`, `Message 6 (tool read_file)`. */
+export declare const describeMessage: (message: HistoryMessage) => string;

package/dist/plugins/historyRecall/tools.d.ts

@@ -0,0 +1,4 @@
+/** The tools the plugin grants, for a host's allowlist or an agent's tool list. */
+export declare const HISTORY_RECALL_TOOLS: readonly ["history_read", "history_search"];
+export declare const historyReadTool: import("../../loop/tool.js").Tool;
+export declare const historySearchTool: import("../../loop/tool.js").Tool;

package/dist/plugins/mcp/catalog.d.ts

@@ -0,0 +1,36 @@
+import type { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import { type Tool as RemoteTool } from '@modelcontextprotocol/sdk/types.js';
+import { type ToolSpec } from '../../llm/index.js';
+import type { McpConfig } from './config.js';
+import type { UnexposableTool } from './errors.js';
+/** One exposable tool: its lagent name, the definition the server listed, and the spec built from it. */
+export type CatalogEntry = {
+    readonly name: string;
+    readonly remoteName: string;
+    readonly definition: RemoteTool;
+    readonly spec: ToolSpec;
+    /** Equal for equal definitions; a changed definition is a different tool. */
+    readonly fingerprint: string;
+};
+/** A complete, immutable snapshot of what a server offers, as lagent can expose it. */
+export type Catalog = {
+    readonly entries: ReadonlyMap<string, CatalogEntry>;
+    readonly unexposable: readonly UnexposableTool[];
+};
+export declare const EMPTY_CATALOG: Catalog;
+/**
+ * Every page of `tools/list`, requested directly. The SDK's `listTools()` replaces the client's
+ * validator and task caches on every page, and its list-changed refresh fetches only the first one.
+ */
+export declare function listAllTools(client: Client, signal: AbortSignal): Promise<RemoteTool[]>;
+/**
+ * What lagent can expose of a complete listing. With an allowlist only the listed tools are
+ * considered, under their aliases, and a listed tool the server does not offer is unexposable.
+ * Collisions are found over the whole listing, so the outcome never depends on how the server
+ * paged: every tool of a colliding group is unexposable.
+ */
+export declare function buildCatalog(config: Pick<McpConfig, 'name' | 'tools'>, listed: readonly RemoteTool[]): Catalog;
+/** Unexposable tools in one order, by tool and then reason, whatever order they were found in. */
+export declare const sortUnexposable: (tools: readonly UnexposableTool[]) => UnexposableTool[];
+/** Whether two reports of unexposable tools say the same thing. */
+export declare const sameUnexposable: (left: readonly UnexposableTool[], right: readonly UnexposableTool[]) => boolean;

package/dist/plugins/mcp/config.d.ts

@@ -0,0 +1,63 @@
+import type { Transport } from '@modelcontextprotocol/sdk/shared/transport.js';
+import { z } from 'zod';
+/**
+ * The longest server name: `mcp__` and `__` around it still leave 33 of the 64 characters a tool
+ * name may have for the tool segment.
+ */
+export declare const MAX_SERVER_NAME_LENGTH = 24;
+/**
+ * A factory for any SDK transport. A transport is single-use, so every connection asks for a new one.
+ * `signal` aborts when the opening is abandoned (its deadline, the owner's signal, disposal): stop
+ * working then. A transport that arrives after that is closed by the mount.
+ */
+export type McpTransportFactory = (signal: AbortSignal) => Transport | Promise<Transport>;
+export declare const McpTransportSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"stdio">;
+    command: z.ZodTuple<[z.ZodString], z.ZodString>;
+    cwd: z.ZodString;
+    env: z.ZodRecord<z.ZodString, z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"streamable-http">;
+    url: z.ZodURL;
+    headers: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"custom">;
+    create: z.ZodCustom<McpTransportFactory, McpTransportFactory>;
+}, z.core.$strict>], "kind">;
+export type McpTransportConfig = z.output<typeof McpTransportSchema>;
+export declare const McpConfigSchema: z.ZodObject<{
+    name: z.ZodString;
+    transport: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"stdio">;
+        command: z.ZodTuple<[z.ZodString], z.ZodString>;
+        cwd: z.ZodString;
+        env: z.ZodRecord<z.ZodString, z.ZodString>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"streamable-http">;
+        url: z.ZodURL;
+        headers: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"custom">;
+        create: z.ZodCustom<McpTransportFactory, McpTransportFactory>;
+    }, z.core.$strict>], "kind">;
+    agents: z.ZodUnion<readonly [z.ZodArray<z.ZodString>, z.ZodLiteral<"global">, z.ZodLiteral<"all">]>;
+    confirm: z.ZodUnion<readonly [z.ZodLiteral<"all">, z.ZodLiteral<"none">, z.ZodObject<{
+        except: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>]>;
+    onInterrupted: z.ZodUnion<readonly [z.ZodLiteral<"report">, z.ZodLiteral<"annotations">, z.ZodObject<{
+        rerun: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>]>;
+    maxConcurrentCalls: z.ZodUnion<readonly [z.ZodNumber, z.ZodLiteral<"unbounded">]>;
+    tools: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        name: z.ZodString;
+        as: z.ZodString;
+    }, z.core.$strict>]>>>;
+    instructions: z.ZodDefault<z.ZodBoolean>;
+    connectTimeoutSeconds: z.ZodDefault<z.ZodNumber>;
+    callTimeoutSeconds: z.ZodDefault<z.ZodNumber>;
+    maxCallSeconds: z.ZodDefault<z.ZodNumber>;
+    maxContentBytes: z.ZodDefault<z.ZodNumber>;
+    signal: z.ZodOptional<z.ZodCustom<AbortSignal, AbortSignal>>;
+}, z.core.$strict>;
+export type McpConfig = z.output<typeof McpConfigSchema>;
+export type McpConfigInput = z.input<typeof McpConfigSchema>;

package/dist/plugins/mcp/connection.d.ts

@@ -0,0 +1,53 @@
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import type { Transport } from '@modelcontextprotocol/sdk/shared/transport.js';
+import type { McpTransportConfig } from './config.js';
+/** One successful initialization: a client, its transport, and the server's instructions. */
+export type Generation = {
+    readonly number: number;
+    readonly client: Client;
+    readonly transport: Transport;
+    readonly instructions: string | null;
+    /** False once the transport closed or the session ended; a dead generation is never reused. */
+    alive: boolean;
+};
+export type ConnectionOptions = {
+    readonly server: string;
+    readonly transport: McpTransportConfig;
+    /** The mount's lifetime: aborting it stops a stdio server's group. */
+    readonly lifetime: AbortSignal;
+    /** The live generation's server says its tools changed. */
+    readonly onToolsChanged: (generation: Generation) => void;
+    /** The live generation went away on its own. */
+    readonly onLost: (generation: Generation, reason: string) => void;
+};
+/**
+ * The transport, initialization and lifetime of one server's connection. Each successful
+ * initialization is a new generation; whoever holds one can tell whether it is still the live one.
+ * The client declares no capabilities, so the server can ask it for nothing: no sampling,
+ * elicitation or roots.
+ */
+export declare class McpConnection {
+    private live;
+    private count;
+    private disposed;
+    private readonly options;
+    constructor(options: ConnectionOptions);
+    /** The live generation, if there is one. */
+    get current(): Generation | null;
+    /**
+     * Connects and initializes a new generation, which becomes the live one. `signal` bounds the whole
+     * opening: creating the transport (a custom factory gets the signal), starting it, `initialize` and
+     * the `initialized` notification. The SDK bounds only `initialize`; the rest could wait for ever.
+     * On expiry the client is closed, which closes the transport and deletes an HTTP session the server
+     * already granted (`closeOnce`); a factory that answers after that has its result closed.
+     */
+    open(signal: AbortSignal, timeoutMs: number): Promise<Generation>;
+    /** Ends a generation the server no longer recognizes, such as a session it answered 404 for. */
+    invalidate(generation: Generation): Promise<void>;
+    /** Ends the live generation: closing shuts a stdio server down and deletes an HTTP session (`closeOnce`). */
+    dispose(): Promise<void>;
+    private createTransport;
+    private describeClose;
+}
+/** Whether an error is the HTTP 404 a server answers for a session it ended. */
+export declare const isSessionGone: (error: unknown) => boolean;