@leuduan/lagent 0.0.0-stage → 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

@@ -0,0 +1,93 @@
+import { Service, type Context } from '@leuduan/cordis';
+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). */
+        verify: VerifyService;
+    }
+}
+/**
+ * The constraint owner a thread owing verification requires (`requires` in its creation, its own
+ * or a thread's above it by origin): while the `verify` service is not mounted, the thread is held
+ * `missing`, and a judgment made without this registration does not end its turn (core's fence on
+ * required registrations).
+ */
+export declare const VERIFY_OWNER = "lagent:verify";
+/** The verification one assignment owes, as its owner records it with {@link VerifyService.owed}. */
+export type OwedVerification = {
+    /** The owner that schedules the assignment, as an assignment origin names it. */
+    readonly owner: string;
+    /** The assignment's id. */
+    readonly assignment: string;
+    /** The participant generation serving it. */
+    readonly generation: number;
+    /** The input whose claim activates the assignment, which arms the requirement. */
+    readonly inputId: string;
+    /** The pinned command runtime executes when completion needs proof. */
+    readonly command: string;
+    /** The absolute directory it must run in. */
+    readonly cwd: string;
+};
+/**
+ * Verification, the one judge of every thread's answers on it. Two things put a verification in
+ * force on a thread: a gate the verify preset mounts there ({@link gate}), which demands a pass
+ * after the last change; and the requirement an owner recorded for the assignment the thread
+ * serves ({@link owed}), armed when the assignment's input is claimed, which demands a pass after
+ * 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 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
+ * otherwise from the catalog, which the service contributes every thread's changes to.
+ *
+ * It registers {@link VERIFY_OWNER}: a thread owing verification requires it, so while the service
+ * is not mounted the thread is held rather than its answer accepted unchecked.
+ */
+export declare class VerifyService extends Service {
+    static inject: string[];
+    /** The gates mounted now, by thread: each mount's verification. */
+    private readonly gates;
+    constructor(ctx: Context);
+    /**
+     * Puts `verification` in force on `threadId` until the returned function is called: what the
+     * verify preset's setup does for the thread it serves, for as long as it is mounted.
+     */
+    gate(threadId: string, verification: Verification): () => void;
+    /**
+     * The rows recording `requirement` on the thread a write schedules its assignment on, for that
+     * write's `rows`. Decided inside the write, refused: unless the thread requires
+     * {@link VERIFY_OWNER}, by its own creation or a thread's above it by origin, so its run is held
+     * while this service is missing; when a verify preset installed on the thread, or a gate mounted
+     * there now, names another verification, which the two would demand in turn and never both pass;
+     * and for one recorded under the same assignment and generation differently. None for one
+     * recorded already exactly so: a replay renews nothing.
+     */
+    owed(requirement: OwedVerification): WriteRows;
+    /**
+     * The thread's say on its answer: every verification in force on it, each judged once, a gate's
+     * on the same verification as the requirement judged with the requirement's arming. Any rejection
+     * wins, then the first continuation. It declares what the say rests on (`observed`) whichever it
+     * is, an abstention too, so a change while another check awaited sends the answer to be judged again.
+     */
+    private judge;
+    /**
+     * What a verdict on the thread rests on, as one token: each verification in force with its arming
+     * 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.
+     */
+    private reading;
+    /** The verifications the thread is configured with: its installed verify presets, and the gates mounted on it now. */
+    private inPlace;
+    /** Whether the thread, or one above it by origin, requires {@link VERIFY_OWNER}; its opening when the write opens it. */
+    private required;
+}

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/html.d.ts

@@ -0,0 +1,23 @@
+/**
+ * HTML to readable plain text in one linear pass, with no DOM and no dependency.
+ *
+ * The text is the page's content region when it marks one — `<main>` or `role="main"`, else its
+ * only top-level `<article>` — and the whole document otherwise. What a reader would not read is
+ * dropped: scripts and styles, navigation, form controls, page banners, footers and sidebars outside
+ * the content, and hidden elements. Paragraphs, list items, table rows and preformatted text keep
+ * their shape.
+ *
+ * The parser is forgiving rather than spec-complete: a close tag pops back to its nearest open
+ * match, a few elements close an open sibling, and an element left open ends with its parent.
+ */
+export type HtmlLink = {
+    text: string;
+    href: string;
+};
+export type HtmlText = {
+    title: string | null;
+    text: string;
+    /** The links in `text`, in document order, with `href` as written. */
+    links: HtmlLink[];
+};
+export declare function htmlToText(html: string): HtmlText;

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/webTools/network.d.ts

@@ -0,0 +1,23 @@
+import type { LookupAddress, LookupAllOptions } from 'node:dns';
+import { type LookupFunction } from 'node:net';
+/** What a refused address is, for the message that names it. */
+type AddressKind = string;
+/**
+ * Why an IP address is not on the public internet, or `null` when it is. A zone index (`%eth0`) is
+ * ignored; anything that is not an IP address is `null`, for the resolver to judge.
+ */
+export declare function privateAddressKind(address: string): AddressKind | null;
+/** Refuses a fetch that would reach a private address, naming the host and what the address is. */
+export declare class PrivateAddressError extends Error {
+    readonly name = "PrivateAddressError";
+    constructor(host: string, address: string, kind: AddressKind);
+}
+/** Resolves every address of a host, as `dns.lookup` does with `all: true`. */
+export type ResolveAll = (hostname: string, options: LookupAllOptions, callback: (error: NodeJS.ErrnoException | null, addresses: LookupAddress[]) => void) => void;
+/**
+ * A socket `lookup` that resolves every address of the host and refuses the connection when any of
+ * them is private, so a mixed answer cannot pick its way past the check. The socket connects to an
+ * address checked here; TLS still verifies the certificate against the host name.
+ */
+export declare const refusingLookup: (resolveAll: ResolveAll) => LookupFunction;
+export {};

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

@@ -0,0 +1,32 @@
+import { z } from 'zod';
+/**
+ * What web_fetch may reach: `refuse` keeps it on the public internet, refusing a host that is, or
+ * resolves to, a loopback, link-local, private, unique-local, CGNAT, unspecified, multicast or
+ * reserved address, in any of its IPv6 forms; `allow` reaches whatever the host can.
+ */
+export type PrivateNetwork = 'allow' | 'refuse';
+/** web_fetch, reaching what {@link PrivateNetwork} allows. */
+export declare const webFetchTool: (privateNetwork: PrivateNetwork) => import("../../plugin.js").Tool;
+/**
+ * What `web_search` runs on: the Codex login it searches through (`authPath`, with the refresh
+ * deadline every client of that login shares), the model the endpoint requires, and how much one
+ * search may return (`maxOutputTokens` bounds the text, `responseLength` the number of results).
+ */
+export declare const WebSearchConfigSchema: 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>;
+export type WebSearchConfig = z.output<typeof WebSearchConfigSchema>;
+/**
+ * web_search, through Codex's search endpoint over the Codex login. The server's text is returned as
+ * it is: each result's title and URL, its age and an excerpt. `results`, the same list as data, is
+ * kept for the host in `metadata`, opaque, and `null` when the server sent none.
+ */
+export declare const webSearchTool: (config: WebSearchConfig) => import("../../plugin.js").Tool;

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

@@ -0,0 +1,20 @@
+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),
+ * at rank 2, after the rank-1 notices of what is in force (sandbox, verification, permission mode):
+ * to its root, its assignment, with everything needed to work it, or the decision, block or cleanup
+ * it waits on; to an isolated participant's child, its own assignment. Contributed only when no
+ * notice the thread can still see says the same: at the step that claims the assignment's activation
+ * input, and again after compaction or a replacement took it away; a contribution never wakes the
+ * thread. An instance that ended is told so to its root once, and only while an earlier presentation
+ * that restricted it is still visible. Notice visibility decides what is told, never authority,
+ * which the activation's claim alone gives.
+ */
+export declare function presentAssignments(ctx: Context, governance: Governance): void;
+/**
+ * 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;