@parcha/agentrun-pi 0.1.0-beta.2 → 0.1.0-beta.21

package/dist/workflow-store.d.ts

@@ -0,0 +1,36 @@
+import { type Workflow } from '@parcha/agentrun-dsl';
+export interface WorkflowRevision {
+    name: string;
+    digest: string;
+    createdAt: string;
+    workflowName: string;
+}
+export interface StoredWorkflow extends WorkflowRevision {
+    workflow: Workflow;
+}
+export declare class WorkflowStoreError extends Error {
+    readonly code: 'invalid_name' | 'invalid_revision' | 'invalid_workflow' | 'unsafe_path' | 'not_found' | 'invalid_record' | 'ambiguous_revision';
+    constructor(code: 'invalid_name' | 'invalid_revision' | 'invalid_workflow' | 'unsafe_path' | 'not_found' | 'invalid_record' | 'ambiguous_revision', message: string);
+}
+/** Local procedure revisions, not execution state or authority. The host still
+ * preflights loaded workflows against current capabilities and approves each run.
+ * This is not a sandbox against a process concurrently replacing project directories.
+ *
+ * Public through `@parcha/agentrun-pi/workflows`. The constructor takes a project directory, never the
+ * workflows directory itself: records live in `<projectDirectory>/.pi/agentrun/workflows/<name>/`, the same
+ * place the extension keeps them for its `ctx.cwd`, so the extension and a host that passes that directory
+ * read each other's records. The directory is resolved once when it is used; everything under it must be
+ * real directories and regular files.
+ */
+export declare class WorkflowStore {
+    private readonly projectDirectory;
+    constructor(projectDirectory: string);
+    private directory;
+    private read;
+    private latest;
+    /** All revisions, newest first; the active revision leads within a timestamp tie. */
+    list(): Promise<WorkflowRevision[]>;
+    load(name: string, digest?: string): Promise<StoredWorkflow>;
+    /** Publish a complete immutable revision atomically; identical saves are idempotent. */
+    save(name: string, value: unknown): Promise<StoredWorkflow>;
+}

package/dist/workflow-store.js

@@ -0,0 +1,255 @@
+import { constants } from 'node:fs';
+import { link, lstat, mkdir, open, readdir, realpath, rename, unlink } from 'node:fs/promises';
+import { randomUUID } from 'node:crypto';
+import { join, resolve } from 'node:path';
+import { inspectWorkflow, validateWorkflow } from '@parcha/agentrun-dsl';
+export class WorkflowStoreError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+        this.name = 'WorkflowStoreError';
+    }
+}
+const assertValidName = (name) => {
+    if (typeof name !== 'string' || !/^[a-z0-9][a-z0-9_-]{0,63}$/.test(name))
+        throw new WorkflowStoreError('invalid_name', 'Use a workflow name of 1–64 lowercase letters, digits, hyphens or underscores, starting with a letter or digit.');
+};
+const assertValidDigest = (digest) => {
+    if (typeof digest !== 'string' || !/^[a-f0-9]{64}$/.test(digest))
+        throw new WorkflowStoreError('invalid_revision', 'A workflow revision must be its complete SHA-256 digest.');
+};
+const missing = (error) => error?.code === 'ENOENT';
+const unsafe = () => new WorkflowStoreError('unsafe_path', 'Workflow storage requires real directories and regular files, without symbolic links.');
+function checkedWorkflow(value) {
+    try {
+        // Inspection rejects non-JSON values before cloning. Neither check executes code.
+        const inspection = inspectWorkflow(value);
+        const workflow = structuredClone(value);
+        const validation = validateWorkflow(workflow, { executeCode: false });
+        if (!validation.ok)
+            throw new Error('invalid workflow');
+        return { workflow, digest: inspection.sha256 };
+    }
+    catch {
+        throw new WorkflowStoreError('invalid_workflow', 'Workflow failed nonexecuting structure, syntax or schema validation. Inspect it before saving.');
+    }
+}
+/** Local procedure revisions, not execution state or authority. The host still
+ * preflights loaded workflows against current capabilities and approves each run.
+ * This is not a sandbox against a process concurrently replacing project directories.
+ *
+ * Public through `@parcha/agentrun-pi/workflows`. The constructor takes a project directory, never the
+ * workflows directory itself: records live in `<projectDirectory>/.pi/agentrun/workflows/<name>/`, the same
+ * place the extension keeps them for its `ctx.cwd`, so the extension and a host that passes that directory
+ * read each other's records. The directory is resolved once when it is used; everything under it must be
+ * real directories and regular files.
+ */
+export class WorkflowStore {
+    projectDirectory;
+    constructor(projectDirectory) { this.projectDirectory = resolve(projectDirectory); }
+    async directory(name, create = false) {
+        if (name !== undefined)
+            assertValidName(name);
+        let directory = await realpath(this.projectDirectory);
+        for (const component of ['.pi', 'agentrun', 'workflows', ...(name === undefined ? [] : [name])]) {
+            directory = join(directory, component);
+            if (create) {
+                try {
+                    await mkdir(directory, { mode: 0o700 });
+                }
+                catch (error) {
+                    if (error.code !== 'EEXIST')
+                        throw error;
+                }
+            }
+            let stat;
+            try {
+                stat = await lstat(directory);
+            }
+            catch (error) {
+                if (missing(error) && !create)
+                    return undefined;
+                throw error;
+            }
+            if (!stat.isDirectory() || stat.isSymbolicLink() || await realpath(directory) !== directory)
+                throw unsafe();
+        }
+        return directory;
+    }
+    async read(name, digest) {
+        assertValidName(name);
+        assertValidDigest(digest);
+        const directory = await this.directory(name);
+        if (!directory)
+            throw new WorkflowStoreError('not_found', 'Saved workflow revision not found.');
+        const path = join(directory, `${digest}.json`);
+        let handle;
+        try {
+            handle = await open(path, constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK);
+        }
+        catch (error) {
+            if (missing(error))
+                throw new WorkflowStoreError('not_found', 'Saved workflow revision not found.');
+            if (error.code === 'ELOOP')
+                throw unsafe();
+            throw error;
+        }
+        let value;
+        try {
+            if (!(await handle.stat()).isFile() || await realpath(path) !== path)
+                throw unsafe();
+            try {
+                value = JSON.parse(await handle.readFile('utf8'));
+            }
+            catch {
+                throw new WorkflowStoreError('invalid_record', 'Saved workflow record is not valid JSON.');
+            }
+        }
+        finally {
+            await handle.close();
+        }
+        if (!value || typeof value !== 'object' || Array.isArray(value)
+            || Object.keys(value).sort().join(',') !== 'createdAt,digest,name,version,workflow'
+            || value.version !== 1 || value.name !== name || value.digest !== digest
+            || typeof value.createdAt !== 'string' || !/^\d{4}-\d\d-\d\dT\d\d:\d\d:\d\d\.\d{3}Z$/.test(value.createdAt)
+            || !Number.isFinite(Date.parse(value.createdAt)) || new Date(value.createdAt).toISOString() !== value.createdAt)
+            throw new WorkflowStoreError('invalid_record', 'Saved workflow metadata does not match its revision.');
+        const checked = checkedWorkflow(value.workflow);
+        if (checked.digest !== digest)
+            throw new WorkflowStoreError('invalid_record', 'Saved workflow content does not match its digest.');
+        return { name, digest, createdAt: value.createdAt, workflowName: checked.workflow.name, workflow: checked.workflow };
+    }
+    async latest(name) {
+        const directory = await this.directory(name);
+        if (!directory)
+            return undefined;
+        const path = join(directory, 'latest');
+        let handle;
+        try {
+            handle = await open(path, constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK);
+        }
+        catch (error) {
+            if (missing(error))
+                return undefined;
+            if (error.code === 'ELOOP')
+                throw unsafe();
+            throw error;
+        }
+        try {
+            const stat = await handle.stat();
+            if (!stat.isFile() || await realpath(path) !== path)
+                throw unsafe();
+            if (stat.size !== 65)
+                throw new WorkflowStoreError('invalid_record', 'Saved workflow latest revision is invalid.');
+            const value = await handle.readFile('utf8');
+            if (!/^[a-f0-9]{64}\n$/.test(value))
+                throw new WorkflowStoreError('invalid_record', 'Saved workflow latest revision is invalid.');
+            return value.slice(0, -1);
+        }
+        finally {
+            await handle.close();
+        }
+    }
+    /** All revisions, newest first; the active revision leads within a timestamp tie. */
+    async list() {
+        const directory = await this.directory();
+        if (!directory)
+            return [];
+        const revisions = [];
+        const latest = new Map();
+        for (const name of await readdir(directory)) {
+            assertValidName(name);
+            const child = await this.directory(name);
+            if (!child)
+                continue;
+            const active = await this.latest(name);
+            if (active)
+                latest.set(name, active);
+            for (const file of await readdir(child)) {
+                // Unpublished files survive an interrupted write and never become revisions.
+                if (/^\.pending-[a-f0-9-]+$/.test(file) || file === 'latest')
+                    continue;
+                if (!/^[a-f0-9]{64}\.json$/.test(file))
+                    throw new WorkflowStoreError('invalid_record', 'Unexpected file in workflow revision storage.');
+                const { workflow: _workflow, ...revision } = await this.read(name, file.slice(0, -5));
+                revisions.push(revision);
+            }
+        }
+        return revisions.sort((a, b) => b.createdAt.localeCompare(a.createdAt) || a.name.localeCompare(b.name)
+            || Number(b.digest === latest.get(b.name)) - Number(a.digest === latest.get(a.name)) || a.digest.localeCompare(b.digest));
+    }
+    async load(name, digest) {
+        assertValidName(name);
+        if (digest !== undefined)
+            return this.read(name, digest);
+        const latest = await this.latest(name);
+        if (latest)
+            return this.read(name, latest);
+        // Revisions saved before the latest pointer was introduced remain readable.
+        const revisions = (await this.list()).filter(item => item.name === name);
+        const revision = revisions[0];
+        if (!revision)
+            throw new WorkflowStoreError('not_found', 'Saved workflow not found.');
+        if (revisions[1]?.createdAt === revision.createdAt)
+            throw new WorkflowStoreError('ambiguous_revision', 'Saved workflow revisions share a timestamp. Load by complete digest or save the intended revision again.');
+        return this.read(name, revision.digest);
+    }
+    /** Publish a complete immutable revision atomically; identical saves are idempotent. */
+    async save(name, value) {
+        assertValidName(name);
+        const { workflow, digest } = checkedWorkflow(value);
+        const directory = (await this.directory(name, true));
+        const temporary = join(directory, `.pending-${randomUUID()}`);
+        const target = join(directory, `${digest}.json`);
+        const handle = await open(temporary, constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL | constants.O_NOFOLLOW, 0o600);
+        try {
+            await handle.writeFile(JSON.stringify({ version: 1, name, digest, createdAt: new Date().toISOString(), workflow }, null, 2) + '\n');
+            await handle.sync();
+        }
+        finally {
+            await handle.close();
+        }
+        // Hard-link publication is atomic and, unlike rename, never overwrites a revision.
+        if (await this.directory(name) !== directory)
+            throw unsafe();
+        try {
+            await link(temporary, target);
+        }
+        catch (error) {
+            if (error.code !== 'EEXIST')
+                throw error;
+        }
+        const saved = await this.read(name, digest);
+        await unlink(temporary);
+        const parent = await open(directory, constants.O_RDONLY | constants.O_NOFOLLOW);
+        try {
+            await parent.sync();
+        }
+        finally {
+            await parent.close();
+        }
+        // This rename is the linearization point for "load by name", even when
+        // different revisions have identical millisecond timestamps.
+        const pointerTemporary = join(directory, `.pending-${randomUUID()}`);
+        const pointer = await open(pointerTemporary, constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL | constants.O_NOFOLLOW, 0o600);
+        try {
+            await pointer.writeFile(`${digest}\n`);
+            await pointer.sync();
+        }
+        finally {
+            await pointer.close();
+        }
+        if (await this.directory(name) !== directory)
+            throw unsafe();
+        await rename(pointerTemporary, join(directory, 'latest'));
+        const updatedParent = await open(directory, constants.O_RDONLY | constants.O_NOFOLLOW);
+        try {
+            await updatedParent.sync();
+        }
+        finally {
+            await updatedParent.close();
+        }
+        return saved;
+    }
+}

package/dist/workflow-tool.d.ts

@@ -0,0 +1,81 @@
+import { Type } from 'typebox';
+import { type AuthorHostAddendum, type DryRunResult, type WorkflowDeps } from '@parcha/agentrun-dsl';
+import type { WorkflowExtensionService } from './extension-service.js';
+export declare const WORKFLOW_TOOL_ACTIONS: readonly ["describe", "inspect", "dry-run", "run", "save", "load", "list"];
+/** The tool's fields: one action, and the fields an action reads. A host's tool may add its own. */
+export declare const workflowToolProperties: () => {
+    action: Type.TUnion<Type.TLiteral<"run" | "dry-run" | "save" | "load" | "describe" | "inspect" | "list">[]>;
+    name: Type.TOptional<Type.TString>;
+    digest: Type.TOptional<Type.TString>;
+    workflow: Type.TOptional<Type.TRecord<"^.*$", Type.TUnknown>>;
+    input: Type.TOptional<Type.TRecord<"^.*$", Type.TUnknown>>;
+};
+/** The tool's parameters. */
+export declare const workflowToolParameters: () => Type.TObject<{
+    action: Type.TUnion<Type.TLiteral<"run" | "dry-run" | "save" | "load" | "describe" | "inspect" | "list">[]>;
+    name: Type.TOptional<Type.TString>;
+    digest: Type.TOptional<Type.TString>;
+    workflow: Type.TOptional<Type.TRecord<"^.*$", Type.TUnknown>>;
+    input: Type.TOptional<Type.TRecord<"^.*$", Type.TUnknown>>;
+}>;
+/** What describe says of each tool a workflow may call: its schemas, and the result contract it is called under. */
+export declare const describeTools: (tools: readonly {
+    name: string;
+    description?: string;
+    parameters: unknown;
+    resultSchema?: unknown;
+}[]) => {
+    name: string;
+    description: string | undefined;
+    parameters: unknown;
+    resultSchema: {};
+    resultContract: string;
+}[];
+/** The author references describe returns, with the host's addendum (the coding-agent extension's by default). */
+export declare const authoringReferences: (host?: AuthorHostAddendum) => {
+    language: string;
+    workflow: string;
+    jev: string;
+    host: string;
+};
+/** The checks that run no code (admission by `checker`, structure, a supplied input), and the workflow's tree. A
+ *  refusal throws, naming why. */
+export declare function inspectCandidate(checker: WorkflowExtensionService, candidate: unknown, input?: Record<string, unknown>): {
+    inspection: import("@parcha/agentrun-dsl").WorkflowInspection;
+    tree: string;
+};
+/** A dry run's answer. `status` says whether every check ran: `passed`, `not_run` (a check could not run; `skipped`
+ *  says which, so it is no proof the workflow works) or `failed` (`problems` say why). */
+export type WorkflowDryRun = {
+    status: 'passed' | 'not_run';
+    ok: true;
+    skipped?: string[];
+} | {
+    status: 'failed';
+    ok: false;
+    problems: string[];
+    stage?: string;
+};
+export type DryRunDraftOptions = {
+    /** The input to run on; without one the dry run synthesizes it from the workflow's input schema. */
+    input?: Record<string, unknown>;
+    /** The SOP text for a workflow that names sections. */
+    sop?: string;
+    /** Why no SOP text is available, said when the workflow names sections. */
+    sopUnavailable?: string;
+    /** The operator authorized code for this dry run: code nodes run in this process. A host's `runCode` runs them instead. */
+    trusted?: boolean;
+    runCode?: WorkflowDeps['runCode'];
+    /** How code is authorized in this host, named when a code node does not run. */
+    trustedCommand?: string;
+    /** Ends the dry run at its next step, as not run. */
+    signal?: AbortSignal;
+};
+/** The status of a dry run's result: its own once the DSL gives one, else read from `ok` and `skipped`. */
+export declare function dryRunStatus(result: DryRunResult): WorkflowDryRun['status'];
+/** Dry-runs an inspected draft on synthetic values, or `options.input`: model, Jev and tool calls are synthesized, so
+ *  nothing is paid and nothing outside this process is touched. Code runs only when authorized, and a code failure is
+ *  reported without what it threw. */
+export declare function dryRunDraft(draft: unknown, options?: DryRunDraftOptions): Promise<WorkflowDryRun>;
+/** A dry run as a person reads it. */
+export declare function formatDryRun(report: WorkflowDryRun): string;

package/dist/workflow-tool.js

@@ -0,0 +1,94 @@
+// The agentrun tool's own work, for any host that offers it to an agent: its actions and parameters, describe, inspect
+// and the dry run. Nothing here imports pi's coding agent, its agent core or its TUI, so a pi-durable host can use it.
+import { Type } from 'typebox';
+import { compileTransform, dryRunWorkflow, formatWorkflowTree, inspectWorkflow, loadAuthorReference, renderAuthorHostAddendum, } from '@parcha/agentrun-dsl';
+import { PI_HOST_ADDENDUM } from './host-addendum.js';
+export const WORKFLOW_TOOL_ACTIONS = ['describe', 'inspect', 'dry-run', 'run', 'save', 'load', 'list'];
+/** The tool's fields: one action, and the fields an action reads. A host's tool may add its own. */
+export const workflowToolProperties = () => ({ action: Type.Union(WORKFLOW_TOOL_ACTIONS.map(value => Type.Literal(value))),
+    name: Type.Optional(Type.String({ description: 'Saved procedure name: lowercase letters, digits, hyphens or underscores.' })),
+    digest: Type.Optional(Type.String({ description: 'Optional exact saved SHA-256 revision to load.' })),
+    workflow: Type.Optional(Type.Record(Type.String(), Type.Unknown(), {
+        description: 'The complete AgentRun workflow JSON object. Pass the object directly, not a JSON-encoded string. Inspection validates its DSL structure.',
+    })), input: Type.Optional(Type.Record(Type.String(), Type.Unknown())) });
+/** The tool's parameters. */
+export const workflowToolParameters = () => Type.Object(workflowToolProperties());
+/** What describe says of each tool a workflow may call: its schemas, and the result contract it is called under. */
+export const describeTools = (tools) => tools.map(t => ({
+    name: t.name, description: t.description, parameters: t.parameters,
+    resultSchema: t.resultSchema ?? { type: 'object', properties: { content: { type: 'array', items: { type: 'object' } }, details: {} }, required: ['content'] },
+    resultContract: t.resultSchema ? 'Host-declared direct workflow call result.' : 'Pi result envelope; tool-specific details are not declared. Do not invent fields inside details.',
+}));
+/** The author references describe returns, with the host's addendum (the coding-agent extension's by default). */
+export const authoringReferences = (host = PI_HOST_ADDENDUM) => ({
+    language: loadAuthorReference('language'), workflow: loadAuthorReference('workflow-format'), jev: loadAuthorReference('jev-decisions'),
+    host: renderAuthorHostAddendum(host),
+});
+/** The checks that run no code (admission by `checker`, structure, a supplied input), and the workflow's tree. A
+ *  refusal throws, naming why. */
+export function inspectCandidate(checker, candidate, input) {
+    if (candidate === null || typeof candidate !== 'object' || Array.isArray(candidate)) {
+        throw new Error('Cannot inspect workflow: workflow must be a JSON object, not a JSON-encoded string or array. Pass the complete object directly.');
+    }
+    let inspection;
+    try {
+        inspection = checker.preflight(candidate, input);
+    }
+    catch (error) {
+        throw new Error(`Cannot inspect workflow: ${error instanceof Error ? error.message : 'Invalid workflow'}`);
+    }
+    return { inspection, tree: formatWorkflowTree(inspection) };
+}
+/** The status of a dry run's result: its own once the DSL gives one, else read from `ok` and `skipped`. */
+export function dryRunStatus(result) {
+    const given = result.status;
+    if (given === 'passed' || given === 'not_run' || given === 'failed')
+        return given;
+    return !result.ok ? 'failed' : result.skipped?.length ? 'not_run' : 'passed';
+}
+/** A code node run in this process, as the interpreter runs one; a failure names the node and not what it threw. */
+const inProcessCode = async (node, state, ctx) => {
+    let transform;
+    try {
+        transform = compileTransform(node.code);
+    }
+    catch {
+        throw new Error(`code node "${ctx.label}" did not compile`);
+    }
+    try {
+        return transform(state, { sop: ctx.sop });
+    }
+    catch {
+        throw new Error(`code node "${ctx.label}" threw; what it threw is not shown`);
+    }
+};
+/** Never reached: a draft with code runs it only when authorized, and this keeps validation from running any. */
+const noCode = async (_node, _state, ctx) => { throw new Error(`code node "${ctx.label}" did not run`); };
+/** Dry-runs an inspected draft on synthetic values, or `options.input`: model, Jev and tool calls are synthesized, so
+ *  nothing is paid and nothing outside this process is touched. Code runs only when authorized, and a code failure is
+ *  reported without what it threw. */
+export async function dryRunDraft(draft, options = {}) {
+    const inspection = inspectWorkflow(draft);
+    const code = inspection.nodes.filter(node => node.kind === 'code').map(node => JSON.stringify(node.label));
+    if (code.length && !options.trusted && !options.runCode) {
+        return { status: 'not_run', ok: true, skipped: [`Code node${code.length === 1 ? '' : 's'} ${code.join(', ')} did not run, and nothing else ran: code runs only ${options.trustedCommand ? `with the user command ${options.trustedCommand}` : 'with the host\'s code executor'}.`] };
+    }
+    const sections = inspection.requires.sopSections;
+    if (sections.length && options.sop === undefined) {
+        return { status: 'not_run', ok: true, skipped: [options.sopUnavailable ?? `The workflow needs SOP text for ${sections.map(name => JSON.stringify(name)).join(', ')}, and none was supplied.`] };
+    }
+    const result = await dryRunWorkflow(draft, {
+        ...(options.input === undefined ? {} : { input: options.input }), ...(options.sop === undefined ? {} : { sop: options.sop }),
+        ...(options.signal ? { signal: options.signal } : {}),
+        runCode: options.runCode ?? (code.length ? inProcessCode : noCode),
+    });
+    return { ...result, status: dryRunStatus(result) };
+}
+/** A dry run as a person reads it. */
+export function formatDryRun(report) {
+    const head = !report.ok ? `Dry run failed${report.stage ? ` at "${report.stage}"` : ''}.`
+        : report.status === 'passed' ? 'Dry run passed: every step ran on synthetic values. It checks the wiring, not the answers.'
+            : 'Dry run not run: a check could not run, so this is not proof the workflow works.';
+    const lines = report.ok ? report.skipped ?? [] : report.problems;
+    return [`${head} No model, Jev or tool call was made.`, ...lines.map(line => `- ${line}`)].join('\n');
+}

package/dist/workflow-view.d.ts

@@ -0,0 +1,64 @@
+import { type WorkflowDeps } from '@parcha/agentrun-dsl';
+import type { ExtensionRunReport } from './extension-service.js';
+type Event = Parameters<NonNullable<WorkflowDeps['onEvent']>>[0];
+type JudgeRequest = Parameters<NonNullable<WorkflowDeps['runJudge']>>[0];
+export interface WorkflowViewNode {
+    path: string;
+    label: string;
+    kind: string;
+    status: string;
+    summary: string;
+    details: string[];
+}
+export interface WorkflowView {
+    title: string;
+    digest: string;
+    status: string;
+    summary: string[];
+    nodes: WorkflowViewNode[];
+    output?: string[];
+}
+export interface DecisionEvidence {
+    path: string;
+    label: string;
+    questions: string;
+    evidence: string;
+    answer?: string;
+    accepted?: boolean;
+}
+export interface RunObservation {
+    steps: Record<string, {
+        label: string;
+        kind: string;
+        status: string;
+    }>;
+    decisions: DecisionEvidence[];
+    notes: Record<string, string>;
+    omitted: number;
+    routes?: Record<string, string>;
+}
+/** Display limits never admit, cancel, or modify execution. */
+export declare function readable(value: unknown, max?: number): string;
+export declare class WorkflowObservation {
+    readonly data: RunObservation;
+    private decisionBytes;
+    record(event: Event): void;
+    private recordSafe;
+    /** Capture the exact supplied questions/state, not an explanation invented afterward. */
+    requested(request: JudgeRequest): DecisionEvidence | undefined;
+    observe(deps: WorkflowDeps): WorkflowDeps;
+}
+export declare function progressLines(observation: RunObservation, terminalStatus?: string): string[];
+export declare function workflowView(workflow: unknown, options?: {
+    input?: Record<string, unknown>;
+    observation?: RunObservation;
+    report?: ExtensionRunReport;
+    running?: boolean;
+    mode?: string;
+    model?: string;
+    limits?: Record<string, number | null>;
+    availableTools?: string[];
+    savedName?: string;
+}): WorkflowView;
+export declare function formatWorkflowView(view: WorkflowView): string;
+export {};