@qvac/harness 1.0.0-rc.1 → 1.0.0-rc.2

package/dist-lib/lib/addon-seal.bare.d.ts

@@ -0,0 +1 @@
+export declare function sealAddons(): void;

package/dist-lib/lib/addon-seal.bare.js

@@ -0,0 +1,3 @@
+export function sealAddons() {
+    Bare.Addon.seal();
+}

package/dist-lib/lib/addon-seal.node.d.ts

@@ -0,0 +1 @@
+export declare function sealAddons(): void;

package/dist-lib/lib/addon-seal.node.js

@@ -0,0 +1 @@
+export function sealAddons() { }

package/dist-lib/lib/agent/delegate.d.ts

@@ -0,0 +1,83 @@
+import type { ToolDefinition, ToolExecuteContext } from '../contract/index.ts';
+import type { FollowEvent, FollowHost } from './follow.ts';
+export declare const DELEGATE_TOOL_NAME = "delegate";
+export interface DelegateRequest {
+    runId?: string;
+    parentRunId?: string;
+    cacheKey?: string;
+    signal?: ToolExecuteContext['signal'];
+    messages?: ReadonlyArray<{
+        role: string;
+        content: string;
+    }>;
+    tools?: ReadonlyArray<{
+        name: string;
+    }>;
+    agent?: {
+        handoffs?: unknown;
+        sandboxMode?: boolean | null;
+    };
+    resume?: unknown;
+    recovery?: unknown;
+    input?: unknown;
+    goal?: unknown;
+}
+export type TargetAccess = 'read' | 'write';
+export interface TargetTask {
+    prompt: string;
+    workdir: string;
+    access: TargetAccess;
+    runId: string | undefined;
+    parentRunId: string | undefined;
+    deadlineMs: number | undefined;
+    onEvent?: (event: TargetEvent) => void;
+}
+export interface TargetUsage {
+    inputTokens?: number;
+    outputTokens?: number;
+    costUsd?: number;
+    turns?: number;
+}
+export interface TargetEvent {
+    type: 'message' | 'thought' | 'tool' | 'permission' | 'usage' | 'end' | 'error';
+    [key: string]: unknown;
+}
+export interface TargetResult {
+    status: 'answered' | 'denied' | 'aborted' | 'budget' | 'error';
+    text: string;
+    usage?: TargetUsage;
+    transcript: TargetEvent[];
+}
+export interface DelegateTarget {
+    name: string;
+    description: string;
+    policyVersion?: string;
+    run(task: TargetTask, signal: AbortSignal): Promise<TargetResult>;
+}
+export interface DelegateOptions {
+    slots?: number;
+    targets?: readonly DelegateTarget[];
+    read?: readonly string[];
+    maxExternal?: number;
+}
+export interface LocalResult {
+    task: string;
+    status: 'answered' | 'paused' | 'aborted' | 'error';
+    text: string;
+}
+export interface ExternalResult {
+    task: string;
+    target: string;
+    status: TargetResult['status'];
+    text: string;
+    usage?: TargetUsage;
+}
+export type DelegateResult = LocalResult | ExternalResult;
+export interface ExternalRun {
+    index: number;
+    target: string;
+    runId: string | undefined;
+    parentRunId: string | undefined;
+    transcript: TargetEvent[];
+}
+export declare function createDelegateTool<Request extends DelegateRequest, Event extends FollowEvent>(host: FollowHost<Request, Event>, base: Request, { slots, targets, read, maxExternal }?: DelegateOptions): ToolDefinition;

package/dist-lib/lib/agent/delegate.js

@@ -0,0 +1,261 @@
+export const DELEGATE_TOOL_NAME = 'delegate';
+const LOCAL = 'local';
+const MAX_EXTERNAL = 2;
+const BRIEF = 'A subagent sees only its task and the summary, never this conversation, so put every fact ' +
+    'it needs in them.';
+const DESCRIPTION = `Hand narrow, independent read-only tasks to subagents and get each answer back. ${BRIEF}`;
+const EXTERNAL_DESCRIPTION = `Hand narrow, independent tasks to subagents and get each answer back. ${BRIEF}`;
+const SANDBOXED = 'external delegate targets are off in sandbox mode; use local subagents';
+const NO_WORKDIR = 'an external delegate target needs a local folder granted to the run, and it has none';
+export function createDelegateTool(host, base, { slots = 1, targets = [], read = [], maxExternal = MAX_EXTERNAL } = {}) {
+    const offered = base.agent?.sandboxMode === true ? [] : targets;
+    const roster = {
+        targets: new Map(offered.map((target) => [target.name, target])),
+        read: new Set(read)
+    };
+    const execute = async (args, ctx) => {
+        const { results, runs } = await fanOut(host, base, { ...roster, slots, maxExternal, args, ctx });
+        return runs.length ? { results, data: { runs } } : { results };
+    };
+    return offered.length ? externalTool(offered, roster, execute) : localTool(execute);
+}
+function localTool(execute) {
+    return {
+        name: DELEGATE_TOOL_NAME,
+        toolset: null,
+        description: DESCRIPTION,
+        parameters: {
+            type: 'object',
+            properties: {
+                tasks: {
+                    type: 'array',
+                    items: { type: 'string' },
+                    description: 'One self-contained task per subagent'
+                },
+                summary: { type: 'string', description: 'What every subagent needs to know, briefly' }
+            },
+            required: ['tasks']
+        },
+        autoApprove: true,
+        effect: () => 'read',
+        validate: (args) => Array.isArray(args.tasks) &&
+            args.tasks.length > 0 &&
+            args.tasks.every((task) => typeof task === 'string')
+            ? null
+            : 'tasks must be a non-empty array of strings',
+        execute
+    };
+}
+function externalTool(offered, roster, execute) {
+    return {
+        name: DELEGATE_TOOL_NAME,
+        toolset: null,
+        description: `${EXTERNAL_DESCRIPTION} Targets:\n- ${LOCAL}: a subagent on this model\n${offered
+            .map((target) => `- ${target.name}: ${target.description}`)
+            .join('\n')}`,
+        parameters: parameters(offered),
+        policyVersion: JSON.stringify([
+            offered.map((target) => [target.name, target.policyVersion ?? null]),
+            [...roster.read].sort()
+        ]),
+        autoApprove: false,
+        externalWrite: true,
+        effect: (args, ctx) => external(args, roster).some(({ target }) => ctx?.planMode || !roster.read.has(target))
+            ? 'write'
+            : 'read',
+        validate: (args, ctx) => validate(args, ctx, roster),
+        quote: (args, ctx) => {
+            const lines = external(args, roster).map(({ task, target }) => `${target} in ${workdir(ctx, access(target, roster)) ?? '?'}: ${task}`);
+            return lines.length ? lines.join('\n') : null;
+        },
+        execute
+    };
+}
+function parameters(targets) {
+    return {
+        type: 'object',
+        properties: {
+            tasks: {
+                type: 'array',
+                items: {
+                    type: 'object',
+                    properties: {
+                        task: { type: 'string', description: 'One self-contained task' },
+                        target: {
+                            type: 'string',
+                            enum: [LOCAL, ...targets.map((target) => target.name)],
+                            description: `Who runs it; absent, ${LOCAL}`
+                        }
+                    },
+                    required: ['task']
+                },
+                description: 'One task per subagent'
+            },
+            summary: { type: 'string', description: 'What every subagent needs to know, briefly' }
+        },
+        required: ['tasks']
+    };
+}
+function tasksOf(args) {
+    const tasks = Array.isArray(args.tasks) ? args.tasks : [];
+    return tasks.map((item) => typeof item === 'string'
+        ? { task: item, target: LOCAL }
+        : { task: String(Object(item).task), target: String(Object(item).target ?? LOCAL) });
+}
+function external(args, roster) {
+    return tasksOf(args).filter(({ target }) => roster.targets.has(target));
+}
+function validate(args, ctx, roster) {
+    const tasks = Array.isArray(args.tasks) ? args.tasks : [];
+    const valid = (item) => typeof item === 'string' ||
+        (typeof Object(item).task === 'string' &&
+            (Object(item).target === undefined ||
+                Object(item).target === LOCAL ||
+                roster.targets.has(Object(item).target)));
+    if (tasks.length === 0 || !tasks.every(valid)) {
+        return `tasks must be a non-empty array, each a string or { task, target } with target one of ${[
+            LOCAL,
+            ...roster.targets.keys()
+        ].join(', ')}`;
+    }
+    const outside = external(args, roster);
+    if (outside.length && ctx?.sandboxMode) {
+        return SANDBOXED;
+    }
+    return outside.some(({ target }) => !workdir(ctx, access(target, roster))) ? NO_WORKDIR : null;
+}
+function access(target, roster) {
+    return roster.read.has(target) ? 'read' : 'write';
+}
+function workdir(ctx, mode) {
+    const writable = (ctx?.fsWriteRoots ?? []).filter((root) => root.kind === 'local');
+    if (mode === 'write') {
+        return writable.length === 1 ? writable[0].root : null;
+    }
+    const readable = [...writable, ...(ctx?.fsRoots ?? []).filter((root) => root.kind === 'local')];
+    return readable[0]?.root ?? null;
+}
+async function fanOut(host, base, { slots, maxExternal, args, ctx, ...roster }) {
+    const tasks = tasksOf(args);
+    const summary = typeof args.summary === 'string' ? args.summary : '';
+    const fanned = { results: new Array(tasks.length), runs: [] };
+    const local = tasks.flatMap(({ target }, index) => (roster.targets.has(target) ? [] : [index]));
+    const outside = tasks.flatMap(({ target }, index) => {
+        const found = roster.targets.get(target);
+        return found ? [{ index, target: found }] : [];
+    });
+    await Promise.all([
+        pool(local, slots, async (index) => {
+            const { task } = tasks[index];
+            fanned.results[index] = await subagent(host, task, child(base, ctx, { task, summary, index }));
+        }),
+        pool(outside, maxExternal, async ({ index, target }) => {
+            const { task } = tasks[index];
+            const { runId, parentRunId } = child(base, ctx, { task, summary, index });
+            const mode = access(target.name, roster);
+            const ran = await runTarget(target, ctx, {
+                prompt: summary ? `${summary}\n\n${task}` : task,
+                workdir: workdir(ctx, mode) ?? '',
+                access: mode,
+                runId,
+                parentRunId,
+                deadlineMs: ctx?.runBudget?.deadlineMs
+            });
+            const { status, text, usage, transcript } = ran;
+            fanned.results[index] = { task, target: target.name, status, text, usage };
+            fanned.runs.push({ index, target: target.name, runId, parentRunId, transcript });
+        })
+    ]);
+    fanned.runs.sort((a, b) => a.index - b.index);
+    return fanned;
+}
+async function pool(items, width, run) {
+    let next = 0;
+    const worker = async () => {
+        while (next < items.length) {
+            await run(items[next++]);
+        }
+    };
+    await Promise.all(Array.from({ length: Math.max(1, Math.min(width, items.length)) }, worker));
+}
+async function runTarget(target, ctx, task) {
+    const parent = ctx?.signal;
+    if (parent?.aborted) {
+        return { status: 'aborted', text: '', transcript: [] };
+    }
+    if (task.deadlineMs !== undefined && task.deadlineMs <= Date.now()) {
+        return { status: 'budget', text: '', transcript: [] };
+    }
+    const controller = new AbortController();
+    const onAbort = () => controller.abort();
+    const deadline = deadlineTimer(task.deadlineMs, controller);
+    parent?.addEventListener('abort', onAbort);
+    const settled = (result) => {
+        if (deadline.passed) {
+            return { ...result, status: 'budget' };
+        }
+        return parent?.aborted ? { ...result, status: 'aborted' } : result;
+    };
+    try {
+        return settled(await target.run(task, controller.signal));
+    }
+    catch (error) {
+        return settled({
+            status: 'error',
+            text: String(Reflect.get(Object(error), 'message') ?? error),
+            transcript: []
+        });
+    }
+    finally {
+        deadline.clear();
+        parent?.removeEventListener('abort', onAbort);
+    }
+}
+function deadlineTimer(deadlineMs, controller) {
+    const deadline = { passed: false, clear: () => { } };
+    if (deadlineMs === undefined) {
+        return deadline;
+    }
+    const timer = setTimeout(() => {
+        deadline.passed = true;
+        controller.abort();
+    }, Math.max(0, deadlineMs - Date.now()));
+    deadline.clear = () => clearTimeout(timer);
+    return deadline;
+}
+function child(base, ctx, { task, summary, index }) {
+    const parent = ctx?.runId ?? base.runId;
+    const run = {
+        ...base,
+        runId: parent === undefined ? undefined : `${parent}/d-${ctx?.callId ?? 0}-${index}`,
+        parentRunId: parent,
+        signal: ctx?.signal ?? base.signal,
+        cacheKey: base.cacheKey === undefined ? undefined : `${base.cacheKey}/d`,
+        messages: [{ role: 'user', content: summary ? `${summary}\n\n${task}` : task }],
+        tools: base.tools?.filter((tool) => tool.name !== DELEGATE_TOOL_NAME),
+        agent: base.agent && { ...base.agent, handoffs: null }
+    };
+    delete run.resume;
+    delete run.recovery;
+    delete run.input;
+    delete run.goal;
+    return run;
+}
+async function subagent(host, task, request) {
+    let text = '';
+    let status = 'answered';
+    for await (const event of host.completion(request)) {
+        const { type } = event;
+        if (type === 'content') {
+            text += String(Object(event).text ?? '');
+        }
+        else if (type === 'error') {
+            status = type;
+            text = String(Object(event).message ?? '');
+        }
+        else if (type === 'paused' || type === 'aborted') {
+            status = type;
+        }
+    }
+    return { task, status, text };
+}

package/dist-lib/lib/agent/follow.d.ts

@@ -0,0 +1,32 @@
+import type { AgentHandoff, RunInput, TransferEvent } from '../contract/index.ts';
+export declare const MAX_TRANSFERS = 3;
+export interface FollowAgent {
+    id?: string;
+    handoffs?: AgentHandoff[] | null;
+}
+export interface FollowRequest {
+    runId?: string;
+    resume?: boolean;
+    recovery?: unknown;
+    agent?: FollowAgent;
+    agents?: Readonly<Record<string, FollowAgent>>;
+    messages?: ReadonlyArray<{
+        role: string;
+        content: string;
+    }>;
+    cacheKey?: string;
+    input?: AsyncIterable<RunInput>;
+}
+export interface FollowEvent {
+    type: string;
+    runId?: unknown;
+    name?: unknown;
+    result?: unknown;
+    id?: unknown;
+    text?: unknown;
+}
+export interface FollowHost<Request, Event> {
+    completion(request: Request): AsyncIterable<Event>;
+}
+export declare function follow<Request extends FollowRequest, Event extends FollowEvent>(host: FollowHost<Request, Event>, request: Request): AsyncGenerator<Event | TransferEvent>;
+export declare function untransferred(text: string): string;

package/dist-lib/lib/agent/follow.js

@@ -0,0 +1,162 @@
+import { pushQueue } from '../queue.js';
+import { TRANSFER_TOOL_NAME } from './transfer.js';
+export const MAX_TRANSFERS = 3;
+export function follow(host, request) {
+    const agents = request.agents ?? {};
+    const entry = checkRoster(request.agent, agents);
+    if (!request.messages) {
+        throw new TypeError('A run that follows handoffs needs its messages to hand them on');
+    }
+    const resumed = request.resume ? resumedHop(request.runId ?? '', agents) : null;
+    const first = resumed ?? { index: 0, id: entry, root: request.runId };
+    return hops(host, request, { ...first, note: null, resume: request.resume === true });
+}
+async function* hops(host, request, first) {
+    const hop = { ...first };
+    const inputs = request.input ? hopInputs(request.input) : null;
+    try {
+        for (;;) {
+            const transfer = yield* runHop(host, { request, hop, inputs });
+            if (!transfer || hop.index === MAX_TRANSFERS) {
+                return;
+            }
+            yield { type: 'transfer', from: hop.id, to: transfer.transferred, reason: transfer.reason };
+            hop.note = `[Transferred from ${hop.id}: ${transfer.reason}]`;
+            hop.id = transfer.transferred;
+            hop.index++;
+            hop.resume = false;
+        }
+    }
+    finally {
+        inputs?.stop();
+    }
+}
+async function* runHop(host, { request, hop, inputs }) {
+    const queue = inputs?.open() ?? null;
+    let transfer = null;
+    try {
+        for await (const event of host.completion(hopRequest(request, hop, queue))) {
+            hop.root ??= typeof event.runId === 'string' ? event.runId : undefined;
+            if (event.type === 'tool-result' && event.name === TRANSFER_TOOL_NAME) {
+                transfer = isTransfer(event.result) ? event.result : null;
+            }
+            else if (STOPPED.has(event.type)) {
+                transfer = null;
+            }
+            else if (event.type === 'input') {
+                inputs?.ack(event.id ?? event.text);
+            }
+            yield { ...event, agent: hop.id };
+        }
+    }
+    finally {
+        queue?.end();
+    }
+    return transfer;
+}
+function hopInputs(input) {
+    const unacked = [];
+    let queue = null;
+    let stopped = false;
+    readInput(input, (item) => {
+        if (!stopped) {
+            unacked.push(item);
+            queue?.push(item);
+        }
+        return !stopped;
+    }).catch(noop);
+    return {
+        open() {
+            queue = pushQueue();
+            for (const item of unacked) {
+                queue.push(item);
+            }
+            return queue;
+        },
+        ack(key) {
+            const at = unacked.findIndex((item) => (item.id ?? item.text) === key);
+            if (at !== -1) {
+                unacked.splice(at, 1);
+            }
+        },
+        stop() {
+            stopped = true;
+        }
+    };
+}
+async function readInput(input, take) {
+    const iterator = input[Symbol.asyncIterator]();
+    for (;;) {
+        const next = await iterator.next();
+        if (next.done || !take(next.value)) {
+            return;
+        }
+    }
+}
+function noop() { }
+function hopRequest(request, hop, input) {
+    const run = {
+        ...request,
+        agent: hop.index === 0 ? request.agent : hopAgent(request.agents ?? {}, hop.id, hop.index),
+        resume: hop.resume,
+        runId: hop.index === 0 ? request.runId : `${hop.root}/${hop.index}-${hop.id}`,
+        cacheKey: request.cacheKey === undefined ? undefined : `${request.cacheKey}/a-${hop.id}`,
+        messages: hop.note === null ? request.messages : noted(request.messages ?? [], hop.note)
+    };
+    delete run.agents;
+    if (input) {
+        run.input = input;
+    }
+    else {
+        delete run.input;
+    }
+    if (!hop.resume) {
+        delete run.recovery;
+    }
+    if (hop.resume && hop.index > 0) {
+        delete run.messages;
+    }
+    return run;
+}
+const STOPPED = new Set(['paused', 'aborted', 'error']);
+function hopAgent(agents, id, index) {
+    const member = agents[id];
+    return { ...member, id, handoffs: index === MAX_TRANSFERS ? null : member.handoffs };
+}
+function checkRoster(entry, agents) {
+    if (!entry?.id) {
+        throw new TypeError('A run that follows handoffs needs an entry agent with an id');
+    }
+    const reached = new Set();
+    const queue = [entry];
+    for (const agent of queue) {
+        for (const { id } of agent.handoffs ?? []) {
+            if (reached.has(id))
+                continue;
+            if (!agents[id]) {
+                throw new TypeError(`Agent ${agent.id} hands to ${id}, which agents does not list`);
+            }
+            reached.add(id);
+            queue.push({ ...agents[id], id });
+        }
+    }
+    return entry.id;
+}
+function resumedHop(runId, agents) {
+    const match = /^(.+)\/(\d+)-([^/]+)$/.exec(runId);
+    return match && agents[match[3]]
+        ? { index: Number(match[2]), id: match[3], root: match[1] }
+        : null;
+}
+const TRANSFER_NOTE = /\n\n\[Transferred from [^\]\n]*: [^\n]*\]$/;
+export function untransferred(text) {
+    return text.replace(TRANSFER_NOTE, '');
+}
+function noted(messages, note) {
+    const last = messages.findLastIndex((message) => message.role === 'user');
+    return messages.map((message, index) => index === last ? { ...message, content: `${message.content}\n\n${note}` } : message);
+}
+function isTransfer(value) {
+    const { transferred, reason } = Object(value);
+    return typeof transferred === 'string' && typeof reason === 'string';
+}

package/dist-lib/lib/agent/index.d.ts

@@ -0,0 +1,37 @@
+import type { AgentConfig, AgentPolicy, AgentPorts, AgentRequest, AgentSkill, ResolvedAgent } from '../contract/index.ts';
+import { createDelegateTool } from './delegate.ts';
+import { follow, untransferred } from './follow.ts';
+import { agentPolicy, resolveAgent } from './resolve.ts';
+import { planFromMessages, planSteps } from './plan.ts';
+import { parseToolGrant } from './tool-grants.ts';
+import { collectToolGrants, enabledTools, permittedTools, skillIsActive } from './tool-selection.ts';
+export declare class Agent<Skill extends AgentSkill = AgentSkill> {
+    static SKILL_TOOL_NAME: string;
+    static WEB_SEARCH_TOOL_NAME: string;
+    static TRANSFER_TOOL_NAME: string;
+    static DELEGATE_TOOL_NAME: string;
+    static PLAN_TOOL_NAME: string;
+    static MAX_PLAN_STEPS: number;
+    static NETWORK_TOOLSETS: readonly import("../contract/completion.ts").Toolset[];
+    static MAX_TRANSFERS: number;
+    static resolve: typeof resolveAgent;
+    static policy: typeof agentPolicy;
+    static parseToolGrant: typeof parseToolGrant;
+    static enabledTools: typeof enabledTools;
+    static permittedTools: typeof permittedTools;
+    static collectToolGrants: typeof collectToolGrants;
+    static skillIsActive: typeof skillIsActive;
+    static follow: typeof follow;
+    static delegateTool: typeof createDelegateTool;
+    static untransferred: typeof untransferred;
+    static planSteps: typeof planSteps;
+    static planFromMessages: typeof planFromMessages;
+    config: AgentConfig | undefined;
+    ports: AgentPorts<Skill>;
+    constructor(config: AgentConfig | undefined, ports: AgentPorts<Skill>);
+    resolve(request: Omit<AgentRequest<Skill>, 'agent'>): ResolvedAgent<Skill>;
+    policy(): AgentPolicy;
+}
+export type { DelegateOptions, DelegateRequest, DelegateResult, DelegateTarget, ExternalResult, ExternalRun, LocalResult, TargetAccess, TargetEvent, TargetResult, TargetTask, TargetUsage } from './delegate.ts';
+export type { FollowAgent, FollowEvent, FollowHost, FollowRequest } from './follow.ts';
+export type { TransferResult } from './transfer.ts';

package/dist-lib/lib/agent/index.js

@@ -0,0 +1,42 @@
+import { createDelegateTool, DELEGATE_TOOL_NAME } from './delegate.js';
+import { follow, MAX_TRANSFERS, untransferred } from './follow.js';
+import { agentPolicy, resolveAgent } from './resolve.js';
+import { MAX_PLAN_STEPS, PLAN_TOOL_NAME, planFromMessages, planSteps } from './plan.js';
+import { parseToolGrant } from './tool-grants.js';
+import { SKILL_TOOL_NAME, WEB_SEARCH_TOOL_NAME } from './tool-names.js';
+import { collectToolGrants, enabledTools, NETWORK_TOOLSETS, permittedTools, skillIsActive } from './tool-selection.js';
+import { TRANSFER_TOOL_NAME } from './transfer.js';
+export class Agent {
+    static SKILL_TOOL_NAME = SKILL_TOOL_NAME;
+    static WEB_SEARCH_TOOL_NAME = WEB_SEARCH_TOOL_NAME;
+    static TRANSFER_TOOL_NAME = TRANSFER_TOOL_NAME;
+    static DELEGATE_TOOL_NAME = DELEGATE_TOOL_NAME;
+    static PLAN_TOOL_NAME = PLAN_TOOL_NAME;
+    static MAX_PLAN_STEPS = MAX_PLAN_STEPS;
+    static NETWORK_TOOLSETS = NETWORK_TOOLSETS;
+    static MAX_TRANSFERS = MAX_TRANSFERS;
+    static resolve = resolveAgent;
+    static policy = agentPolicy;
+    static parseToolGrant = parseToolGrant;
+    static enabledTools = enabledTools;
+    static permittedTools = permittedTools;
+    static collectToolGrants = collectToolGrants;
+    static skillIsActive = skillIsActive;
+    static follow = follow;
+    static delegateTool = createDelegateTool;
+    static untransferred = untransferred;
+    static planSteps = planSteps;
+    static planFromMessages = planFromMessages;
+    config;
+    ports;
+    constructor(config, ports) {
+        this.config = config;
+        this.ports = ports;
+    }
+    resolve(request) {
+        return resolveAgent({ ...request, agent: this.config }, this.ports);
+    }
+    policy() {
+        return agentPolicy(this.config);
+    }
+}

package/dist-lib/lib/agent/plan.d.ts

@@ -0,0 +1,6 @@
+import type { Message, PlanStep, ToolDefinition } from '../contract/index.ts';
+export declare const PLAN_TOOL_NAME = "update_plan";
+export declare const MAX_PLAN_STEPS = 12;
+export declare function planSteps(args: Record<string, unknown>): PlanStep[];
+export declare function planFromMessages(messages: readonly Message[]): PlanStep[];
+export declare function createPlanTool(): ToolDefinition;