pi-extensible-workflows 1.0.0 → 1.0.1

package/dist/src/agent-execution.js

@@ -120,6 +120,43 @@ export async function createNativeAgentSession(input) {
 }
 function changedOption(options, baseline, key) { return JSON.stringify(options[key]) !== JSON.stringify(baseline[key]); }
 function validThinking(value) { return typeof value === "string" && ["off", "minimal", "low", "medium", "high", "xhigh", "max"].includes(value); }
+function jsonValue(value, seen = new Set()) {
+    if (value === null || typeof value === "boolean" || typeof value === "string")
+        return true;
+    if (typeof value === "number")
+        return Number.isFinite(value);
+    if (typeof value !== "object" || seen.has(value))
+        return false;
+    if (!Array.isArray(value) && Object.getPrototypeOf(value) !== Object.prototype && Object.getPrototypeOf(value) !== null)
+        return false;
+    const keys = Reflect.ownKeys(value);
+    if (keys.some((key) => typeof key !== "string"))
+        return false;
+    seen.add(value);
+    const valid = (Array.isArray(value) ? Array.from(value) : keys.map((key) => value[key])).every((item) => jsonValue(item, seen));
+    seen.delete(value);
+    return valid;
+}
+function jsonObject(value) { return jsonValue(value) && typeof value === "object" && value !== null && !Array.isArray(value); }
+function isChildAgentToolParams(value) {
+    if (!jsonObject(value) || typeof value.prompt !== "string" || typeof value.label !== "string")
+        return false;
+    if (value.tools !== undefined && (!Array.isArray(value.tools) || value.tools.some((tool) => typeof tool !== "string")))
+        return false;
+    if (value.model !== undefined && typeof value.model !== "string")
+        return false;
+    if (value.thinking !== undefined && !validThinking(value.thinking))
+        return false;
+    if (value.role !== undefined && typeof value.role !== "string")
+        return false;
+    if (value.outputSchema !== undefined && !jsonObject(value.outputSchema))
+        return false;
+    if (value.retries !== undefined && (typeof value.retries !== "number" || !Number.isInteger(value.retries) || value.retries < 0))
+        return false;
+    if (value.timeoutMs !== undefined && (value.timeoutMs !== null && (typeof value.timeoutMs !== "number" || !Number.isInteger(value.timeoutMs) || value.timeoutMs < 1)))
+        return false;
+    return true;
+}
 function fallbackSetupContext(root, options, signal) {
     const identity = options.agentIdentity ?? { structuralPath: [], callSite: options.label, occurrence: 1 };
     const run = root.runContext ?? Object.freeze({ cwd: root.cwd, sessionId: "", runId: "", workflow: Object.freeze({ name: options.workflowName }), args: null, signal });
@@ -686,7 +723,6 @@ export class FairAgentScheduler {
         if (nodes.every(({ restored }) => restored))
             run.logical = 0;
     }
-    /* eslint-disable @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-argument, @typescript-eslint/restrict-template-expressions */
     toolsFor(parentId, resolveTools) {
         const parent = this.#node(parentId);
         if (!parent.options.tools.includes("agent"))
@@ -694,11 +730,15 @@ export class FairAgentScheduler {
         const agentTool = {
             name: "agent", label: "Child Agent", description: "Start a direct child agent",
             parameters: Type.Object({ prompt: Type.String(), label: Type.String(), tools: Type.Optional(Type.Array(Type.String())), model: Type.Optional(Type.String()), thinking: Type.Optional(Type.String()), role: Type.Optional(Type.String()), outputSchema: Type.Optional(Type.Unsafe({})), retries: Type.Optional(Type.Integer({ minimum: 0 })), timeoutMs: Type.Optional(Type.Union([Type.Integer({ minimum: 1 }), Type.Null()])) }, { additionalProperties: true }),
-            execute: async (_id, params) => {
+            execute: async (_id, rawParams) => {
+                if (!isChildAgentToolParams(rawParams))
+                    throw new WorkflowError("INVALID_METADATA", "Invalid child agent parameters");
+                const params = rawParams;
                 if (params.role !== undefined && (params.model !== undefined || params.thinking !== undefined || params.tools !== undefined))
                     throw new WorkflowError("INVALID_METADATA", "Role agents must not specify model, thinking, or tools");
                 const tools = (params.tools !== undefined || params.role !== undefined ? resolveTools?.(params.role, params.tools, params.model, parent.options.tools, params.thinking) : undefined) ?? params.tools ?? parent.options.tools;
-                const agentOptions = Object.fromEntries(Object.entries(params).filter(([key]) => key !== "prompt"));
+                const agentOptions = { ...params };
+                Reflect.deleteProperty(agentOptions, "prompt");
                 const options = { label: params.label, requestedLabel: params.label, cwd: parent.options.cwd, tools, agentOptions, ...(params.model ? { model: params.model } : {}), ...(params.thinking ? { thinking: params.thinking } : {}), ...(params.role ? { role: params.role } : {}), ...(params.outputSchema ? { schema: params.outputSchema } : {}), ...(params.retries === undefined ? {} : { retries: params.retries }), ...(params.timeoutMs === undefined ? {} : { timeoutMs: params.timeoutMs }) };
                 const child = this.spawn(parent.runId, params.prompt, options, parentId);
                 return { content: [{ type: "text", text: JSON.stringify({ id: child.id }) }], details: { id: child.id } };
@@ -745,17 +785,17 @@ export class FairAgentScheduler {
     #inherit(parent, options) {
         if (!options.label.trim() || !options.cwd || !Array.isArray(options.tools))
             throw new WorkflowError("INVALID_METADATA", "Agents require label, cwd, and tools");
+        const inheritedTools = options.tools;
         if (!parent)
-            return Object.freeze({ ...options, tools: Object.freeze([...options.tools]), ...(options.agentOptions ? { agentOptions: structuredClone(options.agentOptions) } : {}), ...(options.agentIdentity ? { agentIdentity: Object.freeze({ ...options.agentIdentity, structuralPath: Object.freeze([...options.agentIdentity.structuralPath]) }) } : {}) });
+            return Object.freeze({ ...options, tools: Object.freeze([...inheritedTools]), ...(options.agentOptions ? { agentOptions: structuredClone(options.agentOptions) } : {}), ...(options.agentIdentity ? { agentIdentity: Object.freeze({ ...options.agentIdentity, structuralPath: Object.freeze([...options.agentIdentity.structuralPath]) }) } : {}) });
         if (options.cwd !== parent.options.cwd)
             throw new WorkflowError("UNKNOWN_TOOL", "Child cwd cannot differ from its parent");
-        const forbidden = options.tools.find((tool) => !parent.options.tools.includes(tool));
+        const forbidden = inheritedTools.find((tool) => !parent.options.tools.includes(tool));
         if (forbidden)
             throw new WorkflowError("UNKNOWN_TOOL", `Child tool escalates parent boundary: ${forbidden}`);
         const identity = options.agentIdentity ?? parent.options.agentIdentity;
-        return Object.freeze({ ...options, cwd: parent.options.cwd, tools: Object.freeze([...options.tools]), ...(options.agentOptions ? { agentOptions: structuredClone(options.agentOptions) } : {}), ...(parent.options.parentBreadcrumb && !options.parentBreadcrumb ? { parentBreadcrumb: parent.options.parentBreadcrumb } : {}), ...(identity ? { agentIdentity: Object.freeze({ ...identity, structuralPath: Object.freeze([...identity.structuralPath]) }) } : {}), ...(parent.options.worktreeOwner ? { worktreeOwner: parent.options.worktreeOwner } : {}) });
+        return Object.freeze({ ...options, cwd: parent.options.cwd, tools: Object.freeze([...inheritedTools]), ...(options.agentOptions ? { agentOptions: structuredClone(options.agentOptions) } : {}), ...(parent.options.parentBreadcrumb && !options.parentBreadcrumb ? { parentBreadcrumb: parent.options.parentBreadcrumb } : {}), ...(identity ? { agentIdentity: Object.freeze({ ...identity, structuralPath: Object.freeze([...identity.structuralPath]) }) } : {}), ...(parent.options.worktreeOwner ? { worktreeOwner: parent.options.worktreeOwner } : {}) });
     }
-    /* eslint-enable @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-argument, @typescript-eslint/restrict-template-expressions */
     #enqueue(runId, node, start) { this.#runs.get(runId)?.queue.push({ ...(node ? { node } : {}), start }); this.#dispatch(); }
     #dispatch() {
         while (this.#active < this.sessionLimit && this.#runOrder.length) {

package/dist/src/ambient-workflow-evals.js

@@ -1,12 +1,13 @@
 import { spawn } from "node:child_process";
 import { execFileSync } from "node:child_process";
 import { randomUUID } from "node:crypto";
-import { existsSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, rmSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, mkdtempSync, readdirSync, rmSync, writeFileSync } from "node:fs";
 import { homedir, tmpdir } from "node:os";
 import { join, relative } from "node:path";
 import { fileURLToPath } from "node:url";
 import { CAPTURE_IDENTITY } from "./eval-capture-extension.js";
-import { extractCapturedWorkflows, extractParentOracleFile } from "./workflow-evals.js";
+import { isObject } from "./index.js";
+import { extractCapturedWorkflows, extractParentOracleFile, findSessionFile } from "./workflow-evals.js";
 export const AMBIENT_OPT_IN = "PI_WORKFLOW_EVAL_AMBIENT";
 export const AMBIENT_CAPTURE_NOTE = "Ambient Tier D uses the explicit capture extension. Pi 0.80.6 orders CLI extensions before discovered extensions and the first tool registration wins, so ambient tools and skills remain available while workflow execution stays capture-only.";
 export const AMBIENT_INVOCATION_MODE = "ambient-capture-only";
@@ -234,34 +235,12 @@ function emptyAccounting() {
 function ambientAgentDir(environment) {
     return environment.PI_CODING_AGENT_DIR ?? process.env.PI_CODING_AGENT_DIR ?? join(homedir(), ".pi", "agent");
 }
-function isObject(value) { return typeof value === "object" && value !== null && !Array.isArray(value); }
-function findSessionFile(directory, sessionId) {
-    if (!existsSync(directory))
-        return undefined;
-    for (const entry of readdirSync(directory, { withFileTypes: true })) {
-        const path = join(directory, entry.name);
-        if (entry.isDirectory()) {
-            const found = findSessionFile(path, sessionId);
-            if (found)
-                return found;
-        }
-        else if (entry.name.endsWith(".jsonl")) {
-            try {
-                const header = JSON.parse(readFileSync(path, "utf8").split("\n")[0] ?? "{}");
-                if (isObject(header) && header.id === sessionId)
-                    return path;
-            }
-            catch { /* Ignore incomplete sessions. */ }
-        }
-    }
-    return undefined;
-}
 function emptyResult(candidate, repository, worktree, environment, error) {
     const accounting = emptyAccounting();
     return {
         id: candidate.id, status: "failed", workflows: [], accounting, accountingTrustworthy: false, diagnostics: [], errors: [error],
         manifest: {
-            invocationMode: AMBIENT_INVOCATION_MODE, fixtureRoot: repository.fixtureRoot, worktreePath: worktree.path, ambientAgentDir: ambientAgentDir(environment), fixtureFileList: worktree.fixtureFiles, gitStatusBefore: worktree.gitStatusBefore, gitStatusAfter: worktree.gitStatusBefore, parentToolSequence: [], skillReads: [], workflowCalls: [], workflowCallCount: 0, tokenCost: accounting,
+            invocationMode: AMBIENT_INVOCATION_MODE, fixtureRoot: repository.fixtureRoot, worktreePath: worktree.path, ambientAgentDir: ambientAgentDir(environment), fixtureFileList: worktree.fixtureFiles, gitStatusBefore: worktree.gitStatusBefore, parentToolSequence: [], skillReads: [], workflowCalls: [], workflowCallCount: 0, tokenCost: accounting,
             cleanup: { processExited: false, processGroupTerminated: false, worktreeRemoved: false, fixtureRepoRemoved: false, tempRootRemoved: false, captureIdentityVerified: false, realWorkflowAgentsLaunched: 0 },
         },
     };
@@ -271,12 +250,13 @@ async function runAmbientCase(repository, candidate, artifactsDir, environment,
     const sessionId = randomUUID();
     const sessionDir = join(repository.root, "sessions", candidate.id);
     let result;
-    let gitStatusAfter = worktree.gitStatusBefore;
+    let failure;
+    let gitStatusAfter;
     try {
         const pi = await runAmbientPiProcess({ worktree: worktree.path, sessionDir, sessionId, prompt: candidate.prompt, provider, model, ...(thinking ? { thinking } : {}), ...(piCommand ? { piCommand } : {}), timeoutMs: candidate.timeoutMs, maxCost: candidate.maxCost, environment });
         const sessionFile = findSessionFile(sessionDir, sessionId);
         if (!sessionFile)
-            result = emptyResult(candidate, repository, worktree, environment, "Ambient parent session was not written.");
+            failure = "Ambient parent session was not written.";
         else {
             const oracle = extractParentOracleFile(sessionFile);
             const workflows = extractCapturedWorkflows(oracle);
@@ -286,14 +266,14 @@ async function runAmbientCase(repository, candidate, artifactsDir, environment,
             result = {
                 id: candidate.id, status, workflows, accounting: oracle.usage, accountingTrustworthy: !pi.timedOut && !pi.budgetExceeded && pi.exitCode === 0, diagnostics: [pi.stderr].filter(Boolean), errors,
                 manifest: {
-                    invocationMode: AMBIENT_INVOCATION_MODE, fixtureRoot: repository.fixtureRoot, worktreePath: worktree.path, ambientAgentDir: ambientAgentDir(environment), fixtureFileList: worktree.fixtureFiles, gitStatusBefore: worktree.gitStatusBefore, gitStatusAfter, parentToolSequence: oracle.parentToolSequence, skillReads: oracle.skillReads, workflowCalls: workflows, workflowCallCount: oracle.workflowCallCount, tokenCost: oracle.usage,
+                    invocationMode: AMBIENT_INVOCATION_MODE, fixtureRoot: repository.fixtureRoot, worktreePath: worktree.path, ambientAgentDir: ambientAgentDir(environment), fixtureFileList: worktree.fixtureFiles, gitStatusBefore: worktree.gitStatusBefore, parentToolSequence: oracle.parentToolSequence, skillReads: oracle.skillReads, workflowCalls: workflows, workflowCallCount: oracle.workflowCallCount, tokenCost: oracle.usage,
                     cleanup: { processExited: pi.exitCode !== null, processGroupTerminated: pi.processGroupTerminated, worktreeRemoved: false, fixtureRepoRemoved: false, tempRootRemoved: false, captureIdentityVerified, realWorkflowAgentsLaunched: 0 },
                 },
             };
         }
     }
     catch (error) {
-        result = emptyResult(candidate, repository, worktree, environment, error instanceof Error ? error.message : String(error));
+        failure = error instanceof Error ? error.message : String(error);
     }
     finally {
         try {
@@ -304,12 +284,13 @@ async function runAmbientCase(repository, candidate, artifactsDir, environment,
         }
         const worktreeRemoved = removeAmbientCaseWorktree(repository, worktree);
         if (!result)
-            result = emptyResult(candidate, repository, worktree, environment, "Ambient case produced no result.");
+            result = emptyResult(candidate, repository, worktree, environment, failure ?? "Ambient case produced no result.");
         const cleanup = { ...result.manifest.cleanup, worktreeRemoved };
-        result = { ...result, manifest: { ...result.manifest, gitStatusAfter, cleanup } };
-        writeFileSync(join(artifactsDir, `${candidate.id}.json`), `${JSON.stringify(result, null, 2)}\n`, { mode: 0o600 });
+        result = { ...result, manifest: { ...result.manifest, cleanup } };
     }
-    return result;
+    const finalized = { ...result, manifest: { ...result.manifest, gitStatusAfter } };
+    writeFileSync(join(artifactsDir, `${candidate.id}.json`), `${JSON.stringify(finalized, null, 2)}\n`, { mode: 0o600 });
+    return finalized;
 }
 export function assertAmbientOptIn(environment = process.env) {
     if (environment[AMBIENT_OPT_IN] !== "1")

package/dist/src/doctor.js

@@ -2,7 +2,7 @@ import { readFileSync, readdirSync, realpathSync } from "node:fs";
 import { basename, dirname, extname, join, resolve } from "node:path";
 import { InMemoryCredentialStore } from "@earendil-works/pi-ai";
 import { ModelRuntime, createAgentSessionFromServices, createAgentSessionServices, getAgentDir, hasTrustRequiringProjectResources, SessionManager, SettingsManager, } from "@earendil-works/pi-coding-agent";
-import { DEFAULT_SETTINGS, loadSettings, parseModelReference, resolveAgentResourcePolicy, resolveModelReference, parseRoleMarkdown, preflight, registeredWorkflowDefinitions, workflowRoleDirectories, workflowProjectSettingsPath, workflowSettingsPath, WorkflowError, } from "./index.js";
+import { DEFAULT_SETTINGS, loadSettings, resolveAgentResourcePolicy, resolveModelReference, parseRoleMarkdown, preflight, registeredWorkflowDefinitions, workflowRoleDirectories, workflowProjectSettingsPath, workflowSettingsPath, WorkflowError, } from "./index.js";
 const THINKING_HINT = "Use off, minimal, low, medium, high, xhigh, or max.";
 function canonical(path) {
     const absolute = resolve(path);
@@ -153,9 +153,6 @@ function inspectRole(path, activeTools, knownModels, availableModels, diagnostic
             diagnostics.push(diagnostic("error", "ROLE_TOOL_INACTIVE", `Tool is unknown or inactive: ${tool}`, path, "Use a tool listed under Active tools or enable its Pi extension."));
     return definition;
 }
-class DoctorModelSet extends Set {
-    has(value) { parseModelReference(value); return true; }
-}
 function matchResourcePolicy(policy, pi) {
     const extensions = new Set((pi.extensions ?? []).map(canonical));
     const skills = new Set(pi.skills ?? []);
@@ -245,12 +242,13 @@ export async function doctor(options = {}) {
         let valid = true;
         try {
             const checked = preflight(workflow.script, {
-                models: new DoctorModelSet(pi.knownModels),
+                models: new Set(pi.knownModels),
                 tools: activeTools,
                 agentTypes: new Set(definitions.keys()),
                 modelAliases: aliases,
                 knownModels,
                 settingsPath,
+                skipModelAvailability: true,
             }, [], { name, description: workflow.description });
             for (const model of checked.referenced.models)
                 if (!knownModels.has(model) || !availableModels.has(model))

package/dist/src/index.d.ts

@@ -5,8 +5,8 @@ import { RunStore } from "./persistence.js";
 import type { AwaitingCheckpoint, PersistedRun, WorktreeReference } from "./persistence.js";
 export declare const RUN_STATES: readonly ["queued", "running", "pausing", "paused", "awaiting_input", "completed", "failed", "stopped", "interrupted", "budget_exhausted"];
 export declare const AGENT_STATES: readonly ["queued", "running", "waiting_for_child", "paused", "retrying", "completed", "failed", "cancelled"];
-export declare const WORKFLOW_ASYNC_STARTED_EVENT = "workflow:async-started";
-export declare const WORKFLOW_ASYNC_COMPLETE_EVENT = "workflow:async-complete";
+export declare const WORKFLOW_CALL_KINDS: readonly ["agent", "conversation", "parallel", "pipeline", "checkpoint", "phase", "withWorktree"];
+export type WorkflowCallKind = (typeof WORKFLOW_CALL_KINDS)[number];
 export declare const WORKFLOW_RUN_STARTED_EVENT = "workflow:run-started";
 export declare const WORKFLOW_RUN_RESUMED_EVENT = "workflow:run-resumed";
 export declare const WORKFLOW_RUN_STATE_CHANGED_EVENT = "workflow:run-state-changed";
@@ -215,7 +215,7 @@ export interface AgentRecord {
     activity?: AgentActivity | undefined;
 }
 export interface WorkflowRunEvent {
-    type: "warning";
+    type: string;
     message: string;
 }
 export interface RunRecord {
@@ -290,6 +290,7 @@ export interface WorkflowRunContext {
 }
 export interface WorkflowFunctionContext extends WorkflowOrchestrationContext {
     run: Readonly<WorkflowRunContext>;
+    invoke: (name: string, input: Readonly<Record<string, JsonValue>>) => Promise<JsonValue>;
 }
 export interface WorkflowFunction {
     description: string;
@@ -339,6 +340,8 @@ export declare class RunLifecycle {
     terminal(state: "completed" | "failed" | "stopped" | "interrupted" | "budget_exhausted", reason?: string): Promise<void>;
 }
 export declare const DEFAULT_SETTINGS: Readonly<WorkflowSettings>;
+declare function object(value: unknown): value is Record<string, unknown>;
+export { object as isObject };
 export declare function validateBudget(value: unknown): WorkflowBudget | undefined;
 export declare function validateBudgetPatch(value: unknown): WorkflowBudgetPatch;
 export declare class WorkflowBudgetRuntime {
@@ -395,7 +398,7 @@ export interface StaticWorkflowScope {
     key: string | null;
 }
 export interface StaticWorkflowCall {
-    kind: "agent" | "conversation" | "parallel" | "pipeline" | "checkpoint" | "phase" | "withWorktree";
+    kind: WorkflowCallKind;
     start: number;
     end: number;
     name: string | null;