@leuduan/lagent 0.1.2 → 44.0.0

package/dist/plugins/verify/record.d.ts

@@ -0,0 +1,382 @@
+import { z } from 'zod';
+export declare const VERIFY_PRESET = "verify";
+/** Repair continuations per verification since person input or genuinely new assignment arming. */
+export declare const VERIFY_REPAIRS = 2;
+export type Verification = {
+    readonly command: string;
+    readonly cwd: string;
+};
+export declare const notice: {
+    record: (value: {
+        command: string;
+        cwd: string;
+    }) => import("../../records/journal.js").ExtensionRecord;
+    parse: (value: {
+        command: string;
+        cwd: string;
+    }) => {
+        command: string;
+        cwd: string;
+    };
+    entry: (value: {
+        command: string;
+        cwd: string;
+    }, options: import("../../plugin.js").AppendOptions) => {
+        type: "ext";
+        data: {
+            plugin: string;
+            instance_id: string;
+            kind: string;
+            version: number;
+            data: z.core.util.JSONType;
+        };
+        options: import("../../plugin.js").AppendOptions;
+    };
+    append(journal: import("../../plugin.js").PluginJournal, value: {
+        command: string;
+        cwd: string;
+    }, options: import("../../plugin.js").AppendOptions): Promise<import("../../records/journal.js").JournalEvent<"ext">>;
+    read(event: import("../../records/journal.js").JournalEvent): {
+        command: string;
+        cwd: string;
+    } | undefined;
+    contribution(message: {
+        role?: import("../../records/journal.js").InputRole;
+        content: string | readonly import("../../llm/content.js").ContentPartInput[];
+    }, value: {
+        command: string;
+        cwd: string;
+    }, options?: {
+        sourceSeqs?: readonly import("../../records/journal.js").Seq[];
+    }): import("../../records/journal.js").StepContribution;
+    matchesSource(record: import("../../util/json.js").DeepReadonly<import("../../records/journal.js").ExtensionRecord>): boolean;
+    rejection(reason: string, value: {
+        command: string;
+        cwd: string;
+    }): {
+        decision: "reject";
+        reason: string;
+        source: import("../../records/journal.js").ExtensionRecord;
+    };
+    readContribution: (event: import("../../records/journal.js").JournalEvent) => {
+        command: string;
+        cwd: string;
+    } | undefined;
+    readSource: (source: import("../../util/json.js").DeepReadonly<import("../../records/journal.js").ExtensionRecord> | null) => {
+        command: string;
+        cwd: string;
+    } | undefined;
+    told: import("../../plugin.js").PluginProjection<import("../../services/extensionEvents.js").ToldNotices<{
+        command: string;
+        cwd: string;
+    }>>;
+    projection<State>(fold: {
+        key: string;
+        init(): State;
+        apply(state: State, value: {
+            command: string;
+            cwd: string;
+        }, event: import("../../records/journal.js").JournalEvent<"ext">): State;
+        onFork?: "inherit" | "reset";
+    }): import("../../plugin.js").PluginProjection<State>;
+};
+export declare const repair: {
+    record: (value: {
+        command: string;
+        cwd: string;
+    }) => import("../../records/journal.js").ExtensionRecord;
+    parse: (value: {
+        command: string;
+        cwd: string;
+    }) => {
+        command: string;
+        cwd: string;
+    };
+    entry: (value: {
+        command: string;
+        cwd: string;
+    }, options: import("../../plugin.js").AppendOptions) => {
+        type: "ext";
+        data: {
+            plugin: string;
+            instance_id: string;
+            kind: string;
+            version: number;
+            data: z.core.util.JSONType;
+        };
+        options: import("../../plugin.js").AppendOptions;
+    };
+    append(journal: import("../../plugin.js").PluginJournal, value: {
+        command: string;
+        cwd: string;
+    }, options: import("../../plugin.js").AppendOptions): Promise<import("../../records/journal.js").JournalEvent<"ext">>;
+    read(event: import("../../records/journal.js").JournalEvent): {
+        command: string;
+        cwd: string;
+    } | undefined;
+    contribution(message: {
+        role?: import("../../records/journal.js").InputRole;
+        content: string | readonly import("../../llm/content.js").ContentPartInput[];
+    }, value: {
+        command: string;
+        cwd: string;
+    }, options?: {
+        sourceSeqs?: readonly import("../../records/journal.js").Seq[];
+    }): import("../../records/journal.js").StepContribution;
+    matchesSource(record: import("../../util/json.js").DeepReadonly<import("../../records/journal.js").ExtensionRecord>): boolean;
+    rejection(reason: string, value: {
+        command: string;
+        cwd: string;
+    }): {
+        decision: "reject";
+        reason: string;
+        source: import("../../records/journal.js").ExtensionRecord;
+    };
+    readContribution: (event: import("../../records/journal.js").JournalEvent) => {
+        command: string;
+        cwd: string;
+    } | undefined;
+    readSource: (source: import("../../util/json.js").DeepReadonly<import("../../records/journal.js").ExtensionRecord> | null) => {
+        command: string;
+        cwd: string;
+    } | undefined;
+    told: import("../../plugin.js").PluginProjection<import("../../services/extensionEvents.js").ToldNotices<{
+        command: string;
+        cwd: string;
+    }>>;
+    projection<State>(fold: {
+        key: string;
+        init(): State;
+        apply(state: State, value: {
+            command: string;
+            cwd: string;
+        }, event: import("../../records/journal.js").JournalEvent<"ext">): State;
+        onFork?: "inherit" | "reset";
+    }): import("../../plugin.js").PluginProjection<State>;
+};
+export declare const rejected: {
+    record: (value: {
+        cause: "execution" | "denied" | "unverified";
+        command: string;
+        cwd: string;
+    }) => import("../../records/journal.js").ExtensionRecord;
+    parse: (value: {
+        cause: "execution" | "denied" | "unverified";
+        command: string;
+        cwd: string;
+    }) => {
+        cause: "execution" | "denied" | "unverified";
+        command: string;
+        cwd: string;
+    };
+    entry: (value: {
+        cause: "execution" | "denied" | "unverified";
+        command: string;
+        cwd: string;
+    }, options: import("../../plugin.js").AppendOptions) => {
+        type: "ext";
+        data: {
+            plugin: string;
+            instance_id: string;
+            kind: string;
+            version: number;
+            data: z.core.util.JSONType;
+        };
+        options: import("../../plugin.js").AppendOptions;
+    };
+    append(journal: import("../../plugin.js").PluginJournal, value: {
+        cause: "execution" | "denied" | "unverified";
+        command: string;
+        cwd: string;
+    }, options: import("../../plugin.js").AppendOptions): Promise<import("../../records/journal.js").JournalEvent<"ext">>;
+    read(event: import("../../records/journal.js").JournalEvent): {
+        cause: "execution" | "denied" | "unverified";
+        command: string;
+        cwd: string;
+    } | undefined;
+    contribution(message: {
+        role?: import("../../records/journal.js").InputRole;
+        content: string | readonly import("../../llm/content.js").ContentPartInput[];
+    }, value: {
+        cause: "execution" | "denied" | "unverified";
+        command: string;
+        cwd: string;
+    }, options?: {
+        sourceSeqs?: readonly import("../../records/journal.js").Seq[];
+    }): import("../../records/journal.js").StepContribution;
+    matchesSource(record: import("../../util/json.js").DeepReadonly<import("../../records/journal.js").ExtensionRecord>): boolean;
+    rejection(reason: string, value: {
+        cause: "execution" | "denied" | "unverified";
+        command: string;
+        cwd: string;
+    }): {
+        decision: "reject";
+        reason: string;
+        source: import("../../records/journal.js").ExtensionRecord;
+    };
+    readContribution: (event: import("../../records/journal.js").JournalEvent) => {
+        cause: "execution" | "denied" | "unverified";
+        command: string;
+        cwd: string;
+    } | undefined;
+    readSource: (source: import("../../util/json.js").DeepReadonly<import("../../records/journal.js").ExtensionRecord> | null) => {
+        cause: "execution" | "denied" | "unverified";
+        command: string;
+        cwd: string;
+    } | undefined;
+    told: import("../../plugin.js").PluginProjection<import("../../services/extensionEvents.js").ToldNotices<{
+        cause: "execution" | "denied" | "unverified";
+        command: string;
+        cwd: string;
+    }>>;
+    projection<State>(fold: {
+        key: string;
+        init(): State;
+        apply(state: State, value: {
+            cause: "execution" | "denied" | "unverified";
+            command: string;
+            cwd: string;
+        }, event: import("../../records/journal.js").JournalEvent<"ext">): State;
+        onFork?: "inherit" | "reset";
+    }): import("../../plugin.js").PluginProjection<State>;
+};
+/**
+ * A verification owed for one assignment, recorded on the thread serving it: the assignment's
+ * identity (its owner, id and participant generation, as an assignment origin names them), the
+ * input whose claim activates it, and the pinned verification. Its identity is the assignment's.
+ */
+declare const RequirementSchema: z.ZodObject<{
+    owner: z.ZodString;
+    assignment: z.ZodString;
+    generation: z.ZodNumber;
+    input: z.ZodString;
+    command: z.ZodString;
+    cwd: z.ZodString;
+}, z.core.$strict>;
+export type RequirementInput = z.input<typeof RequirementSchema>;
+export type Requirement = z.output<typeof RequirementSchema>;
+export declare const requirement: {
+    record: (value: {
+        owner: string;
+        assignment: string;
+        generation: number;
+        input: string;
+        command: string;
+        cwd: string;
+    }) => import("../../records/journal.js").ExtensionRecord;
+    parse: (value: {
+        owner: string;
+        assignment: string;
+        generation: number;
+        input: string;
+        command: string;
+        cwd: string;
+    }) => {
+        owner: string;
+        assignment: string;
+        generation: number;
+        input: string;
+        command: string;
+        cwd: string;
+    };
+    entry: (value: {
+        owner: string;
+        assignment: string;
+        generation: number;
+        input: string;
+        command: string;
+        cwd: string;
+    }, options: import("../../plugin.js").AppendOptions) => {
+        type: "ext";
+        data: {
+            plugin: string;
+            instance_id: string;
+            kind: string;
+            version: number;
+            data: z.core.util.JSONType;
+        };
+        options: import("../../plugin.js").AppendOptions;
+    };
+    append(journal: import("../../plugin.js").PluginJournal, value: {
+        owner: string;
+        assignment: string;
+        generation: number;
+        input: string;
+        command: string;
+        cwd: string;
+    }, options: import("../../plugin.js").AppendOptions): Promise<import("../../records/journal.js").JournalEvent<"ext">>;
+    read(event: import("../../records/journal.js").JournalEvent): {
+        owner: string;
+        assignment: string;
+        generation: number;
+        input: string;
+        command: string;
+        cwd: string;
+    } | undefined;
+    contribution(message: {
+        role?: import("../../records/journal.js").InputRole;
+        content: string | readonly import("../../llm/content.js").ContentPartInput[];
+    }, value: {
+        owner: string;
+        assignment: string;
+        generation: number;
+        input: string;
+        command: string;
+        cwd: string;
+    }, options?: {
+        sourceSeqs?: readonly import("../../records/journal.js").Seq[];
+    }): import("../../records/journal.js").StepContribution;
+    matchesSource(record: import("../../util/json.js").DeepReadonly<import("../../records/journal.js").ExtensionRecord>): boolean;
+    rejection(reason: string, value: {
+        owner: string;
+        assignment: string;
+        generation: number;
+        input: string;
+        command: string;
+        cwd: string;
+    }): {
+        decision: "reject";
+        reason: string;
+        source: import("../../records/journal.js").ExtensionRecord;
+    };
+    readContribution: (event: import("../../records/journal.js").JournalEvent) => {
+        owner: string;
+        assignment: string;
+        generation: number;
+        input: string;
+        command: string;
+        cwd: string;
+    } | undefined;
+    readSource: (source: import("../../util/json.js").DeepReadonly<import("../../records/journal.js").ExtensionRecord> | null) => {
+        owner: string;
+        assignment: string;
+        generation: number;
+        input: string;
+        command: string;
+        cwd: string;
+    } | undefined;
+    told: import("../../plugin.js").PluginProjection<import("../../services/extensionEvents.js").ToldNotices<{
+        owner: string;
+        assignment: string;
+        generation: number;
+        input: string;
+        command: string;
+        cwd: string;
+    }>>;
+    projection<State>(fold: {
+        key: string;
+        init(): State;
+        apply(state: State, value: {
+            owner: string;
+            assignment: string;
+            generation: number;
+            input: string;
+            command: string;
+            cwd: string;
+        }, event: import("../../records/journal.js").JournalEvent<"ext">): State;
+        onFork?: "inherit" | "reset";
+    }): import("../../plugin.js").PluginProjection<State>;
+};
+/** `value` validated as a requirement, its directory normalized as a placed run's is. */
+export declare function requirementValue(value: RequirementInput): Requirement;
+export {};

package/dist/plugins/verify/service.d.ts

@@ -1,6 +1,6 @@
 import { Service, type Context } from '@leuduan/cordis';
-import { type WriteRows } from '../../loop/index.js';
-import { type Verification } from './facts.js';
+import { type WriteRows } from '../../state/index.js';
+import { type Verification } from './record.js';
 declare module '@leuduan/cordis' {
     interface Context {
         /** Verification: the gates and assignment requirements of every thread (optional plugin). */
@@ -24,7 +24,7 @@ export type OwedVerification = {
     readonly generation: number;
     /** The input whose claim activates the assignment, which arms the requirement. */
     readonly inputId: string;
-    /** The pinned verification: the command text `run_command` must be given. */
+    /** The pinned command runtime executes when completion needs proof. */
     readonly command: string;
     /** The absolute directory it must run in. */
     readonly cwd: string;
@@ -37,7 +37,8 @@ export type OwedVerification = {
  * both its arming and the last change, whether or not the thread changed anything. A gate and a
  * requirement on one verification are judged once, together; a later requirement supersedes an
  * earlier one, as does a delegation task opened on the thread after it armed, and replaying one
- * renews no reminder or denial.
+ * renews no repair allowance. Core executes its pure preparation plans through current policy;
+ * ordinary model commands never establish proof.
  *
  * Each verification covers the thread's delegated work too: a change any thread its calls started
  * made, at any depth, its passing runs of the same verification included, needs a pass after it, read from that thread's facts when it is loaded and
@@ -78,6 +79,8 @@ export declare class VerifyService extends Service {
      * and what its judgment reads of the thread's facts, and the last change of its delegated work.
      */
     private observed;
+    /** The same call-origin ownership scope as delegated mutation coverage, with affirmative cleanup evidence. */
+    private work;
     /**
      * The verifications in force on the thread, by {@link commandKey}, each with the moment its
      * requirement armed (`null` for a gate alone), and its delegated work's last change.

package/dist/plugins/verify/state.d.ts

@@ -0,0 +1,58 @@
+import { type PluginJournal } from '../../journal/index.js';
+import { type Refusal } from '../../state/index.js';
+import type { Seq } from '../../records/journal.js';
+import type { ToolResult } from '../../records/toolResult.js';
+import { type Verification, type Requirement, requirement } from './record.js';
+export declare const commandKey: (command: string, cwd: string) => string;
+type Attempt = {
+    seq: Seq;
+    candidate: Seq;
+    key: string;
+    verification: Verification;
+    authorizedAt: Seq | null;
+    resultAt: Seq | null;
+    result: ToolResult | null;
+};
+export type VerifyFacts = {
+    calls: Map<string, Seq | null>;
+    changedAt: Seq | null;
+    personAt: Seq | null;
+    repairs: Map<string, Seq[]>;
+    attempts: Map<Seq, Attempt>;
+};
+export declare const later: (a: Seq | null, b: Seq | null) => Seq | null;
+/** All ordinary commands are mutations; only durable runtime results can establish proof. */
+export declare const verifyFacts: import("../../journal/projection.js").PluginProjection<VerifyFacts>;
+export declare const changes: import("../../services/catalogContributions.js").ContributionDefinition<{
+    changed_at: number | null;
+}>;
+export type DelegatedChange = {
+    readonly at: Seq | null;
+} | {
+    readonly unreadable: string;
+};
+/** Call-origin descendants belong to the caller; assignment-origin work is verified independently. */
+export declare function workScope(journal: PluginJournal, threadId: string): Set<string>;
+export declare function delegatedChange(journal: PluginJournal, threadId: string): DelegatedChange;
+/**
+ * The rows recording `value` on `threadId`, decided inside its write: one row for a requirement
+ * not recorded yet; none for one recorded already exactly so (a replay renews nothing); a refusal
+ * for one recorded under its identity otherwise. A thread being opened has none recorded.
+ */
+export declare function requirementRows(journal: PluginJournal, threadId: string, opening: boolean, parsed: Requirement): ReturnType<typeof requirement.entry>[] | {
+    refuse: Refusal;
+};
+/**
+ * The requirement in force on a thread: the one armed last, with the moment it armed, the later of
+ * its input's claim and its own row (so one recorded after the claim arms at its row); `null` while
+ * none has armed. A participant serves one assignment at a time, so a later arming supersedes every
+ * earlier requirement: two of them, pinned to different commands, would otherwise each count the
+ * other's runs as changes and never both pass. A requirement lives for the assignment that armed it:
+ * a delegation task opened on the thread after it armed, a successor assignment owing no
+ * verification included, retires it. Row seqs are one journal's, so the two compare directly.
+ */
+export declare function inForce(journal: PluginJournal, threadId: string): {
+    verification: Verification;
+    at: Seq;
+} | null;
+export {};

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

@@ -0,0 +1,34 @@
+import type { Plugin } from '@leuduan/cordis';
+import { z } from 'zod';
+export type { WebSearchConfig } from './web.js';
+/**
+ * What the web tools are configured with, all of it the host's choice: what `web_fetch` may reach
+ * (`privateNetwork`: `refuse` keeps it on the public internet) and the Codex login `web_search`
+ * searches through (`search`; with `null` there is no `web_search`).
+ */
+declare const WebToolsConfigSchema: z.ZodObject<{
+    privateNetwork: z.ZodEnum<{
+        allow: "allow";
+        refuse: "refuse";
+    }>;
+    search: z.ZodNullable<z.ZodObject<{
+        authPath: z.ZodString;
+        refreshTimeoutMs: z.ZodNumber;
+        model: z.ZodString;
+        maxOutputTokens: z.ZodNumber;
+        responseLength: z.ZodEnum<{
+            medium: "medium";
+            short: "short";
+            long: "long";
+        }>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type WebToolsConfig = z.input<typeof WebToolsConfigSchema>;
+/** The tools that fetch and search the web; `web_search` only where the host configures `search`. */
+export declare const WEB_TOOLS: readonly ["web_fetch", "web_search"];
+/**
+ * Registers `web_fetch`, and `web_search` when `search` names a Codex login, for the life of the
+ * plugin. Neither touches the workspace: they reach the network under the policy configured here.
+ * The host names the private-network policy and the search login; there is no default for either.
+ */
+export declare const webTools: Plugin.Object<WebToolsConfig>;

package/dist/plugins/webTools/index.js

@@ -0,0 +1 @@
+import{a,b}from"../../chunks/SS3B5W34.js";import"../../chunks/Q75FUN7D.js";import"../../chunks/34KW6VNQ.js";import"../../chunks/JFX2MXBA.js";import"../../chunks/CUK7CGC7.js";import"../../chunks/BPRCULZH.js";import"../../chunks/FJLU4UH3.js";import"../../chunks/DDANMY45.js";import"../../chunks/BBCW2FZK.js";import"../../chunks/MMNNZCBO.js";import"../../chunks/G44LG6VL.js";import"../../chunks/D4PQP5MA.js";export{a as WEB_TOOLS,b as webTools};

package/dist/plugins/workflows/assignment.d.ts

@@ -1,4 +1,5 @@
 import type { Context } from '@leuduan/cordis';
+import { type ResultDecision } from './state.js';
 import { type Governance } from './policy.js';
 /**
  * Presents each instance to the threads working it at the model steps they take (§6 of the design),
@@ -12,5 +13,8 @@ import { type Governance } from './policy.js';
  * which the activation's claim alone gives.
  */
 export declare function presentAssignments(ctx: Context, governance: Governance): void;
-/** A host decision's verdict as the model is told it: what was decided, never who decided it. */
-export declare function verdictOf(verdict: 'approve' | 'revise'): string;
+/**
+ * A host decision on `step` as the model is told it, by a transition's notice or the attempt it
+ * opened: its verdict and option, and its feedback, defused, in a block of its own.
+ */
+export declare function toldDecision(step: string, decided: ResultDecision): string;

package/dist/plugins/workflows/cleanup.d.ts

@@ -1,6 +1,6 @@
 import type { Context } from '@leuduan/cordis';
 import type { AppendEntry } from '../../journal/index.js';
-import { type InstanceState } from './fold.js';
+import { type InstanceState } from './state.js';
 import type { InstanceRowInput } from './record.js';
 import type { Barrier } from './routing.js';
 import type { ReadonlyState } from '../../util/foldState.js';

package/dist/plugins/workflows/definition.d.ts

@@ -1,7 +1,7 @@
 import { z } from 'zod';
-import { type ThinkingEffort } from '../../llm/index.js';
+import { type ThinkingEffort } from '../../llm/primitives.js';
 import { type ReadonlyJsonValue } from '../../util/json.js';
-import type { ResultDecision } from './fold.js';
+import type { ResultDecision } from './state.js';
 /** The edge target that completes an instance. */
 export declare const COMPLETE = "$complete";
 /** A value an edge predicate compares a field with. */

package/dist/plugins/workflows/{bindings.d.ts → entryPlan.d.ts}

@@ -1,7 +1,7 @@
 import type { ReadonlyJsonValue } from '../../util/json.js';
 import type { CanonicalDefinition } from './definition.js';
-import type { InstanceState, ResultDecision } from './fold.js';
-import type { Acquired } from './providers.js';
+import type { InstanceState, ResultDecision } from './state.js';
+import type { Acquired } from './hostBindings.js';
 import type { ReadonlyState } from '../../util/foldState.js';
 import { type Entered, type InstanceRowInput, type TransitionCause } from './record.js';
 /**

package/dist/plugins/workflows/{providers.d.ts → hostBindings.d.ts}

@@ -1,6 +1,6 @@
 import { z } from 'zod';
-import type { WriteRows } from '../../loop/index.js';
-import type { InitialInstallation, ThreadEnvironment } from '../../models/index.js';
+import type { WriteRows } from '../../state/index.js';
+import type { InitialInstallation, ThreadEnvironment } from '../../records/journal.js';
 import type { DeepReadonly, JsonValue } from '../../util/json.js';
 /**
  * A conversation's configuration as a provider pins from it: the root's, as the host proposes to

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

@@ -13,16 +13,16 @@ import { type WorkflowsConfig } from './service.js';
  * write. Isolated participants' tasks are started by the plugin itself, as delegations' owner of
  * them, independently of the root's turns; a definition with isolated participants needs
  * delegations mounted first. All configuration is required. Root-only, mounted once by the
- * application. See `docs/workflows.md`.
+ * application. See `docs/records/workflows.md`.
  */
 export declare const workflows: Plugin.Object<WorkflowsConfig>;
 export { defineWorkflow, WorkflowDefinitionError } from './definition.js';
 export type { Assignment, Binding, CanonicalDefinition, Condition, Definition, Edge, JsonScalar, JsonSchema, Participant, ParticipantModel, Step, StepOption, WorkflowDefinition, } from './definition.js';
-export { WorkflowRefusedError } from './service.js';
+export { resolveParticipantModels, WorkflowRefusedError } from './participantModels.js';
 export { SUBMIT_TOOL, WORKFLOWS_OWNER } from './record.js';
 export type { CancelRequest, CatalogEntry, DecideRequest, OpeningRequest, Prerequisite, StopCancel, RoleBinding, WorkflowsConfig, WorkflowsService, } from './service.js';
-export type { Acquired, CheckProvider, CheckRequest, Configured, EvidenceProvider, EvidenceRequest, PinOutcome, ProviderBinding, ProviderNotice, } from './providers.js';
-export type { DecisionReason, PendingDecision, ResultDecision, Subject } from './fold.js';
+export type { Acquired, CheckProvider, CheckRequest, Configured, EvidenceProvider, EvidenceRequest, PinOutcome, ProviderBinding, ProviderNotice, } from './hostBindings.js';
+export type { DecisionReason, PendingDecision, ResultDecision, Subject } from './state.js';
 export type { Citation } from './record.js';
 export type { InstanceView } from './view.js';
 export type { Restriction } from './policy.js';