@agwab/pi-workflow 0.2.0 → 0.3.0

package/dist/subagent-backend.js

@@ -1,6 +1,7 @@
 import { existsSync } from "node:fs";
 import { copyFile, mkdir, readFile, readdir, rm, writeFile, } from "node:fs/promises";
 import { delimiter, dirname, extname, isAbsolute, join, relative, resolve, sep, } from "node:path";
+import { availableParallelism } from "node:os";
 import { fileURLToPath } from "node:url";
 import { fromProjectPath, isTerminalTaskStatus, nowIso, toProjectPath, writeRunRecord, } from "./store.js";
 import { applyTaskResultArtifact, isTaskTimedOut, markTaskTimedOut, } from "./result.js";
@@ -15,6 +16,15 @@ const FETCH_CONTENT_CACHE_ENV = "PI_WORKFLOW_FETCH_CONTENT_CACHE";
 const LEGACY_FETCH_CACHE_ENV = "PI_WORKFLOW_FETCH_CACHE";
 const DEFAULT_TRANSIENT_MODEL_FAILURE_RETRIES = 5;
 const DEFAULT_ARTIFACT_OUTPUT_RETRIES = 2;
+const MAX_CONCURRENT_LAUNCHES_ENV = "PI_WORKFLOW_MAX_CONCURRENT_LAUNCHES";
+const PARENT_SUBAGENT_CWD_ENV = "PI_WORKFLOW_PARENT_SUBAGENT_CWD";
+const PARENT_SUBAGENT_RUNS_DIR_ENV = "PI_WORKFLOW_PARENT_SUBAGENT_RUNS_DIR";
+const PARENT_SUBAGENT_RUN_ID_ENV = "PI_WORKFLOW_PARENT_SUBAGENT_RUN_ID";
+const PARENT_SUBAGENT_ATTEMPT_ID_ENV = "PI_WORKFLOW_PARENT_SUBAGENT_ATTEMPT_ID";
+const DEFAULT_LAUNCH_SLOT_RELEASE_DELAY_MS = 3_000;
+const STALE_LAUNCH_CLAIM_GRACE_MS = 30_000;
+const MIN_TRANSIENT_RETRY_JITTER_MS = 1_000;
+const MAX_TRANSIENT_RETRY_JITTER_MS = 5_000;
 const MODULE_PATH = fileURLToPath(import.meta.url);
 const MODULE_DIR = dirname(MODULE_PATH);
 const BUNDLED_PI_WEB_ACCESS_EXTENSION = bundledNodeModulePath("pi-web-access", "index.ts");
@@ -34,6 +44,12 @@ function bundledNodeModulePath(packageName, ...parts) {
     ];
     return (candidates.find((candidate) => existsSync(candidate)) ?? candidates[0]);
 }
+const GENERIC_TASK_STATUS_DETAILS = new Set([
+    "completed",
+    "failed",
+    "interrupted",
+    "running",
+]);
 const subagentApiSpecifier = "@agwab/pi-subagent/api";
 let cachedSubagentApi;
 let injectedSubagentApi;
@@ -47,10 +63,143 @@ async function loadSubagentApi() {
     cachedSubagentApi ??= import(subagentApiSpecifier).then((mod) => mod);
     return cachedSubagentApi;
 }
+function nonEmptyEnv(env, key) {
+    const value = env[key]?.trim();
+    return value ? value : undefined;
+}
+function parentSubagentRefFromEnv(env = process.env) {
+    const cwd = nonEmptyEnv(env, PARENT_SUBAGENT_CWD_ENV);
+    const runsDir = nonEmptyEnv(env, PARENT_SUBAGENT_RUNS_DIR_ENV);
+    const runId = nonEmptyEnv(env, PARENT_SUBAGENT_RUN_ID_ENV);
+    if (!cwd || !runsDir || !runId)
+        return undefined;
+    const attemptId = nonEmptyEnv(env, PARENT_SUBAGENT_ATTEMPT_ID_ENV);
+    return { cwd, runsDir, runId, ...(attemptId ? { attemptId } : {}) };
+}
+function terminalChildEventForTaskStatus(status) {
+    if (status === "completed")
+        return "completed";
+    if (status === "failed")
+        return "failed";
+    if (status === "interrupted")
+        return "cancelled";
+    return undefined;
+}
+async function recordParentSubagentChildEvent(options) {
+    const parent = parentSubagentRefFromEnv();
+    if (!parent)
+        return;
+    const api = await loadSubagentApi().catch(() => undefined);
+    if (!api?.recordSubagentChildEvent)
+        return;
+    await api
+        .recordSubagentChildEvent({
+        ...parent,
+        event: options.event,
+        childRunId: options.childRunId,
+        workflowRunId: options.run.runId,
+        childTaskId: options.task.taskId,
+        ...(options.failureKind === undefined
+            ? {}
+            : { failureKind: options.failureKind }),
+        ...(options.message === undefined ? {} : { message: options.message }),
+    })
+        .catch(() => undefined);
+}
+async function recordTerminalParentSubagentChildEvent(run, task, snapshot) {
+    const event = terminalChildEventForTaskStatus(task.status);
+    if (!event)
+        return;
+    const taskFailureKind = task.statusDetail && !GENERIC_TASK_STATUS_DETAILS.has(task.statusDetail)
+        ? task.statusDetail
+        : undefined;
+    await recordParentSubagentChildEvent({
+        event,
+        childRunId: snapshot.runId,
+        run,
+        task,
+        failureKind: event === "completed"
+            ? undefined
+            : (snapshot.failureKind ?? taskFailureKind ?? task.statusDetail),
+        message: task.lastMessage,
+    });
+}
+let launchSlotReleaseDelayMs = DEFAULT_LAUNCH_SLOT_RELEASE_DELAY_MS;
+let transientRetryJitterForTests;
+const launchWaitQueue = [];
+let activeLaunchSlots = 0;
+function resolveMaxConcurrentLaunches() {
+    const override = Number.parseInt(process.env[MAX_CONCURRENT_LAUNCHES_ENV] ?? "", 10);
+    if (Number.isFinite(override))
+        return Math.max(1, Math.floor(override));
+    return Math.max(2, Math.floor(availableParallelism() / 2));
+}
+function isLaunchGateSaturated() {
+    return activeLaunchSlots >= resolveMaxConcurrentLaunches();
+}
+async function acquireLaunchSlot() {
+    if (!isLaunchGateSaturated()) {
+        activeLaunchSlots += 1;
+        return releaseLaunchSlot;
+    }
+    await new Promise((resolveWait) => launchWaitQueue.push(resolveWait));
+    return releaseLaunchSlot;
+}
+function releaseLaunchSlot() {
+    const next = launchWaitQueue.shift();
+    if (next) {
+        // Transfer the occupied slot directly to the queued launcher.
+        next();
+        return;
+    }
+    activeLaunchSlots = Math.max(0, activeLaunchSlots - 1);
+}
+function releaseLaunchSlotAfterDelay(delayMs, release) {
+    if (delayMs <= 0) {
+        release();
+        return;
+    }
+    setTimeout(release, delayMs);
+}
+async function runWithLaunchSlot(action) {
+    const release = await acquireLaunchSlot();
+    let holdAfterReturn = false;
+    try {
+        const result = await action();
+        holdAfterReturn = true;
+        return result;
+    }
+    finally {
+        releaseLaunchSlotAfterDelay(holdAfterReturn ? launchSlotReleaseDelayMs : 0, release);
+    }
+}
+function transientRetryJitterMs() {
+    if (transientRetryJitterForTests)
+        return transientRetryJitterForTests();
+    return (MIN_TRANSIENT_RETRY_JITTER_MS +
+        Math.floor(Math.random() *
+            (MAX_TRANSIENT_RETRY_JITTER_MS - MIN_TRANSIENT_RETRY_JITTER_MS + 1)));
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+export function setSubagentLaunchControlsForTests(options) {
+    launchSlotReleaseDelayMs =
+        options?.releaseDelayMs === undefined
+            ? DEFAULT_LAUNCH_SLOT_RELEASE_DELAY_MS
+            : Math.max(0, Math.floor(options.releaseDelayMs));
+    transientRetryJitterForTests =
+        options?.retryJitterMs === undefined
+            ? undefined
+            : typeof options.retryJitterMs === "function"
+                ? options.retryJitterMs
+                : () => Math.max(0, Math.floor(options.retryJitterMs));
+    activeLaunchSlots = 0;
+    while (launchWaitQueue.length > 0)
+        launchWaitQueue.shift()?.();
+}
 export async function cleanupSubagentRun(_cwd, run) {
     for (const task of run.tasks) {
-        if (isTerminalTaskStatus(task.status))
-            continue;
         const handle = getSubagentHandle(task);
         if (!handle)
             continue;
@@ -77,6 +226,14 @@ export async function launchSubagentTask(cwd, run, task, compiledTask) {
             message: "fast:on is not supported for pi-workflow execution.",
         };
     }
+    if ((task.launchRetry?.attempts ?? 0) > 0) {
+        const jitterMs = transientRetryJitterMs();
+        task.statusDetail = "retry_model_failure";
+        task.lastMessage = `waiting ${jitterMs}ms before retrying transient-model launch`;
+        await writeRunRecord(cwd, run);
+        if (jitterMs > 0)
+            await sleep(jitterMs);
+    }
     const systemPromptFile = fromProjectPath(cwd, task.files.systemPrompt);
     const taskPromptFile = fromProjectPath(cwd, task.files.taskPrompt);
     const outputFile = fromProjectPath(cwd, task.files.output);
@@ -126,7 +283,11 @@ export async function launchSubagentTask(cwd, run, task, compiledTask) {
         subagentOptions.extensions = extensions;
         if (captureToolCallsEnabled())
             subagentOptions.captureToolCalls = true;
-        launched = await api.runSubagent(subagentOptions);
+        if (isLaunchGateSaturated()) {
+            task.lastMessage = `waiting for pi-subagent launch slot (${resolveMaxConcurrentLaunches()} max)`;
+            await writeRunRecord(cwd, run).catch(() => undefined);
+        }
+        launched = await runWithLaunchSlot(() => api.runSubagent(subagentOptions));
     }
     catch (error) {
         task.status = "pending";
@@ -148,6 +309,13 @@ export async function launchSubagentTask(cwd, run, task, compiledTask) {
     task.statusDetail = "running";
     task.lastMessage = "launched via pi-subagent/headless";
     await writeRunRecord(cwd, run).catch(() => undefined);
+    await recordParentSubagentChildEvent({
+        event: "started",
+        childRunId: launched.runId,
+        run,
+        task,
+        message: task.lastMessage,
+    });
     return { kind: "launched" };
 }
 export async function refreshRunFromSubagentArtifacts(cwd, run) {
@@ -174,8 +342,13 @@ export async function refreshRunFromSubagentArtifacts(cwd, run) {
             }
         }
         if (!handle) {
+            if (isStaleLaunchClaim(task)) {
+                resetStaleLaunchClaim(task);
+                changed = true;
+                continue;
+            }
             if (isTaskTimedOut(task)) {
-                markTaskTimedOut(task);
+                markSubagentTaskTimedOut(task);
                 changed = true;
             }
             continue;
@@ -198,16 +371,8 @@ export async function refreshRunFromSubagentArtifacts(cwd, run) {
             .catch(() => null);
         if (snapshot === null) {
             if (isTaskTimedOut(task)) {
-                await api
-                    .interruptSubagent({
-                    cwd: handle.cwd,
-                    runsDir: handle.runsDir,
-                    runId: handle.runId,
-                    attemptId: handle.attemptId,
-                    reason: "workflow timeout",
-                })
-                    .catch(() => undefined);
-                markTaskTimedOut(task);
+                await interruptTimedOutSubagent(api, handle);
+                markSubagentTaskTimedOut(task);
                 changed = true;
             }
             continue;
@@ -220,16 +385,8 @@ export async function refreshRunFromSubagentArtifacts(cwd, run) {
                 ? `pi-subagent heartbeat ${activeAttempt.heartbeatAt}`
                 : "pi-subagent running";
             if (isTaskTimedOut(task)) {
-                await api
-                    .interruptSubagent({
-                    cwd: handle.cwd,
-                    runsDir: handle.runsDir,
-                    runId: handle.runId,
-                    attemptId: handle.attemptId,
-                    reason: "workflow timeout",
-                })
-                    .catch(() => undefined);
-                markTaskTimedOut(task);
+                await interruptTimedOutSubagent(api, handle);
+                markSubagentTaskTimedOut(task);
                 changed = true;
             }
             continue;
@@ -241,6 +398,40 @@ export async function refreshRunFromSubagentArtifacts(cwd, run) {
         await writeRunRecord(cwd, run);
     return run;
 }
+async function interruptTimedOutSubagent(api, handle) {
+    await api
+        .interruptSubagent({
+        cwd: handle.cwd,
+        runsDir: handle.runsDir,
+        runId: handle.runId,
+        attemptId: handle.attemptId,
+        reason: "workflow timeout",
+    })
+        .catch(() => undefined);
+}
+function markSubagentTaskTimedOut(task) {
+    markTaskTimedOut(task);
+    task.backendHandle = undefined;
+    task.backendTaskId = task.taskId;
+    task.pid = undefined;
+}
+function isStaleLaunchClaim(task) {
+    if (task.statusDetail !== "launching" || !task.startedAt)
+        return false;
+    const startedAtMs = Date.parse(task.startedAt);
+    return (Number.isFinite(startedAtMs) &&
+        Date.now() - startedAtMs > STALE_LAUNCH_CLAIM_GRACE_MS);
+}
+function resetStaleLaunchClaim(task) {
+    task.status = "pending";
+    task.statusDetail = "pending";
+    task.startedAt = undefined;
+    task.backendHandle = undefined;
+    task.backendFiles = undefined;
+    task.backendTaskId = task.taskId;
+    task.pid = undefined;
+    task.lastMessage = "stale pi-subagent launch claim reset";
+}
 async function materializeTerminalSubagentResult(cwd, run, task, snapshot) {
     const outputRef = findLog(snapshot, "output");
     const stderrRef = findLog(snapshot, "stderr");
@@ -259,8 +450,23 @@ async function materializeTerminalSubagentResult(cwd, run, task, snapshot) {
         : undefined;
     const toolCalls = await readToolCallsSummary(snapshot, subagentResult, artifactRoot);
     const outputText = await readFile(outputFile, "utf8").catch(() => "");
+    const stderrText = await readFile(stderrFile, "utf8").catch(() => "");
     const outputBytes = Buffer.byteLength(outputText, "utf8");
-    const statusInfo = workflowStatusFromSubagent(snapshot, subagentResult, outputBytes);
+    let statusInfo = workflowStatusFromSubagent(snapshot, subagentResult, outputBytes);
+    const deterministicBootFailure = classifyDeterministicBootFailure({
+        statusInfo,
+        stderrText,
+        outputBytes,
+        contextLengthExceeded: Boolean(subagentResult?.metadata?.contextLengthExceeded ??
+            snapshot.metadata?.contextLengthExceeded),
+    });
+    if (deterministicBootFailure) {
+        statusInfo = {
+            status: "failed",
+            failureKind: "deterministic_boot",
+            errorMessage: deterministicBootFailure,
+        };
+    }
     const completedAt = typeof subagentResult?.completedAt === "string"
         ? subagentResult.completedAt
         : (snapshot.completedAt ?? nowIso());
@@ -279,7 +485,7 @@ async function materializeTerminalSubagentResult(cwd, run, task, snapshot) {
     const contextLengthExceeded = Boolean(subagentResult?.metadata?.contextLengthExceeded ??
         snapshot.metadata?.contextLengthExceeded);
     if (task.artifactGraph?.enabled && statusInfo.status === "completed") {
-        return await materializeTerminalArtifactGraphResult(cwd, run, task, {
+        const changed = await materializeTerminalArtifactGraphResult(cwd, run, task, {
             outputFile,
             stderrFile,
             resultFile,
@@ -288,6 +494,8 @@ async function materializeTerminalSubagentResult(cwd, run, task, snapshot) {
             exitCode,
             subagentResult,
         });
+        await recordTerminalParentSubagentChildEvent(run, task, snapshot);
+        return changed;
     }
     if (shouldAttemptArtifactGraphSalvage({
         task,
@@ -299,7 +507,7 @@ async function materializeTerminalSubagentResult(cwd, run, task, snapshot) {
         subagentResult,
         snapshot,
     })) {
-        return await materializeTerminalArtifactGraphResult(cwd, run, task, {
+        const changed = await materializeTerminalArtifactGraphResult(cwd, run, task, {
             outputFile,
             stderrFile,
             resultFile,
@@ -313,6 +521,8 @@ async function materializeTerminalSubagentResult(cwd, run, task, snapshot) {
                 subagentFailureKind: snapshot.failureKind,
             },
         });
+        await recordTerminalParentSubagentChildEvent(run, task, snapshot);
+        return changed;
     }
     const workflowResult = {
         status: statusInfo.status,
@@ -340,10 +550,12 @@ async function materializeTerminalSubagentResult(cwd, run, task, snapshot) {
     };
     if (shouldRetryTransientModelFailure(statusInfo, workflowResult, outputBytes)) {
         await writeJson(transientFailureAttemptPath(resultFile, (task.launchRetry?.attempts ?? 0) + 1), workflowResult);
-        return retryOrFailTransientSubagentFailure(task, {
+        const changed = retryOrFailTransientSubagentFailure(task, {
             reason: statusInfo.failureKind ?? "model",
             message: errorMessage ?? "pi-subagent run failed before producing output",
         });
+        await recordTerminalParentSubagentChildEvent(run, task, snapshot);
+        return changed;
     }
     await writeJson(resultFile, workflowResult);
     const completedAfterTimeout = resultCompletedAfterTimeout(task, completedAt);
@@ -357,6 +569,7 @@ async function materializeTerminalSubagentResult(cwd, run, task, snapshot) {
         delete task.backendHandle;
         delete task.backendFiles;
     }
+    await recordTerminalParentSubagentChildEvent(run, task, snapshot);
     return changed;
 }
 function artifactGraphRetrySession(run, task, subagentResult, attempt) {
@@ -685,6 +898,23 @@ function failArtifactGraphTask(task, options) {
     task.lastMessage = options.message;
     return true;
 }
+function classifyDeterministicBootFailure(options) {
+    if (options.statusInfo.status !== "failed" ||
+        options.statusInfo.failureKind !== "model" ||
+        options.outputBytes !== 0 ||
+        options.contextLengthExceeded) {
+        return undefined;
+    }
+    const text = options.stderrText;
+    const deterministicPattern = /(Failed to load extension|Cannot find module|(?:failed to load|invalid|missing) (?:workflow )?config(?:uration)?|config(?:uration)? (?:error|failed|invalid))/i;
+    if (!deterministicPattern.test(text))
+        return undefined;
+    const excerpt = text
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .find((line) => deterministicPattern.test(line)) ?? text.trim();
+    return `deterministic-boot failure: ${excerpt.slice(0, 500)}`;
+}
 function shouldRetryTransientModelFailure(statusInfo, workflowResult, outputBytes) {
     return (statusInfo.status === "failed" &&
         statusInfo.failureKind === "model" &&
@@ -714,14 +944,14 @@ function retryOrFailTransientSubagentFailure(task, options) {
     if (!exhausted) {
         task.status = "pending";
         task.statusDetail = "retry_model_failure";
-        task.lastMessage = `${options.message}; retrying transient model failure (${attempt}/${maxAttempts})`;
+        task.lastMessage = `${options.message}; retrying transient-model failure (${attempt}/${maxAttempts})`;
         return true;
     }
     task.status = "failed";
     task.statusDetail = task.launchRetry.reason ?? "model_exhausted";
     task.exitCode = 1;
     task.completedAt = nowIso();
-    task.lastMessage = `${options.message}; transient model failure retries exhausted (${maxAttempts})`;
+    task.lastMessage = `${options.message}; transient-model failure retries exhausted (${maxAttempts})`;
     return true;
 }
 function retryOrFailArtifactGraphTask(task, options) {
@@ -1021,6 +1251,7 @@ async function recoverSubagentHandle(run, task) {
     const runsDir = subagentRunsDir(run, task);
     const absoluteRunsDir = resolve(task.cwd, runsDir);
     const expectedCorrelationId = `${run.runId}:${task.taskId}`;
+    const claimStartedAtMs = timestampMs(task.startedAt);
     const entries = await readdir(absoluteRunsDir, { withFileTypes: true }).catch(() => []);
     const candidates = [];
     for (const entry of entries) {
@@ -1029,6 +1260,8 @@ async function recoverSubagentHandle(run, task) {
         const record = await readJsonLoose(join(absoluteRunsDir, entry.name, "run.json"));
         if (!record || record.correlationId !== expectedCorrelationId)
             continue;
+        if (isPreClaimSubagentRecord(record, claimStartedAtMs))
+            continue;
         const attemptId = record.activeAttemptId ??
             record.latestAttemptId ??
             record.attempts?.at(-1)?.attemptId;
@@ -1046,6 +1279,14 @@ async function recoverSubagentHandle(run, task) {
     candidates.sort((left, right) => right.updatedAtMs - left.updatedAtMs);
     return candidates[0]?.handle;
 }
+function isPreClaimSubagentRecord(record, claimStartedAtMs) {
+    if (claimStartedAtMs === undefined)
+        return false;
+    const recordStartedAtMs = timestampMs(record.startedAt) ??
+        timestampMs(record.attempts?.[0]?.startedAt) ??
+        timestampMs(record.updatedAt);
+    return (recordStartedAtMs !== undefined && recordStartedAtMs < claimStartedAtMs);
+}
 function timestampMs(value) {
     if (value === undefined)
         return undefined;
@@ -1089,7 +1330,16 @@ function subagentRunsDir(run, task) {
 function subagentSessionId(run, task) {
     if (!task.artifactGraph?.enabled)
         return undefined;
-    return task.outputRetry?.sessionId ?? baseSubagentSessionId(run, task);
+    const baseSessionId = baseSubagentSessionId(run, task);
+    if (task.outputRetry?.sessionId)
+        return task.outputRetry.sessionId;
+    const launchAttempt = task.launchRetry?.attempts ?? 0;
+    if (launchAttempt > 0)
+        return `${baseSessionId}:launch-retry-${launchAttempt}`;
+    const resumeAttempt = task.resumeEvents?.length ?? 0;
+    if (resumeAttempt > 0)
+        return `${baseSessionId}:resume-${resumeAttempt}`;
+    return baseSessionId;
 }
 function baseSubagentSessionId(run, task) {
     return `pi-workflow.${run.runId}.${task.taskId}`.replace(/[^A-Za-z0-9._-]/g, "-");

package/dist/types.d.ts

@@ -1,4 +1,4 @@
-import type { WorkflowRuntimeThinkingResolution } from "./workflow-runtime.js";
+import type { WorkflowModelInfo, WorkflowRuntimeDefaults, WorkflowRuntimeThinkingResolution } from "./workflow-runtime.js";
 export declare const THINKING_LEVELS: readonly ["off", "minimal", "low", "medium", "high", "xhigh"];
 export declare const FAST_MODES: readonly ["inherit", "off"];
 export declare const APPROVAL_MODES: readonly ["non-interactive", "on-request"];
@@ -420,6 +420,8 @@ export interface CompiledDynamicWorkflowTask {
     helpers: Record<string, CompiledDynamicWorkflowHelper>;
     workflows: Record<string, CompiledDynamicNestedWorkflow>;
     decisionLoop?: CompiledDynamicDecisionLoop;
+    runtimeOverrides?: WorkflowRuntimeDefaults;
+    availableModels?: WorkflowModelInfo[];
 }
 export interface CompiledArtifactGraphTask {
     enabled: true;
@@ -482,6 +484,9 @@ export interface CompiledTask {
         branchId?: string;
         outputProfile?: string;
     };
+    foreachGenerated?: {
+        placeholderSpecId: string;
+    };
     loopChild?: CompiledLoopChildTaskRef;
     loopPlaceholder?: {
         loopId: string;
@@ -560,6 +565,9 @@ export interface WorkflowTaskRunRecord {
         branchId?: string;
         outputProfile?: string;
     };
+    foreachGenerated?: {
+        placeholderSpecId: string;
+    };
     launchRetry?: {
         attempts: number;
         maxAttempts?: number;

package/dist/workflow-runtime.d.ts

@@ -35,6 +35,8 @@ export interface ResolveWorkflowRuntimeOptions {
     availableModels?: WorkflowModelInfo[];
     prompt?: WorkflowRuntimePrompt;
 }
+export type WorkflowRuntimeLayer = WorkflowRuntimeDefaults | undefined;
+export declare function selectWorkflowRuntime(...layers: WorkflowRuntimeLayer[]): WorkflowRuntimeResolutionInput;
 export declare function toWorkflowModelInfo(model: {
     provider: string;
     id: string;

package/dist/workflow-runtime.js

@@ -1,4 +1,34 @@
 import { THINKING_LEVELS } from "./types.js";
+export function selectWorkflowRuntime(...layers) {
+    const modelLayer = layers.find((layer) => modelOf(layer));
+    const model = modelOf(modelLayer);
+    let thinking;
+    for (const layer of layers) {
+        if (!layer)
+            continue;
+        if (layer.thinking) {
+            thinking = layer.thinking;
+            break;
+        }
+        const layerModel = modelOf(layer);
+        const modelThinking = layerModel
+            ? splitKnownThinkingSuffix(layerModel).thinking
+            : undefined;
+        if (modelThinking) {
+            thinking = modelThinking;
+            break;
+        }
+    }
+    return {
+        ...(model ? { model } : {}),
+        ...(thinking ? { thinking } : {}),
+    };
+}
+function modelOf(layer) {
+    return typeof layer?.model === "string" && layer.model.trim()
+        ? layer.model.trim()
+        : undefined;
+}
 export function toWorkflowModelInfo(model) {
     return {
         provider: model.provider,
@@ -163,9 +193,18 @@ export function readSimpleJsonPath(value, path) {
     const parts = path.slice(2).split(".").filter(Boolean);
     let current = value;
     for (const part of parts) {
-        if (current === null || typeof current !== "object" || !(part in current))
+        if (!canReadJsonPathPart(current, part))
             return undefined;
         current = current[part];
     }
     return current;
 }
+function canReadJsonPathPart(value, part) {
+    return (isSafeJsonPathPart(part) && isRecord(value) && Object.hasOwn(value, part));
+}
+function isSafeJsonPathPart(part) {
+    return part !== "__proto__" && part !== "prototype" && part !== "constructor";
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null;
+}

package/dist/workflow-view.js

@@ -953,12 +953,14 @@ function statusForSummary(summary) {
         return "running";
     if (summary.blocked > 0)
         return "blocked";
-    if (summary.failed > 0 || summary.interrupted > 0)
+    if (summary.failed > 0)
         return "failed";
     if (summary.pending > 0)
         return "pending";
     if (summary.total > 0 && summary.completed === summary.total)
         return "completed";
+    if (summary.interrupted > 0)
+        return "interrupted";
     return "interrupted";
 }
 function taskElapsed(task) {