pi-subagents 0.53.0 → 0.55.0

package/src/watchdog/permission-arbiter.ts

@@ -45,7 +45,11 @@ export function createWatchdogPermissionArbiter(options: WatchdogPermissionArbit
 		const createdAt = Date.now();
 		const auditBase = { type: "permission.request", createdAt, toolName: request.toolName, preview, matchedRule: "ask", decisionSource: "watchdog" };
 		appendPermissionAudit(request.auditPath, auditBase);
+		let completed = false;
 		const finish = (approved: boolean, reason: string, decision: string): WatchdogPermissionResult => {
+			const concise = conciseReason(reason);
+			if (completed) return { approved, reason: concise, source: "watchdog" };
+			completed = true;
 			appendPermissionAudit(request.auditPath, {
 				type: "permission.decision",
 				createdAt: Date.now(),
@@ -54,9 +58,9 @@ export function createWatchdogPermissionArbiter(options: WatchdogPermissionArbit
 				decision,
 				approved,
 				decisionSource: "watchdog",
-				reason: conciseReason(reason),
+				reason: concise,
 			});
-			return { approved, reason: conciseReason(reason), source: "watchdog" };
+			return { approved, reason: concise, source: "watchdog" };
 		};
 
 		let childConfig;
@@ -84,61 +88,65 @@ export function createWatchdogPermissionArbiter(options: WatchdogPermissionArbit
 
 		let timeout: ReturnType<typeof setTimeout> | undefined;
 		let agent: Agent | undefined;
+		let abort: (() => void) | undefined;
 		try {
-			const config = childResolvedConfig(childConfig);
-			const selection = await resolveWatchdogReviewModel(request.ctx, config);
-			const auth = selection.auth;
-			const registeredProvider = (request.ctx.modelRegistry as {
-				getRegisteredProviderConfig?: (provider: string) => { api?: string; streamSimple?: StreamFn } | undefined;
-			}).getRegisteredProviderConfig?.(selection.model.provider);
-			const baseStreamFn = options.streamFn ?? (registeredProvider?.streamSimple && registeredProvider.api === selection.model.api
-				? registeredProvider.streamSimple
-				: streamSimple);
-			const streamFn: StreamFn = (model, context, streamOptions) => baseStreamFn(model, context, {
-				...streamOptions,
-				...(auth.apiKey ? { apiKey: auth.apiKey } : {}),
-				env: auth.env || streamOptions?.env ? { ...(auth.env ?? {}), ...(streamOptions?.env ?? {}) } : undefined,
-				headers: { ...(streamOptions?.headers ?? {}), ...(auth.headers ?? {}) },
-			});
-			agent = new Agent({
-				initialState: {
-					systemPrompt: [
-						"You are the pi-subagents watchdog permission arbiter.",
-						"Decide only whether this exact non-bash child tool call should proceed.",
-						"Call watchdog_permission_decision exactly once with approve or deny and a concise reason.",
-						"Deny when uncertain. Do not produce freeform advice or ask the parent orchestrator.",
-					].join("\n"),
-					model: selection.model,
-					thinkingLevel: selection.thinkingLevel,
-					tools: [tool],
-				},
-				convertToLlm,
-				...agentStreamOptions(streamFn),
-				getApiKey: (providerName) => providerName === selection.model.provider ? auth.apiKey : undefined,
-				beforeToolCall: async ({ toolCall }) => toolCall.name === tool.name ? undefined : { block: true, reason: `Permission arbiter tool '${toolCall.name}' is not allowed.` },
-				toolExecution: "sequential",
-			});
-			const abort = () => agent?.abort();
-			request.signal?.addEventListener("abort", abort, { once: true });
-			request.ctx.signal?.addEventListener("abort", abort, { once: true });
-			try {
-				const prompt = `Tool: ${request.toolName}\nRedacted arguments: ${preview}`;
-				await Promise.race([
-					agent.prompt(prompt),
-					new Promise<never>((_, reject) => { timeout = setTimeout(() => { agent?.abort(); reject(new Error("Watchdog permission decision timed out.")); }, childConfig.agentEndTimeoutMs); }),
-				]);
-			} finally {
-				request.signal?.removeEventListener("abort", abort);
-				request.ctx.signal?.removeEventListener("abort", abort);
-			}
-			if (!decision) return finish(false, "Watchdog permission arbiter returned no decision.", "malformed");
-			const approved = decision.decision === "approve";
-			return finish(approved, decision.reason, decision.decision);
+			const run = async (): Promise<WatchdogPermissionResult> => {
+				const config = childResolvedConfig(childConfig);
+				const selection = await resolveWatchdogReviewModel(request.ctx, config);
+				const auth = selection.auth;
+				const registeredProvider = (request.ctx.modelRegistry as {
+					getRegisteredProviderConfig?: (provider: string) => { api?: string; streamSimple?: StreamFn } | undefined;
+				}).getRegisteredProviderConfig?.(selection.model.provider);
+				const baseStreamFn = options.streamFn ?? (registeredProvider?.streamSimple && registeredProvider.api === selection.model.api
+					? registeredProvider.streamSimple
+					: streamSimple);
+				const streamFn: StreamFn = (model, context, streamOptions) => baseStreamFn(model, context, {
+					...streamOptions,
+					...(auth.apiKey ? { apiKey: auth.apiKey } : {}),
+					env: auth.env || streamOptions?.env ? { ...(auth.env ?? {}), ...(streamOptions?.env ?? {}) } : undefined,
+					headers: { ...(streamOptions?.headers ?? {}), ...(auth.headers ?? {}) },
+				});
+				agent = new Agent({
+					initialState: {
+						systemPrompt: [
+							"You are the pi-subagents watchdog permission arbiter.",
+							"Decide only whether this exact non-bash child tool call should proceed.",
+							"Call watchdog_permission_decision exactly once with approve or deny and a concise reason.",
+							"Deny when uncertain. Do not produce freeform advice or ask the parent orchestrator.",
+						].join("\n"),
+						model: selection.model,
+						thinkingLevel: selection.thinkingLevel,
+						tools: [tool],
+					},
+					convertToLlm,
+					...agentStreamOptions(streamFn),
+					getApiKey: (providerName) => providerName === selection.model.provider ? auth.apiKey : undefined,
+					beforeToolCall: async ({ toolCall }) => toolCall.name === tool.name ? undefined : { block: true, reason: `Permission arbiter tool '${toolCall.name}' is not allowed.` },
+					toolExecution: "sequential",
+				});
+				await agent.prompt(`Tool: ${request.toolName}\nRedacted arguments: ${preview}`);
+				if (!decision) return finish(false, "Watchdog permission arbiter returned no decision.", "malformed");
+				const approved = decision.decision === "approve";
+				return finish(approved, decision.reason, decision.decision);
+			};
+			return await Promise.race([
+				run(),
+				new Promise<WatchdogPermissionResult>((resolve) => { timeout = setTimeout(() => { agent?.abort(); resolve(finish(false, "Watchdog permission decision timed out.", "timeout")); }, childConfig.agentEndTimeoutMs); }),
+				new Promise<WatchdogPermissionResult>((resolve) => {
+					abort = () => { agent?.abort(); resolve(finish(false, "Watchdog permission decision was cancelled.", "cancelled")); };
+					request.signal?.addEventListener("abort", abort, { once: true });
+					request.ctx.signal?.addEventListener("abort", abort, { once: true });
+				}),
+			]);
 		} catch (error) {
 			const reason = error instanceof Error ? error.message : String(error);
 			return finish(false, `Watchdog permission arbiter failed closed: ${reason}`, reason.includes("timed out") ? "timeout" : "error");
 		} finally {
 			if (timeout) clearTimeout(timeout);
+			if (abort) {
+				request.signal?.removeEventListener("abort", abort);
+				request.ctx.signal?.removeEventListener("abort", abort);
+			}
 		}
 	};
 }

package/src/workflows/scripted-workflow.ts

@@ -242,6 +242,33 @@ function runHostCall(key, params, collectFailure, batch) {
   return { key, callId, promise };
 }
 
+function isArrayIndexProperty(prop) {
+  if (!/^(0|[1-9]\d*)$/.test(prop)) return false;
+  const index = Number(prop);
+  return Number.isSafeInteger(index) && index >= 0 && index < 4294967295;
+}
+
+const runsAllResultTargets = new WeakMap();
+
+function runsAllKeyAccessError(prop) {
+  return new Error("Cannot read runs.all result property '" + prop + "'. runs.all resolves to an ordered array, not a key map. Use results[0], array destructuring, or results.map((result) => result.output), not results." + prop + ".");
+}
+
+function wrapRunsAllResults(results, keys) {
+  const keySet = new Set(keys);
+  const proxy = new Proxy(results, {
+    get(target, prop, receiver) {
+      if (typeof prop !== "string") return Reflect.get(target, prop, receiver);
+      if (prop === "then" || prop === "toJSON") return undefined;
+      if (prop in target || isArrayIndexProperty(prop)) return Reflect.get(target, prop, receiver);
+      if (keySet.has(prop)) throw runsAllKeyAccessError(prop);
+      throw runsAllKeyAccessError(prop);
+    },
+  });
+  runsAllResultTargets.set(proxy, results);
+  return proxy;
+}
+
 function formatRef(result) {
   if (!result || typeof result !== "object") throw new Error("runs.ref(result) requires a run result object.");
   const parts = ["run " + (result.key || "unknown")];
@@ -302,7 +329,7 @@ const runs = Object.freeze({
     runFingerprints = fingerprints;
     const batch = { id: "batch-" + (++nextCallId), calls };
     const launched = calls.map(({ key, params }) => runHostCall(key, params, true, batch));
-    return trackRunObservation(launched.map(({ key, callId }) => ({ key, operation: "run", callId })), Promise.all(launched.map(({ promise }) => promise)));
+    return trackRunObservation(launched.map(({ key, callId }) => ({ key, operation: "run", callId })), Promise.all(launched.map(({ promise }) => promise)).then((results) => wrapRunsAllResults(results, calls.map(({ key }) => key))));
   },
   steer(key, message, options = {}) {
     if (typeof key !== "string" || !runKeyPattern.test(key)) throw new Error("runs.steer has an invalid key.");
@@ -431,6 +458,31 @@ function isPlainWorkflowObject(value) {
   return prototype === null || prototype === Object.prototype || prototype === contextObjectPrototype;
 }
 
+function unwrapRunsAllResults(value, seen = new Map()) {
+  if (value === null || typeof value !== "object") return value;
+  const runsAllTarget = runsAllResultTargets.get(value);
+  const target = runsAllTarget || value;
+  if (seen.has(target)) return seen.get(target);
+  if (Array.isArray(target)) {
+    const copy = [];
+    seen.set(target, copy);
+    let changed = !!runsAllTarget;
+    for (let index = 0; index < target.length; index++) {
+      copy[index] = unwrapRunsAllResults(target[index], seen);
+      changed ||= copy[index] !== target[index];
+    }
+    return changed ? copy : target;
+  }
+  if (!isPlainWorkflowObject(target) || Object.getOwnPropertySymbols(target).length > 0) return target;
+  let changed = false;
+  const entries = Object.entries(target).map(([key, entry]) => {
+    const unwrapped = unwrapRunsAllResults(entry, seen);
+    changed ||= unwrapped !== entry;
+    return [key, unwrapped];
+  });
+  return changed ? Object.fromEntries(entries) : target;
+}
+
 function omitUndefinedWorkflowValues(value, seen = new Set()) {
   if (value === null || typeof value !== "object") return value;
   if (seen.has(value)) return value;
@@ -459,7 +511,7 @@ parentPort.on("message", async (message) => {
   }
   if (message.type !== "start") return;
   try {
-    const sandbox = { runs, Promise: workflowPromise, emit(value) { assertJsonValue(value); parentPort.postMessage({ type: "emit", value }); }, console: capturedConsole };
+    const sandbox = { runs, Promise: workflowPromise, emit(value) { const emittedValue = unwrapRunsAllResults(value); assertJsonValue(emittedValue); parentPort.postMessage({ type: "emit", value: emittedValue }); }, console: capturedConsole };
     if (message.stateEnabled) sandbox.state = state;
     const context = vm.createContext(sandbox, { codeGeneration: { strings: false, wasm: false } });
     contextObjectPrototype = vm.runInContext("Object.prototype", context);
@@ -540,6 +592,7 @@ parentPort.on("message", async (message) => {
 export interface WorkflowScriptChildResult {
 	key: string;
 	ok: boolean;
+	stopped?: boolean;
 	/** Canonical child agent name when launch resolution produced one. */
 	agent?: string;
 	runId?: string;
@@ -628,10 +681,27 @@ export interface RunWorkflowScriptOptions {
 		get: (key: string) => unknown | Promise<unknown>;
 		set: (key: string, value: unknown) => void | Promise<void>;
 	};
+	registerStopChild?: (stop: ((key: string, message?: string) => boolean) | undefined) => void;
 	onTrace?: (trace: WorkflowScriptTraceEntry[]) => void;
 	onEmit?: (emits: unknown[]) => void;
 }
 
+function combinedAbortSignal(signals: AbortSignal[]): AbortSignal {
+	const controller = new AbortController();
+	const abort = (signal: AbortSignal): void => {
+		if (controller.signal.aborted) return;
+		controller.abort(signal.reason);
+	};
+	for (const signal of signals) {
+		if (signal.aborted) {
+			abort(signal);
+			break;
+		}
+		signal.addEventListener("abort", () => abort(signal), { once: true });
+	}
+	return controller.signal;
+}
+
 function isRecord(value: unknown): value is Record<string, unknown> {
 	return !!value && typeof value === "object" && !Array.isArray(value);
 }
@@ -795,6 +865,7 @@ export async function runWorkflowScript(options: RunWorkflowScriptOptions): Prom
 	const launches = new Map<string, { fingerprint: string; promise: Promise<WorkflowScriptChildResult>; observed: boolean }>();
 	const steers = new Map<number, { key: string; promise: Promise<WorkflowSteerResult>; observed: boolean }>();
 	const stoppedLaunches = new Set<string>();
+	const childStopControllers = new Map<string, AbortController>();
 	const batchAdmissions = new Map<string, Promise<void>>();
 	const observedRunCalls = new Set<number>();
 	const observedSteerCalls = new Set<number>();
@@ -818,6 +889,26 @@ export async function runWorkflowScript(options: RunWorkflowScriptOptions): Prom
 			console.error("Workflow onTrace callback failed:", error);
 		}
 	};
+	const stoppedChildResult = (key: string, message: string): WorkflowScriptChildResult => ({ key, ok: false, stopped: true, output: message, error: message, artifactPaths: [] });
+	const stopChild = (key: string, message = `Workflow child '${key}' stopped by user.`): boolean => {
+		if (!launches.has(key) || children.has(key)) return false;
+		stoppedLaunches.add(key);
+		children.set(key, stoppedChildResult(key, message));
+		childStopControllers.get(key)?.abort(new Error(message));
+		const started = trace.findLast((entry) => entry.operation === "run" && entry.key === key && entry.state === "started");
+		trace.push({
+			operation: "run",
+			key,
+			state: "stopped",
+			...(started?.agent ? { agent: started.agent } : {}),
+			...(started?.phase ? { phase: started.phase } : {}),
+			...(started?.label ? { label: started.label } : {}),
+			error: message,
+		});
+		traceChanged();
+		return true;
+	};
+	options.registerStopChild?.(stopChild);
 
 	return await new Promise<WorkflowScriptResult>((resolve, reject) => {
 		const finish = (outcome: { value: unknown } | { error: Error & { workflowErrorKind?: unknown } }) => {
@@ -827,6 +918,7 @@ export async function runWorkflowScript(options: RunWorkflowScriptOptions): Prom
 			void Promise.allSettled([...steers.values()].map(({ promise }) => promise)).then(() => {
 				if (settled) return;
 				settled = true;
+				options.registerStopChild?.(undefined);
 				if (timer) clearTimeout(timer);
 				options.signal?.removeEventListener("abort", onAbort);
 				void worker.terminate();
@@ -1061,7 +1153,7 @@ export async function runWorkflowScript(options: RunWorkflowScriptOptions): Prom
 			const deliver = (promise: Promise<WorkflowScriptChildResult>) => collectFailure
 				? promise
 				: promise.then((result) => {
-					if (!result.ok) {
+					if (!result.ok && !result.stopped) {
 						const childError = new Error(result.detached ? `Run '${key}' detached: ${result.error ?? result.output}` : `Run '${key}' failed: ${result.error ?? result.output}`) as Error & { workflowErrorKind?: "detached-child" };
 						if (result.detached) childError.workflowErrorKind = "detached-child";
 						throw childError;
@@ -1100,13 +1192,16 @@ export async function runWorkflowScript(options: RunWorkflowScriptOptions): Prom
 			const promise = admission.then(async () => {
 				if (settled || finishing || stoppedLaunches.has(key)) {
 					const reason = childController.signal.reason;
-					const text = reason instanceof Error ? reason.message : typeof reason === "string" ? reason : "Workflow script aborted.";
-					return { key, ok: false, output: text, error: text, artifactPaths: [] };
+					const text = children.get(key)?.error ?? (reason instanceof Error ? reason.message : typeof reason === "string" ? reason : "Workflow script aborted.");
+					return stoppedChildResult(key, text);
 				}
+				const childStopController = new AbortController();
+				childStopControllers.set(key, childStopController);
+				const childSignal = combinedAbortSignal([childController.signal, childStopController.signal]);
 				const resolvedResumeValue = resumeReference
 					? await Promise.resolve().then(() => {
 						if (!options.resolveResume) throw new Error("Keyed workflow receipt resume is unavailable in this host.");
-						return options.resolveResume(resumeReference, childController.signal);
+						return options.resolveResume(resumeReference, childSignal);
 					})
 					: undefined;
 				const resolvedResume = typeof resolvedResumeValue === "string"
@@ -1124,22 +1219,24 @@ export async function runWorkflowScript(options: RunWorkflowScriptOptions): Prom
 					if (resolvedResumeLineage.at(-1) !== resolvedResumeId) resolvedResumeLineage.push(resolvedResumeId!);
 				}
 				const launchParams = resolvedResumeId ? { ...params, resume: resolvedResumeId } : params;
-				return options.launch(key, { ...launchParams, async: launchParams.async ?? false }, childController.signal, { admitted: true });
+				return options.launch(key, launchParams, childSignal, { admitted: true });
 			}).then((result) => {
 				let normalized = !result.ok && !result.error ? { ...result, error: result.output } : result;
 				if (resolvedResumeLineage?.length && normalized.runId) {
 					normalized = { ...normalized, continuation: { runIds: [...new Set([...resolvedResumeLineage, normalized.runId])] } };
 				}
-				if (stoppedLaunches.has(key)) return normalized;
+				childStopControllers.delete(key);
+				if (stoppedLaunches.has(key)) return children.get(key) ?? normalized;
 				children.set(key, normalized);
-				const state = normalized.ok ? "completed" : normalized.detached ? "detached" : "failed";
+				const state = normalized.ok ? "completed" : normalized.stopped ? "stopped" : normalized.detached ? "detached" : "failed";
 				trace.push({ operation: "run", key, state, durationMs: Date.now() - startedAt, ...workflowStringMetadata(params), ...(normalized.agent ? { agent: normalized.agent } : {}), ...(normalized.runId ? { runId: normalized.runId } : {}), ...(!normalized.ok ? { error: normalized.error ?? normalized.output } : {}) });
 				traceChanged();
 				return normalized;
 			}, (error: unknown) => {
 				const text = error instanceof Error ? error.message : String(error);
 				const failure: WorkflowScriptChildResult = { key, ok: false, output: text, error: text, artifactPaths: [] };
-				if (stoppedLaunches.has(key)) return failure;
+				childStopControllers.delete(key);
+				if (stoppedLaunches.has(key)) return children.get(key) ?? { ...failure, stopped: true };
 				children.set(key, failure);
 				trace.push({ operation: "run", key, state: "failed", durationMs: Date.now() - startedAt, ...workflowStringMetadata(params), error: text });
 				traceChanged();