@openclaw/lobster 2026.7.1-beta.2 → 2026.7.1-beta.4

package/node_modules/@clawdbot/lobster/dist/src/workflows/file.js

@@ -13,12 +13,25 @@ import { resolveInlineShellCommand } from "../shell.js";
 import { compileCached } from "../validation.js";
 import { CostTracker } from "../core/cost_tracker.js";
 import { withRetry, resolveRetryConfig } from "../core/retry.js";
+import { RequestInputResumeError, validateCommandInputState, } from "../input_request.js";
 export class WorkflowResumeArgumentError extends Error {
     constructor(message) {
         super(message);
         this.name = "WorkflowResumeArgumentError";
     }
 }
+class WorkflowPipelineInputSuspension extends Error {
+    stepId;
+    request;
+    pipelineInput;
+    constructor({ stepId, request, pipelineInput, }) {
+        super(`Workflow step ${stepId} pipeline requested input`);
+        this.name = "WorkflowPipelineInputSuspension";
+        this.stepId = stepId;
+        this.request = request;
+        this.pipelineInput = pipelineInput;
+    }
+}
 export async function loadWorkflowFile(filePath) {
     const text = await fsp.readFile(filePath, "utf8");
     const ext = path.extname(filePath).toLowerCase();
@@ -412,6 +425,7 @@ export async function runWorkflowFile({ filePath, args, ctx, resume, approved, r
                 previous.approvedBy = approvedBy;
             results[resumeState.approvalStepId] = previous;
         }
+        let resumedPipelineInput = null;
         if (resumeState?.inputStepId) {
             if (approved !== undefined) {
                 throw new WorkflowResumeArgumentError("Workflow resume requires --response-json for input requests");
@@ -419,30 +433,65 @@ export async function runWorkflowFile({ filePath, args, ctx, resume, approved, r
             if (response === undefined) {
                 throw new WorkflowResumeArgumentError("Workflow resume requires --response-json for input requests");
             }
-            const inputStep = steps[stepIndexById.get(resumeState.inputStepId) ?? -1];
-            if (!inputStep || !isInputStep(inputStep.input)) {
-                throw new Error(`Invalid input step in resume state: ${resumeState.inputStepId}`);
-            }
-            try {
-                validateInputResponse({
-                    schema: resumeState.inputSchema ?? inputStep.input.responseSchema,
+            if (resumeState.inputKind === "pipeline_command") {
+                const resumedStepIndex = stepIndexById.get(resumeState.inputStepId);
+                if (resumedStepIndex !== startIndex) {
+                    throw new RequestInputResumeError("workflow input step changed since input request");
+                }
+                const pipelineStep = steps[resumedStepIndex];
+                if (!pipelineStep || typeof pipelineStep.pipeline !== "string") {
+                    throw new Error(`Invalid pipeline input step in resume state: ${resumeState.inputStepId}`);
+                }
+                if (!evaluateCondition(pipelineStep.when ?? pipelineStep.condition, results)) {
+                    throw new RequestInputResumeError("workflow input step condition changed since input request");
+                }
+                try {
+                    validateInputResponse({
+                        schema: resumeState.inputSchema,
+                        response,
+                        stepId: pipelineStep.id,
+                    });
+                }
+                catch (err) {
+                    throw new WorkflowResumeArgumentError(err?.message ?? String(err));
+                }
+                resumedPipelineInput = {
+                    stepId: resumeState.inputStepId,
                     response,
-                    stepId: inputStep.id,
-                });
+                    pipelineInput: resumeState.pipelineInput,
+                    onConsumed: consumedResumeStateKey
+                        ? async () => {
+                            await deleteStateJson({ env: ctx.env, key: consumedResumeStateKey });
+                        }
+                        : undefined,
+                };
             }
-            catch (err) {
-                throw new WorkflowResumeArgumentError(err?.message ?? String(err));
+            else {
+                const inputStep = steps[stepIndexById.get(resumeState.inputStepId) ?? -1];
+                if (!inputStep || !isInputStep(inputStep.input)) {
+                    throw new Error(`Invalid input step in resume state: ${resumeState.inputStepId}`);
+                }
+                try {
+                    validateInputResponse({
+                        schema: resumeState.inputSchema ?? inputStep.input.responseSchema,
+                        response,
+                        stepId: inputStep.id,
+                    });
+                }
+                catch (err) {
+                    throw new WorkflowResumeArgumentError(err?.message ?? String(err));
+                }
+                const previous = results[resumeState.inputStepId] ?? { id: resumeState.inputStepId };
+                previous.subject = resumeState.inputSubject ?? null;
+                previous.response = response;
+                delete previous.skipped;
+                results[resumeState.inputStepId] = previous;
             }
-            const previous = results[resumeState.inputStepId] ?? { id: resumeState.inputStepId };
-            previous.subject = resumeState.inputSubject ?? null;
-            previous.response = response;
-            delete previous.skipped;
-            results[resumeState.inputStepId] = previous;
         }
         if (ctx.dryRun) {
             return dryRunWorkflow({ steps, resolvedArgs, results, startIndex, ctx });
         }
-        const costTracker = new CostTracker(CostTracker.parsePricingFromEnv(ctx.env));
+        const costTracker = new CostTracker(CostTracker.parsePricingFromEnv(ctx.env, ctx.stderr), ctx.stderr);
         let lastStepId = resumeState?.inputStepId ?? findLastCompletedStepId(steps, results);
         for (let idx = startIndex; idx < steps.length; idx++) {
             const step = steps[idx];
@@ -577,6 +626,7 @@ export async function runWorkflowFile({ filePath, args, ctx, resume, approved, r
                                 ctx,
                                 env: subEnv,
                                 cwd: subCwd,
+                                requestInputEnabled: false,
                             });
                         }
                         else {
@@ -677,6 +727,7 @@ export async function runWorkflowFile({ filePath, args, ctx, resume, approved, r
                                     ctx: { ...ctx, signal: branchSignal },
                                     env: branchEnv,
                                     cwd: branchCwd,
+                                    requestInputEnabled: false,
                                 });
                                 return { branchId: branch.id, result: branchResult };
                             }
@@ -799,6 +850,13 @@ export async function runWorkflowFile({ filePath, args, ctx, resume, approved, r
                             ctx: { ...ctx, signal: stepSignal },
                             env,
                             cwd,
+                            resume: resumedPipelineInput?.stepId === step.id
+                                ? {
+                                    pipelineInput: resumedPipelineInput.pipelineInput,
+                                    response: resumedPipelineInput.response,
+                                    onConsumed: resumedPipelineInput.onConsumed,
+                                }
+                                : undefined,
                         });
                     }
                     else {
@@ -819,6 +877,10 @@ export async function runWorkflowFile({ filePath, args, ctx, resume, approved, r
                     ? await withRetry(executeStepAttempt, retryConfig, {
                         signal: ctx.signal,
                         shouldRetry: (error) => {
+                            if (error instanceof WorkflowPipelineInputSuspension ||
+                                error instanceof RequestInputResumeError) {
+                                return false;
+                            }
                             const message = error?.message ?? String(error);
                             return !/halted (for approval inside|before completion at) pipeline/.test(message);
                         },
@@ -831,6 +893,48 @@ export async function runWorkflowFile({ filePath, args, ctx, resume, approved, r
                 parallelBranchResults = attemptResult.parallelBranchResults;
             }
             catch (err) {
+                if (err instanceof WorkflowPipelineInputSuspension) {
+                    const inputRequest = buildNeedsInputRequest({
+                        stepId: err.stepId,
+                        prompt: err.request.prompt,
+                        responseSchema: err.request.responseSchema,
+                        defaults: err.request.defaults,
+                        subject: err.request.subject,
+                        maxEnvelopeBytes: resolveToolEnvelopeMaxBytes(ctx.env),
+                    });
+                    const stateKey = await saveWorkflowResumeState(ctx.env, {
+                        filePath: resolvedFilePath,
+                        resumeAtIndex: idx,
+                        steps: results,
+                        args: resolvedArgs,
+                        inputStepId: err.stepId,
+                        inputKind: "pipeline_command",
+                        inputSchema: err.request.responseSchema,
+                        inputSubject: err.request.subject,
+                        pipelineInput: err.pipelineInput,
+                        createdAt: new Date().toISOString(),
+                    });
+                    if (consumedResumeStateKey && consumedResumeStateKey !== stateKey) {
+                        await deleteStateJson({ env: ctx.env, key: consumedResumeStateKey });
+                    }
+                    const resumeToken = encodeToken({
+                        protocolVersion: 1,
+                        v: 1,
+                        kind: "workflow-file",
+                        stateKey,
+                    });
+                    return {
+                        status: "needs_input",
+                        output: [],
+                        requiresInput: {
+                            ...inputRequest,
+                            resumeToken,
+                        },
+                    };
+                }
+                if (err instanceof RequestInputResumeError) {
+                    throw err;
+                }
                 if (ctx.signal?.aborted && (err?.name === "AbortError" || err?.code === "ABORT_ERR")) {
                     throw err;
                 }
@@ -908,7 +1012,7 @@ export async function runWorkflowFile({ filePath, args, ctx, resume, approved, r
                         requiresApproval: {
                             ...approval,
                             resumeToken,
-                            approvalId,
+                            ...(approvalId ? { approvalId } : null),
                         },
                     };
                 }
@@ -1264,8 +1368,55 @@ async function loadWorkflowResumeState(env, stateKey) {
         throw new Error("Invalid workflow resume state");
     if (!data.args || typeof data.args !== "object")
         throw new Error("Invalid workflow resume state");
+    if (data.inputKind !== undefined &&
+        !["workflow_step", "pipeline_command"].includes(data.inputKind)) {
+        throw new Error("Invalid workflow resume state");
+    }
+    if (data.inputKind === "pipeline_command") {
+        if (typeof data.inputStepId !== "string")
+            throw new Error("Invalid workflow resume state");
+        if (data.inputSchema === undefined)
+            throw new Error("Invalid workflow resume state");
+        data.pipelineInput = validateWorkflowPipelineInputResumeState(data.pipelineInput);
+    }
+    else if (data.pipelineInput !== undefined) {
+        throw new Error("Invalid workflow resume state");
+    }
     return data;
 }
+function validateWorkflowPipelineInputResumeState(value) {
+    if (!value || typeof value !== "object")
+        throw new Error("Invalid workflow resume state");
+    const data = value;
+    if (!Array.isArray(data.pipeline))
+        throw new Error("Invalid workflow resume state");
+    validateWorkflowPipelineShape(data.pipeline);
+    if (typeof data.resumeAtIndex !== "number" ||
+        !Number.isInteger(data.resumeAtIndex) ||
+        data.resumeAtIndex < 0 ||
+        data.resumeAtIndex >= data.pipeline.length) {
+        throw new Error("Invalid workflow resume state");
+    }
+    if (!Array.isArray(data.items))
+        throw new Error("Invalid workflow resume state");
+    data.commandInput = validateCommandInputState(data.commandInput);
+    return data;
+}
+function validateWorkflowPipelineShape(pipeline) {
+    for (const stage of pipeline) {
+        if (!stage || typeof stage !== "object")
+            throw new Error("Invalid workflow resume state");
+        const data = stage;
+        if (typeof data.name !== "string" || data.name.length === 0) {
+            throw new Error("Invalid workflow resume state");
+        }
+        if (!data.args || typeof data.args !== "object" || Array.isArray(data.args)) {
+            throw new Error("Invalid workflow resume state");
+        }
+        if (typeof data.raw !== "string")
+            throw new Error("Invalid workflow resume state");
+    }
+}
 function mergeEnv(base, workflowEnv, stepEnv, args, results) {
     const env = { ...base };
     // Expose resolved args as env vars so shell commands can safely reference them
@@ -2040,12 +2191,23 @@ function getStepExecution(step) {
     }
     return { kind: "none" };
 }
-async function runPipelineStep({ stepId, pipelineText, inputValue, ctx, env, cwd, }) {
+async function runPipelineStep({ stepId, pipelineText, inputValue, ctx, env, cwd, resume, requestInputEnabled = true, }) {
     let pipeline;
     try {
-        pipeline = parsePipeline(pipelineText);
+        const currentPipeline = parsePipeline(pipelineText);
+        if (resume) {
+            if (!isDeepStrictEqual(currentPipeline, resume.pipelineInput.pipeline)) {
+                throw new RequestInputResumeError("workflow pipeline changed since input request");
+            }
+            pipeline = resume.pipelineInput.pipeline;
+        }
+        else {
+            pipeline = currentPipeline;
+        }
     }
     catch (err) {
+        if (err instanceof RequestInputResumeError)
+            throw err;
         throw new Error(`Workflow step ${stepId} pipeline parse failed: ${err?.message ?? String(err)}`);
     }
     const stdout = new PassThrough();
@@ -2054,8 +2216,10 @@ async function runPipelineStep({ stepId, pipelineText, inputValue, ctx, env, cwd
     stdout.on("data", (chunk) => {
         renderedStdout += String(chunk);
     });
+    const pipelineStartIndex = resume ? resume.pipelineInput.resumeAtIndex : 0;
+    const remainingPipeline = pipeline.slice(pipelineStartIndex);
     const result = await runPipeline({
-        pipeline,
+        pipeline: remainingPipeline,
         registry: ctx.registry,
         stdin: ctx.stdin,
         stdout,
@@ -2065,7 +2229,15 @@ async function runPipelineStep({ stepId, pipelineText, inputValue, ctx, env, cwd
         cwd,
         signal: ctx.signal,
         llmAdapters: ctx.llmAdapters,
-        input: inputValueToStream(inputValue),
+        input: resume ? resume.pipelineInput.items : inputValueToPipelineItems(inputValue),
+        requestInputEnabled,
+        requestInputResume: resume
+            ? {
+                state: resume.pipelineInput.commandInput,
+                response: resume.response,
+                onConsumed: resume.onConsumed,
+            }
+            : undefined,
     });
     stdout.end();
     if (result.halted) {
@@ -2073,6 +2245,26 @@ async function runPipelineStep({ stepId, pipelineText, inputValue, ctx, env, cwd
         if (result.items.length === 1 && result.items[0]?.type === "approval_request") {
             throw new Error(`Workflow step ${stepId} halted for approval inside pipeline stage ${haltedName}. Use a separate approval step in the workflow file.`);
         }
+        const request = result.items.length === 1 && result.items[0]?.type === "input_request"
+            ? result.items[0]
+            : null;
+        if (request?.commandInput) {
+            throw new WorkflowPipelineInputSuspension({
+                stepId,
+                request: {
+                    prompt: String(request.prompt),
+                    responseSchema: request.responseSchema,
+                    ...(request.defaults !== undefined ? { defaults: request.defaults } : null),
+                    ...(request.subject !== undefined ? { subject: request.subject } : null),
+                },
+                pipelineInput: {
+                    pipeline,
+                    resumeAtIndex: pipelineStartIndex + (result.haltedAt?.index ?? 0),
+                    items: Array.isArray(request.items) ? request.items : [],
+                    commandInput: request.commandInput,
+                },
+            });
+        }
         throw new Error(`Workflow step ${stepId} halted before completion at pipeline stage ${haltedName}`);
     }
     const normalizedStdout = renderedStdout || serializePipelineItemsToStdout(result.items);
@@ -2142,12 +2334,8 @@ function* inputValueToItems(value) {
     }
     yield value;
 }
-function inputValueToStream(value) {
-    return (async function* () {
-        for (const item of inputValueToItems(value)) {
-            yield item;
-        }
-    })();
+function inputValueToPipelineItems(value) {
+    return [...inputValueToItems(value)];
 }
 function serializePipelineItemsToStdout(items) {
     if (!items.length)