@ai-ecoverse/slicc-agent 6.18.17 → 6.19.0

package/dist/types/codemode/index.d.ts

@@ -1,5 +1,5 @@
 import type { Context, JsonValue } from '@earendil-works/chord';
-import { type CodemodeError, type CodemodeOutputItem, type CodemodeResult, type CodemodeSandboxOptions, type CodemodeTool } from '@earendil-works/pi-codemode';
+import { type CodemodeError, type CodemodeOutputItem, type CodemodeResult, type CodemodeRun, type CodemodeRunOptions, type CodemodeSandboxOptions, type CodemodeTool } from '@earendil-works/pi-codemode';
 import { type Agent, type Extension, type ToolExecutionApi, type ToolRegistration } from '@earendil-works/pi-durable';
 export declare const CODEMODE = "codemode";
 export declare const DEFAULT_MAX_OUTPUT_TOKENS = 10000;
@@ -12,6 +12,7 @@ export interface Sandbox {
         signal?: AbortSignal;
         store?: Record<string, unknown>;
     }): Promise<CodemodeResult>;
+    start(code: string, options: CodemodeRunOptions): CodemodeRun;
     close(): Promise<void>;
 }
 export type SandboxFactory = (options: CodemodeSandboxOptions) => Sandbox;
@@ -39,4 +40,5 @@ export declare function disabledBySettings(text: string | undefined): boolean;
 export type Fetcher = (url: string) => Promise<Response>;
 export declare function wasmCandidates(from: URL): string[];
 export declare function locateWasm(fetcher: Fetcher, from: URL): Promise<WebAssembly.Module | undefined>;
+export declare function sharedSandbox(): SandboxFactory | undefined;
 export declare function sandboxFactory(wasm: () => Promise<WebAssembly.Module | undefined>, workerUrl?: string | URL): SandboxFactory;

package/dist/types/guests/guard.d.ts

@@ -1,5 +1,5 @@
 import type { Context } from '@earendil-works/chord';
-import { type Extension, type Harness, type SubmissionId } from '@earendil-works/pi-durable';
+import { type ConversationId, type Extension, type Harness, type SubmissionId } from '@earendil-works/pi-durable';
 import type { Approval, Approvals } from '../approvals/index.ts';
 import { type GuestPolicy } from './policy.ts';
 import { type AlwaysTool, type SeatRecord } from './seats.ts';
@@ -36,6 +36,15 @@ export declare function argumentsHash(args: string): Promise<string>;
 export declare function sealedRules(rules: readonly AlwaysTool[]): Promise<AlwaysTool[] | null>;
 export declare function summaryOf(args: Record<string, unknown>): string;
 export declare function reasonOf(item: Approval): string;
+export type InheritedTaint = {
+    seat: string | null;
+    tier: string;
+};
+export declare const GuestTaintDoc: import("@earendil-works/pi-durable").RewindableConversationDocToken<{
+    taints: InheritedTaint[];
+}>;
+type TaintReader = Pick<Harness, 'submission' | 'snapshot'>;
+export declare function runTaints(harness: TaintReader, conversationId: ConversationId, context: Context): Promise<InheritedTaint[]>;
 export declare function taintsOf(inputs: readonly SubmissionId[], seats: Readonly<Record<string, SeatRecord>>, harness: Pick<Harness, 'submission'>, context: Context): Promise<Taint[]>;
 export declare function guestToolGate(harness: () => Held | undefined): GuestToolGate;
 export {};

package/dist/types/scoops/cli.d.ts

@@ -13,7 +13,7 @@ export declare const DEFAULT_WAIT_S = 30;
 export declare const MAX_DEPTH = 3;
 export declare const RUN_DIR = "/var/lib/slicc/agent/scoops";
 export declare const THINKING: Set<string>;
-export declare const USAGE = "usage:\n  agent [options] (--prompt <text> | --file <path> | -)...          run a scoop, wait, print its answer\n  agent --async [options] (--prompt <text> | --file <path> | -)...  start a scoop, print its handle\n  agent <cwd> <allowed-commands> <prompt>                         the same as a synchronous run, in v6's form\n  agent list [--agents] | status <handle> | rename <handle> <name>\n  agent send <handle> [--follow-up] (<message> | --file <path> | -)\n  agent send <target> --lick=<cron|webhook> [--source <name>] (<message> | --file <path> | -)\n  agent send parent <note>                                        from a scoop: a progress note to its cone\n  agent wait <handle>... [--timeout <seconds>] [--notify]\n  agent stop <handle>\n\noptions:\n  --name <name>  --agent <role>  --model <provider/model>  --thinking <level> | --effort <low|medium|high|max>\n  --tools <a,b>  --read-only <path,path>  --system-prompt <text> | --system-prompt-file <path>\n  --background-after <seconds>  --persist-session | --no-persist-session\n\nA synchronous run removes the scoop's folder afterwards. Its transcript is archived in\n/tmp/agent-sessions/<handle>.md, in /home/sessions/<handle>.md with --persist-session, or nowhere\nwith --no-persist-session. subagent is the same command: subagent spawn = agent --async.\n";
+export declare const USAGE = "usage:\n  agent [options] (--prompt <text> | --file <path> | -)...          run a scoop, wait, print its answer\n  agent --async [options] (--prompt <text> | --file <path> | -)...  start a scoop, print its handle\n  agent <cwd> <allowed-commands> <prompt>                         the same as a synchronous run, in v6's form\n  agent list [--agents] | status <handle> | rename <handle> <name>\n  agent send <handle> [--follow-up] (<message> | --file <path> | -)\n  agent send <target> --lick=<cron|webhook> [--source <name>] (<message> | --file <path> | -)\n  agent send parent <note>                                        from a scoop: a progress note to its cone\n  agent wait <handle>... [--timeout <seconds>] [--notify]\n  agent stop <handle>\n  agent workflow run|list|status|stop|save ...                    Claude Code workflows; agent workflow help\n\noptions:\n  --name <name>  --agent <role>  --model <provider/model>  --thinking <level> | --effort <low|medium|high|max>\n  --tools <a,b>  --read-only <path,path>  --system-prompt <text> | --system-prompt-file <path>\n  --background-after <seconds>  --persist-session | --no-persist-session\n\nA synchronous run removes the scoop's folder afterwards. Its transcript is archived in\n/tmp/agent-sessions/<handle>.md, in /home/sessions/<handle>.md with --persist-session, or nowhere\nwith --no-persist-session. subagent is the same command: subagent spawn = agent --async.\n";
 export interface CliOptions {
     env: ExecutionEnv;
     harness: Harness;
@@ -33,6 +33,7 @@ export interface CliOptions {
     panel?: (argv: readonly string[], caller: PanelCaller, context: Context) => Promise<Answer>;
     licks?: Pick<Licks, 'deliver'>;
     webhook?: (name: string, delivery: WebhookDelivery, context: Context) => Promise<boolean>;
+    workflow?: (argv: readonly string[], who: Caller, request: Request, context: Context) => Promise<Answer>;
 }
 export interface PanelCaller {
     agentId: string | null;

package/dist/types/scoops/service.d.ts

@@ -1,7 +1,8 @@
 import type { Context } from '@earendil-works/chord';
-import { type AgentChange, type AnyTask, type Conversation, type ConversationId, type Harness, type ToolRegistration } from '@earendil-works/pi-durable';
+import { type AgentChange, type AnyTask, type Conversation, type ConversationId, type Extension, type Harness, type ToolRegistration, type Tx } from '@earendil-works/pi-durable';
 import type { ExecutionEnv } from '@earendil-works/pi-durable/env';
 import { type Agents, type AgentsState, type Mark, type ScoopRecord } from '../agents.ts';
+import { type InheritedTaint } from '../guests/guard.ts';
 import type { ProcessGroups } from '../kernel/groups.ts';
 import { type Layout } from '../layout.ts';
 import type { Licks } from '../licks/licks.ts';
@@ -57,6 +58,7 @@ export interface ScoopsHost {
     mcp?: (names: readonly string[]) => ToolRegistration[];
     layout?: Layout;
     enforced?: boolean;
+    exclude?: readonly Extension[];
 }
 export interface Rewound {
     stopped: string[];
@@ -99,6 +101,13 @@ export interface SpawnRequest {
     fromAgent: boolean;
     request?: string;
     limits: Limits;
+    taints?: InheritedTaint[];
+    created?: (tx: Tx, made: Spawned) => Promise<void>;
+}
+export interface Spawned {
+    folder: string;
+    conversation: number;
+    tasks: number[];
 }
 export declare function workspace(folder: string, layout?: Layout): string;
 export declare function tail(conversation: Conversation, context: Context): Promise<Mark>;
@@ -106,6 +115,7 @@ export declare function turnStart(conversation: Conversation, context: Context):
 export declare function coneOf(state: Readonly<AgentsState>, conversation: number): string | undefined;
 export declare function findScoop(state: Readonly<AgentsState>, handle: string, cone: string | null): [string, ScoopRecord] | undefined;
 export declare function choosable(tools: readonly ToolRegistration[]): Choosable;
+export declare function agentChange(request: SpawnRequest, folder: string, host: Pick<ScoopsHost, 'tools' | 'mcp' | 'layout' | 'exclude'>): AgentChange;
 export declare function askerName(state: Readonly<AgentsState>, asker: string | null): string;
 export declare function createScoops(host: Promise<ScoopsHost>, tasks: () => ScoopTasks): {
     detach: (made: readonly number[], target: string, context: Context) => Promise<void>;

package/dist/types/workflow/index.d.ts

@@ -0,0 +1,104 @@
+import type { Context, JsonValue } from '@earendil-works/chord';
+import { type AnyTask, type Extension, type Registry, type ToolRegistration } from '@earendil-works/pi-durable';
+import type { ExecutionEnv } from '@earendil-works/pi-durable/env';
+import type { Agents } from '../agents.ts';
+import { sharedSandbox } from '../codemode/index.ts';
+import type { Layout } from '../layout.ts';
+import { type Engine, type RunHost, type RunRecord } from './run.ts';
+export { WorkflowsDoc } from './run.ts';
+export declare const WORKFLOW = "workflow";
+export declare const SAVE_NAME: RegExp;
+export type Answer = {
+    code: number;
+    out: string;
+};
+export interface Files {
+    dir: string;
+    env: Pick<ExecutionEnv, 'readTextFile' | 'writeFile' | 'createDir' | 'fileInfo'>;
+    cwd: string;
+}
+export interface RunRequest {
+    cone: string;
+    from?: number | null;
+    files: Files;
+    target: string;
+    script?: boolean;
+    args?: JsonValue;
+    budget?: number;
+    concurrency?: number;
+}
+export interface WorkflowHost extends RunHost {
+    envFor(user: string | null, context: Context): Promise<Files['env']>;
+    tasks: {
+        run: AnyTask;
+    };
+}
+export declare function workflowsDir(home: string): string;
+export declare function pathOf(files: Files, target: string): string;
+export declare function concurrencyOf(value: number | undefined): number;
+export declare function budgetOf(value: number | undefined): number | null;
+export declare function summary(run: RunRecord): string;
+export declare function outcome(run: RunRecord): Answer;
+export declare function createWorkflows(host: Promise<WorkflowHost>): {
+    runs: (context: Context) => Promise<Record<string, RunRecord>>;
+    find: (id: string, context: Context) => Promise<RunRecord>;
+    start: (request: RunRequest, context: Context) => Promise<string>;
+    wait: (id: string, context: Context) => Promise<RunRecord | undefined>;
+    stop: (id: string, context: Context) => Promise<RunRecord | undefined>;
+    save: (id: string, name: string, force: boolean, files: Files, context: Context) => Promise<Answer>;
+    list(cone: string | null, context: Context): Promise<RunRecord[]>;
+};
+export type Workflows = ReturnType<typeof createWorkflows>;
+export interface Invocation {
+    cone: string;
+    scoop: boolean;
+    from: number | null;
+    files: Files;
+}
+export declare const USAGE = "usage:\n  agent workflow run <file.js | name> [--args <json>] [--budget <tokens>] [--concurrency <n>] [--wait]\n  agent workflow run --script '<js>' [same options]\n  agent workflow list | status <run> | wait <run> | stop <run> | save <run> <name> [--force]\n\nGlobals: agent(prompt, { label, phase, schema, model, effort, agentType }), parallel(thunks),\npipeline(items, ...stages), phase(title), log(message), console, args, budget (output tokens).\n\nRuns a Claude Code .workflow.js as a durable task; it survives a reload. Without --wait it prints\nthe run id. --budget caps output tokens, --concurrency caps agents running at once. save keeps a\nrun's source as ~/.slicc/workflows/<name>.workflow.js, which agent workflow run <name> runs.\n";
+type Parsed = {
+    values: Map<string, string>;
+    switches: Set<string>;
+    rest: string[];
+};
+export declare function parseArgv(argv: readonly string[]): Parsed;
+export interface RunOptions {
+    target?: string;
+    script?: string;
+    args?: JsonValue;
+    budget?: number;
+    concurrency?: number;
+    wait?: boolean;
+}
+export declare function runWorkflow(workflows: Workflows, who: Invocation, options: RunOptions, context: Context): Promise<Answer>;
+export declare function command(workflows: Workflows, who: Invocation, argv: readonly string[], context: Context): Promise<Answer>;
+export declare const TOOL_DESCRIPTION = "Run a Claude Code dynamic workflow (.workflow.js) as a durable background task that survives a reload, or manage runs.\naction run: give file (a path, or the name of a saved workflow) or script (the source). The source starts with `export const meta = { name, description }`; the body may use top-level await and return a JSON result. Globals: `agent(prompt, { label, phase, schema, model: 'provider/model', effort, agentType })` runs one scoop and resolves to its answer (JSON matching schema, when given), and rejects when it fails; `parallel(thunks)` and `pipeline(items, ...stages)` turn a failed branch into null; `phase(title)`, `log(message)`, `console.*`, `args`, `budget` ({ total, spent(), remaining() } in output tokens). No Date.now(), Math.random(), timers, require, fs or nested workflow().\nbudget caps output tokens, concurrency caps agents running at once (default 8). wait: true blocks until the run ends and returns its result; otherwise the run id comes back at once.\naction list | status (run) | stop (run) | save (run, name, force): manage runs; save keeps the source as ~/.slicc/workflows/<name>.workflow.js.";
+type ToolArgs = {
+    action: 'run' | 'list' | 'status' | 'stop' | 'save';
+    file?: string;
+    script?: string;
+    args?: unknown;
+    budget?: number;
+    concurrency?: number;
+    wait?: boolean;
+    run?: string;
+    name?: string;
+    force?: boolean;
+};
+export declare function toolArgv(args: ToolArgs): string[];
+export declare function workflowTool(workflows: Workflows, who: (conversation: number, context: Context) => Promise<Invocation | undefined>): ToolRegistration;
+export interface WorkflowsSetup {
+    workflows: Workflows;
+    extension: Extension;
+    attach(host: Omit<WorkflowHost, 'tasks'>): void;
+}
+export declare function setupWorkflows(registry: Registry): WorkflowsSetup;
+export declare function cliCommand(workflows: Workflows, layout: Layout, env: Files['env'], agents: Pick<Agents, 'state'>): (argv: readonly string[], who: {
+    cone: string;
+    scoop: string | null;
+    fromAgent: boolean;
+}, request: {
+    user?: string | null;
+    cwd: string;
+}, context: Context) => Promise<Answer>;
+export declare function workflowEngine(factory?: typeof sharedSandbox): () => Engine;

package/dist/types/workflow/run.d.ts

@@ -0,0 +1,137 @@
+import type { Context, JsonValue } from '@earendil-works/chord';
+import type { CodemodeHostCall, CodemodeOutcome, CodemodeResult, CodemodeRun, CodemodeRunOptions } from '@earendil-works/pi-codemode';
+import { type TaskRuntime, type Tx } from '@earendil-works/pi-durable';
+import type { InheritedTaint } from '../guests/guard.ts';
+import type { Spawned } from '../scoops/service.ts';
+import { plan, type StepHost } from './step.ts';
+export declare const MAX_LOGS = 200;
+export declare const KEPT_RUNS = 50;
+export type RunStatus = 'running' | 'completed' | 'failed' | 'stopped';
+export type RunRecord = {
+    id: string;
+    name: string;
+    description: string;
+    cone: string;
+    home: string;
+    file: string | null;
+    source: string;
+    budget: number | null;
+    concurrency: number;
+    status: RunStatus;
+    phase: string | null;
+    started: number;
+    ended: number | null;
+    agents: {
+        started: number;
+        done: number;
+        failed: number;
+        running: string[];
+    };
+    spent: number;
+    logs: string[];
+    fromAgent: boolean;
+    taints: InheritedTaint[];
+    result?: JsonValue;
+    error?: string;
+};
+export declare const WorkflowsDoc: import("@earendil-works/pi-durable").SessionDocToken<{
+    runs: Record<string, RunRecord>;
+}>;
+type Start = {
+    startedAt: number;
+    seed: number;
+    fingerprint: string | null;
+    count: number;
+    firstIssued: number | null;
+};
+type Entry = {
+    id: number;
+    name: string;
+    at: number;
+    outcome: JsonValue;
+    issuedAfter: number | null;
+};
+export interface Engine {
+    start(code: string, options: CodemodeRunOptions): CodemodeRun;
+}
+export interface RunHost extends StepHost {
+    engine: () => Engine;
+}
+type Lookup = () => Promise<RunHost>;
+type RunInput = {
+    code: string;
+};
+type RunState = {
+    phase: 'start';
+} | {
+    phase: 'run';
+};
+export declare const GLOBALS: {
+    name: string;
+}[];
+export declare const DIVERGED = "the workflow took another path than before the restart, so it cannot resume";
+export declare function noted(record: RunRecord, args: unknown): void;
+export declare function errorText(result: CodemodeResult): string;
+type Runtime = TaskRuntime<RunInput, RunState, null, object>;
+type Event = {
+    kind: 'call';
+    call: CodemodeHostCall;
+} | {
+    kind: 'idle';
+    seq: number;
+    issued: number;
+} | {
+    kind: 'started';
+    fingerprint: string;
+};
+export declare class Driver {
+    readonly id: string;
+    readonly host: RunHost;
+    readonly runtime: Runtime;
+    readonly context: Context;
+    readonly controller: AbortController;
+    readonly issued: Map<number, CodemodeHostCall>;
+    readonly steps: Set<Promise<void>>;
+    readonly deferred: CodemodeHostCall[];
+    readonly queue: (() => void)[];
+    journal: Entry[];
+    start: Start;
+    record: RunRecord | undefined;
+    next: number;
+    idle: {
+        seq: number;
+        issued: number;
+    } | null;
+    agents: number;
+    inflight: number;
+    spent: number;
+    stopped: string | null;
+    run: CodemodeRun | undefined;
+    constructor(host: RunHost, runtime: Runtime, context: Context);
+    get scoped(): Context;
+    get lanes(): number;
+    load(): Promise<void>;
+    halt(reason: string): void;
+    replaying(): boolean;
+    deliver(seq: number, at: number, id: number, outcome: CodemodeOutcome): void;
+    expected(): number | null;
+    pump(): void;
+    handle(event: Event): void;
+    acknowledge(seq: number, issued: number): Promise<void>;
+    launch(call: CodemodeHostCall): void;
+    journalize(call: CodemodeHostCall, outcome: CodemodeOutcome, effect: (record: RunRecord) => void): Promise<void>;
+    refused(): string | null;
+    admit(): Promise<void>;
+    free(): void;
+    live(call: CodemodeHostCall): Promise<void>;
+    created(call: CodemodeHostCall): (tx: Tx, made: Spawned) => Promise<void>;
+    spawn(call: CodemodeHostCall, planned: ReturnType<typeof plan>, limits: object): Promise<{
+        folder: string;
+        task: number;
+    }>;
+    step(call: CodemodeHostCall): Promise<JsonValue>;
+    fingerprint(value: string): Promise<void>;
+    execute(code: string): Promise<CodemodeResult>;
+}
+export declare function runTask(lookup: Lookup): import("@earendil-works/pi-durable").Task<RunInput, RunState, null, object>;
+export {};

package/dist/types/workflow/script.d.ts

@@ -0,0 +1,20 @@
+export declare const MAX_SOURCE: number;
+export declare const MAX_AGENTS = 1000;
+export declare const MAX_ITEMS = 4096;
+export declare const MAX_SCHEMA: number;
+export declare const DEFAULT_CONCURRENCY = 8;
+export interface Meta {
+    name: string;
+    description: string;
+}
+export interface Config {
+    args?: unknown;
+    budget: number | null;
+    concurrency: number;
+}
+export declare function maxConcurrency(cores?: number): number;
+export declare function parseMeta(source: string): Meta;
+export declare function stripExports(source: string): string;
+export declare const PRELUDE = "\nclass WorkflowError extends Error {\n  constructor(message) {\n    super(message);\n    this.name = 'WorkflowError';\n  }\n}\nconst RealDate = globalThis.Date;\nconst RealMath = globalThis.Math;\nconst banned = (what) => () => {\n  throw new WorkflowError(what + ' is not allowed in a workflow; pass time or randomness in args');\n};\nconst Date = function Date(...given) {\n  if (new.target === undefined) banned('Date()')();\n  if (given.length === 0) banned('new Date()')();\n  return new RealDate(...given);\n};\nDate.prototype = RealDate.prototype;\nDate.UTC = RealDate.UTC;\nDate.parse = RealDate.parse;\nDate.now = banned('Date.now()');\nObject.freeze(Date);\nconst Math = {};\nfor (const key of Object.getOwnPropertyNames(RealMath)) Math[key] = RealMath[key];\nMath.random = banned('Math.random()');\nObject.freeze(Math);\nconst crypto = Object.freeze({\n  getRandomValues: banned('crypto.getRandomValues()'),\n  randomUUID: banned('crypto.randomUUID()'),\n});\nconst performance = Object.freeze({ now: banned('performance.now()') });\nconst setTimeout = banned('setTimeout()');\nconst setInterval = banned('setInterval()');\nconst OPTIONS = ['label', 'phase', 'schema', 'model', 'effort', 'agentType', 'isolation'];\nconst lanes = config.concurrency;\nlet started = 0;\nlet spent = 0;\nlet current = null;\nlet active = 0;\nconst waiting = [];\nconst acquire = async () => {\n  if (active < lanes) {\n    active++;\n    return;\n  }\n  await new Promise((resume) => waiting.push(resume));\n};\nconst release = () => {\n  const next = waiting.shift();\n  if (next) next();\n  else active--;\n};\nconst textOf = (values) =>\n  values.map((value) => (typeof value === 'string' ? value : JSON.stringify(value))).join(' ');\nconst note = (kind, text) => {\n  tell({ kind, text }).then(undefined, () => undefined);\n};\nconst gate = () => {\n  if (config.budget !== null && spent >= config.budget)\n    throw new WorkflowError('agent(): the budget of ' + config.budget + ' output tokens is spent');\n};\nconst failed = (error) => {\n  note('log', '[error] ' + (error && error.message ? error.message : String(error)));\n  return null;\n};\nconst console = Object.freeze({\n  log: (...values) => note('log', textOf(values)),\n  info: (...values) => note('log', textOf(values)),\n  debug: (...values) => note('log', textOf(values)),\n  warn: (...values) => note('log', '[warn] ' + textOf(values)),\n  error: (...values) => note('log', '[error] ' + textOf(values)),\n});\nconst budget = Object.freeze({\n  total: config.budget,\n  spent: () => spent,\n  remaining: () => (config.budget === null ? Infinity : Math.max(0, config.budget - spent)),\n});\nfunction phase(title) {\n  current = String(title);\n  note('phase', current);\n}\nfunction log(message) {\n  note('log', String(message));\n}\nfunction workflow() {\n  throw new WorkflowError('workflow(): nested workflows are not supported in SLICC');\n}\nasync function agent(prompt, options) {\n  if (typeof prompt !== 'string' || !prompt.trim()) throw new WorkflowError('agent() needs a prompt string');\n  const given = options === undefined || options === null ? {} : options;\n  if (typeof given !== 'object' || Array.isArray(given)) throw new WorkflowError('agent(): options must be an object');\n  for (const key of Object.keys(given))\n    if (!OPTIONS.includes(key)) throw new WorkflowError('agent(): unknown option ' + key);\n  if (given.isolation !== undefined) throw new WorkflowError('agent(): isolation is not supported in SLICC');\n  if (started >= 1000) throw new WorkflowError('agent(): a workflow starts at most 1000 agents');\n  gate();\n  started++;\n  await acquire();\n  try {\n    gate();\n    const call = { ...given, prompt };\n    if (call.phase === undefined && current !== null) call.phase = current;\n    try {\n      const answer = await host(call);\n      spent += answer.outputTokens;\n      return answer.value;\n    } catch (error) {\n      spent += error && typeof error.outputTokens === 'number' ? error.outputTokens : 0;\n      throw error;\n    }\n  } finally {\n    release();\n  }\n}\nasync function parallel(thunks) {\n  if (!Array.isArray(thunks) || thunks.some((thunk) => typeof thunk !== 'function'))\n    throw new WorkflowError('parallel() expects an array of functions');\n  if (thunks.length > 4096) throw new WorkflowError('parallel(): at most 4096 items per call');\n  return Promise.all(\n    thunks.map(async (thunk) => {\n      try {\n        return await thunk();\n      } catch (error) {\n        return failed(error);\n      }\n    })\n  );\n}\nasync function pipeline(items, ...stages) {\n  if (!Array.isArray(items)) throw new WorkflowError('pipeline() expects an array as its first argument');\n  if (items.length > 4096) throw new WorkflowError('pipeline(): at most 4096 items per call');\n  if (stages.some((stage) => typeof stage !== 'function')) throw new WorkflowError('pipeline(): every stage must be a function');\n  return Promise.all(\n    items.map(async (item, index) => {\n      let value = item;\n      for (const stage of stages) {\n        try {\n          value = await stage(value, item, index);\n        } catch (error) {\n          return failed(error);\n        }\n        if (value === null) return null;\n      }\n      return value;\n    })\n  );\n}\nreturn Object.freeze({\n  agent, parallel, pipeline, phase, log, workflow, console, budget, args: config.args,\n  Date, Math, crypto, performance, setTimeout, setInterval, WorkflowError,\n});\n";
+export declare const PUBLIC: string[];
+export declare function buildCode(source: string, config: Config): string;

package/dist/types/workflow/step.d.ts

@@ -0,0 +1,53 @@
+import type { Context, JsonValue } from '@earendil-works/chord';
+import type { Harness, TaskId } from '@earendil-works/pi-durable';
+import type { ExecutionEnv } from '@earendil-works/pi-durable/env';
+import type { Agents } from '../agents.ts';
+import type { Layout } from '../layout.ts';
+import { type Role, type Roles } from '../roles/roles.ts';
+import type { ReportResult } from '../scoops/extension.ts';
+import { type Scoops } from '../scoops/service.ts';
+export declare const EFFORT: Record<string, string>;
+export interface AgentCall {
+    prompt: string;
+    label?: string;
+    phase?: string;
+    schema?: JsonValue;
+    model?: string;
+    effort?: string;
+    agentType?: string;
+}
+export interface StepHost {
+    harness: Harness;
+    agents: Agents;
+    scoops: Scoops;
+    roles: (context: Context) => Promise<Roles>;
+    env: Pick<ExecutionEnv, 'remove'>;
+    layout: Layout;
+}
+export declare class StepError extends Error {
+    readonly outputTokens: number;
+    constructor(message: string, outputTokens?: number);
+}
+export interface Planned {
+    name: string;
+    prompt: string;
+    role?: Role;
+    model?: {
+        provider: string;
+        modelId: string;
+    };
+    thinking?: string;
+    schema?: object;
+}
+export declare function instruction(schema: object): string;
+export declare function plan(given: unknown, roles: Roles): Planned;
+export declare function parseAnswer(text: string, schema: object): JsonValue;
+export declare function outputTokens(harness: Harness, conversation: number, context: Context): Promise<number>;
+export declare function cleanup(host: StepHost, folder: string): Promise<void>;
+export declare function settle(host: StepHost, folder: string, task: number, planned: Planned, wait: (task: number) => Promise<ReportResult>, context: Context): Promise<{
+    value: JsonValue;
+    outputTokens: number;
+}>;
+export declare function waitReport(wait: (id: TaskId<ReportResult>, context: Context) => Promise<{
+    state: unknown;
+}>, task: number, context: Context): Promise<ReportResult>;