callman-core 1.25.1 → 1.27.0

package/dist/scenario-runner/runScenario.js

@@ -4,6 +4,7 @@ import { evaluateAssertionConfig, validateAssertionConfig, } from "./assertion.j
 import { createSubScenarioStepId, buildRuntimeStepDescriptors, DEFAULT_END_LOOP_DELAY_MS, DEFAULT_END_LOOP_ITERATIONS, flattenScenarioNodesForContext, MAX_END_LOOP_ITERATIONS, DEFAULT_POLL_INTERVAL_MS, DEFAULT_POLL_MAX_ATTEMPTS, MAX_POLL_ATTEMPTS, DEFAULT_FOREACH_MAX_ITERATIONS, MAX_FOREACH_ITERATIONS, DEFAULT_WS_CONNECT_TIMEOUT_MS, MAX_WS_CONNECT_TIMEOUT_MS, DEFAULT_WS_EXPECT_TIMEOUT_MS, MAX_WS_EXPECT_TIMEOUT_MS, MAX_WS_WAIT_DURATION_MS, MAX_WS_STEPS, DEFAULT_WS_CLOSE_CODE, } from "./graphTraversal.js";
 import { evaluateWebsocketExpect } from "./websocket.js";
 import { executeWithScenarioNodePolicy } from "./executionPolicyRunner.js";
+import { boundSnapshot } from "./boundSnapshot.js";
 import { getLegacyScenarioNodeExecutionPolicy, getScenarioNodeExecutionPolicy, supportsScenarioNodeExecutionPolicy, } from "./nodePolicy.js";
 import { buildScenarioExecutionGraph, buildScenarioTemplateValues, collectExclusiveBranchNodeIds, evaluateScenarioExpression, resolveScenarioJsonTemplateString, resolveScenarioTemplateString, } from "./templateResolver.js";
 import { executeWaitNode, ScenarioWaitNodeCancelledError, ScenarioWaitNodeValidationError, } from "./waitNodeExecutor.js";
@@ -110,19 +111,24 @@ const createInputSnapshot = (context) => ({
         result: context.redisResult ?? null,
     },
 });
-const createContextSnapshot = (context) => ({
-    environment: { ...context.environment },
-    globals: { ...context.globals },
-    workflowContext: { ...context.workflowContext },
-    nodeMetaByLabel: cloneNodeMetaByLabel(context.nodeMetaByLabel),
-    workflowMeta: cloneWorkflowExecutionMeta(context.workflowMeta),
-    responseRoot: context.responseRoot ? { ...context.responseRoot } : null,
-    lastResponse: context.lastResponse,
-    dbResult: context.dbResult,
-    kafkaEvent: context.kafkaEvent,
-    kafkaCapture: context.kafkaCapture,
-    redisResult: context.redisResult,
-});
+const createContextSnapshot = (context, mode = "full") => {
+    // "bounded": the payload-bearing slots are size-capped copies instead of
+    // references, so the event log never pins a node's full response body.
+    const bound = mode === "bounded" ? boundSnapshot : (value) => value;
+    return {
+        environment: { ...context.environment },
+        globals: { ...context.globals },
+        workflowContext: bound({ ...context.workflowContext }),
+        nodeMetaByLabel: cloneNodeMetaByLabel(context.nodeMetaByLabel),
+        workflowMeta: cloneWorkflowExecutionMeta(context.workflowMeta),
+        responseRoot: context.responseRoot ? bound({ ...context.responseRoot }) : null,
+        lastResponse: bound(context.lastResponse),
+        dbResult: bound(context.dbResult),
+        kafkaEvent: bound(context.kafkaEvent),
+        kafkaCapture: bound(context.kafkaCapture),
+        redisResult: bound(context.redisResult),
+    };
+};
 const buildKafkaEventValue = (message) => {
     const fallbackValue = {
         value: message.valueJson ?? message.valueText,
@@ -333,6 +339,7 @@ const createStepExecutionRecord = ({ stepId, stepType, title, }) => ({
     activeBranch: null,
     ai: null,
     inputData: null,
+    resolvedInput: null,
     outputData: null,
     incomingEdgeId: null,
     startedAt: null,
@@ -512,6 +519,7 @@ const updateRecordFromEvent = (records, event) => {
         activeBranch: event.activeBranch ?? current.activeBranch,
         ai: event.ai ?? current.ai,
         inputData: event.inputData ?? current.inputData,
+        resolvedInput: event.resolvedInput ?? current.resolvedInput ?? null,
         outputData: event.outputData ?? current.outputData,
         incomingEdgeId: event.incomingEdgeId ?? current.incomingEdgeId,
         startedAt: current.startedAt ?? event.at,
@@ -557,7 +565,7 @@ const callHandler = async (handlers, event) => {
             return;
     }
 };
-export const runScenario = async ({ scenario, environment = {}, globals = {}, runtimeAdapters, eventHandlers, signal, minNodeVisualStateMs = DEFAULT_MIN_NODE_VISUAL_STATE_MS, }) => {
+export const runScenario = async ({ scenario, environment = {}, globals = {}, runtimeAdapters, eventHandlers, signal, minNodeVisualStateMs = DEFAULT_MIN_NODE_VISUAL_STATE_MS, eventContextMode = "full", }) => {
     const runId = createRunId();
     const startedAtMs = Date.now();
     const startedAt = new Date(startedAtMs).toISOString();
@@ -568,6 +576,9 @@ export const runScenario = async ({ scenario, environment = {}, globals = {}, ru
     const localStatuses = new Map(runtimeStepIds.map((stepId) => [stepId, "idle"]));
     const records = new Map();
     const events = [];
+    // Every emitted event carries a context snapshot; `runtimeContext` is
+    // assigned just below and is always initialised before the first emit.
+    const snapshotContext = () => createContextSnapshot(runtimeContext, eventContextMode);
     const initialWorkflowMeta = createInitialWorkflowMeta({
         startedAt,
         totalNodes: runtimeStepIds.length,
@@ -862,6 +873,11 @@ export const runScenario = async ({ scenario, environment = {}, globals = {}, ru
         }
         const executionStartedAtMs = Date.now();
         let inputData = createInputSnapshot(runtimeContext);
+        // The node's OWN resolved input (query + params, topic + payload, the
+        // request as sent…) — set by each node branch below once the values it
+        // will act on are known, so a failing node still reports what it tried.
+        let resolvedInput = null;
+        const resolvedInputForEvent = () => eventContextMode === "bounded" ? boundSnapshot(resolvedInput) : resolvedInput;
         let statusCode = null;
         let statusExpectation = null;
         let response = null;
@@ -892,6 +908,7 @@ export const runScenario = async ({ scenario, environment = {}, globals = {}, ru
             statusCode = null;
             response = null;
             outputData = null;
+            resolvedInput = null;
             testResults = [];
             contractResults = [];
             contractSummary = null;
@@ -977,7 +994,7 @@ export const runScenario = async ({ scenario, environment = {}, globals = {}, ru
                         runId,
                         stepId,
                         node,
-                        context: createContextSnapshot(runtimeContext),
+                        context: snapshotContext(),
                         kafkaCapturePlans,
                         captureFromTimestampMs: startedAtMs,
                         signal,
@@ -993,6 +1010,7 @@ export const runScenario = async ({ scenario, environment = {}, globals = {}, ru
                     statusCode = requestResult.response.status;
                     statusExpectation = requestResult.statusExpectation ?? null;
                     outputData = requestResult.outputData;
+                    resolvedInput = requestResult.resolvedInput ?? null;
                     testResults = requestResult.testResults;
                     contractResults = requestResult.contractResults;
                     contractSummary = requestResult.contractSummary;
@@ -1024,6 +1042,12 @@ export const runScenario = async ({ scenario, environment = {}, globals = {}, ru
                             return resolved;
                         })
                         : (node.data.config.params ?? []).map((param) => resolveScenarioTemplateString(param, templateValues));
+                    resolvedInput = {
+                        connectionId: node.data.config.connectionId,
+                        query: resolvedQuery,
+                        params: resolvedParams,
+                        useSession: Boolean(node.data.config.useSession),
+                    };
                     const dbResult = await runtimeAdapters.dbExecutor({
                         runId,
                         stepId,
@@ -1038,7 +1062,7 @@ export const runScenario = async ({ scenario, environment = {}, globals = {}, ru
                                 },
                             }
                             : {}),
-                        context: createContextSnapshot(runtimeContext),
+                        context: snapshotContext(),
                         signal,
                     });
                     runtimeContext.dbResult = dbResult.dbResult;
@@ -1048,6 +1072,7 @@ export const runScenario = async ({ scenario, environment = {}, globals = {}, ru
                     }
                 }
                 if (node.type === "wait") {
+                    resolvedInput = { durationMs: node.data.config.durationMs };
                     try {
                         outputData = await executeWaitNode({
                             durationMs: node.data.config.durationMs,
@@ -1071,7 +1096,7 @@ export const runScenario = async ({ scenario, environment = {}, globals = {}, ru
                         runId,
                         stepId,
                         node,
-                        context: createContextSnapshot(runtimeContext),
+                        context: snapshotContext(),
                         signal,
                     });
                     scriptSource = scriptResult.scriptSource;
@@ -1090,12 +1115,16 @@ export const runScenario = async ({ scenario, environment = {}, globals = {}, ru
                     const resolvedCommands = node.data.config.commands
                         .map((command) => resolveScenarioTemplateString(command, templateValues))
                         .filter((command) => command.trim().length > 0);
+                    resolvedInput = {
+                        connectionId: node.data.config.connectionId,
+                        commands: resolvedCommands,
+                    };
                     const redisResult = await runtimeAdapters.redisExecutor({
                         runId,
                         stepId,
                         node,
                         resolvedCommands,
-                        context: createContextSnapshot(runtimeContext),
+                        context: snapshotContext(),
                         signal,
                     });
                     runtimeContext.redisResult = redisResult.redisResult;
@@ -1118,6 +1147,13 @@ export const runScenario = async ({ scenario, environment = {}, globals = {}, ru
                         : null;
                     // Thinned emission keeps stored events bounded (~100 tick events).
                     const pollEmitStride = Math.max(1, Math.ceil(pollMaxAttempts / 100));
+                    resolvedInput = {
+                        actionType: pollConfig.actionType,
+                        intervalMs: pollBaseIntervalMs,
+                        timeoutMs: pollTimeoutMs,
+                        maxAttempts: pollMaxAttempts,
+                        onTimeout: pollConfig.onTimeout ?? "fail",
+                    };
                     // One tick = the embedded action through the SAME host adapters real
                     // nodes use (desktop IPC / backend drivers both covered), publishing
                     // results into the runtime context exactly like the real node would,
@@ -1147,7 +1183,7 @@ export const runScenario = async ({ scenario, environment = {}, globals = {}, ru
                                     position: node.position,
                                     data: { label: node.data.label, config: pollConfig.request },
                                 },
-                                context: createContextSnapshot(runtimeContext),
+                                context: snapshotContext(),
                                 kafkaCapturePlans: [],
                                 captureFromTimestampMs: startedAtMs,
                                 signal,
@@ -1187,7 +1223,7 @@ export const runScenario = async ({ scenario, environment = {}, globals = {}, ru
                                 },
                                 resolvedQuery,
                                 resolvedParams,
-                                context: createContextSnapshot(runtimeContext),
+                                context: snapshotContext(),
                                 signal,
                             });
                             runtimeContext.dbResult = tickResult.dbResult;
@@ -1210,7 +1246,7 @@ export const runScenario = async ({ scenario, environment = {}, globals = {}, ru
                                     data: { label: node.data.label, config: pollConfig.redis },
                                 },
                                 resolvedCommands,
-                                context: createContextSnapshot(runtimeContext),
+                                context: snapshotContext(),
                                 signal,
                             });
                             runtimeContext.redisResult = tickResult.redisResult;
@@ -1228,7 +1264,7 @@ export const runScenario = async ({ scenario, environment = {}, globals = {}, ru
                                 position: node.position,
                                 data: { label: node.data.label, config: pollConfig.script },
                             },
-                            context: createContextSnapshot(runtimeContext),
+                            context: snapshotContext(),
                             signal,
                         });
                         scriptSource = tickResult.scriptSource;
@@ -1347,11 +1383,17 @@ export const runScenario = async ({ scenario, environment = {}, globals = {}, ru
                         workflowMeta: runtimeContext.workflowMeta,
                         useRichBlocks: node.data.config.advanced?.useRichBlocks !== false,
                     });
+                    resolvedInput = {
+                        provider: node.data.config.provider,
+                        severity: normalizeNotificationSeverity(node.data.config.severity),
+                        channel: resolvedChannelOverride,
+                        message: resolvedMessage || "N/A",
+                    };
                     const notificationResult = await runtimeAdapters.notificationExecutor({
                         runId,
                         stepId,
                         node,
-                        context: createContextSnapshot(runtimeContext),
+                        context: snapshotContext(),
                         deliveryRequest,
                         signal,
                     });
@@ -1374,6 +1416,13 @@ export const runScenario = async ({ scenario, environment = {}, globals = {}, ru
                             : "";
                         const resolvedKey = resolvedKeyRaw.length > 0 ? resolvedKeyRaw : null;
                         const resolvedValue = resolveScenarioTemplateString(node.data.config.messageValue ?? "", templateValues);
+                        resolvedInput = {
+                            mode: "publish",
+                            topic: resolvedTopic,
+                            key: resolvedKey,
+                            valueFormat,
+                            value: resolvedValue,
+                        };
                         if (valueFormat === "json" && resolvedValue.trim().length > 0) {
                             try {
                                 JSON.parse(resolvedValue);
@@ -1395,6 +1444,14 @@ export const runScenario = async ({ scenario, environment = {}, globals = {}, ru
                                 continue;
                             resolvedHeaders[headerKey] = resolveScenarioTemplateString(header.value, templateValues);
                         }
+                        resolvedInput = {
+                            mode: "publish",
+                            topic: resolvedTopic,
+                            key: resolvedKey,
+                            valueFormat,
+                            value: resolvedValue,
+                            headers: resolvedHeaders,
+                        };
                         const { publishResult } = await runtimeAdapters.kafkaExecutor({
                             runId,
                             stepId,
@@ -1420,6 +1477,12 @@ export const runScenario = async ({ scenario, environment = {}, globals = {}, ru
                     else {
                         const rules = node.data.config.rules?.filter((rule) => rule.trim()) ?? [];
                         const resolvedMatchMode = node.data.config.matchMode ?? "regex";
+                        resolvedInput = {
+                            mode: "consume",
+                            topic: resolvedTopic,
+                            matchMode: resolvedMatchMode,
+                            rules,
+                        };
                         const prefetchedCaptureResult = prefetchedKafkaResults.get(stepId);
                         const captureResult = prefetchedCaptureResult ??
                             (await runtimeAdapters.kafkaExecutor({
@@ -1527,6 +1590,13 @@ export const runScenario = async ({ scenario, environment = {}, globals = {}, ru
                             rules: step.rules,
                         };
                     });
+                    resolvedInput = {
+                        url: resolvedUrl,
+                        headers: resolvedHeaders,
+                        subprotocols: resolvedSubprotocols,
+                        connectTimeoutMs,
+                        steps: resolvedSteps,
+                    };
                     const wsExecution = await runtimeAdapters.websocketExecutor({
                         runId,
                         stepId,
@@ -1647,12 +1717,19 @@ export const runScenario = async ({ scenario, environment = {}, globals = {}, ru
                         runId,
                         stepId,
                         node,
-                        context: createContextSnapshot(runtimeContext),
+                        context: snapshotContext(),
                         signal,
                     });
                     throwIfStopped(signal);
                     aiDetails = aiResult.details;
                     outputData = aiResult.outputData;
+                    resolvedInput = aiDetails
+                        ? {
+                            provider: aiDetails.provider,
+                            model: aiDetails.model,
+                            prompt: aiDetails.resolvedPrompt,
+                        }
+                        : null;
                     if (aiResult.failureMessage) {
                         throw new ScenarioNodeFailureError(aiResult.failureMessage);
                     }
@@ -1681,6 +1758,11 @@ export const runScenario = async ({ scenario, environment = {}, globals = {}, ru
                     conditionMode = conditionPayload.mode;
                     conditionDebug = conditionPayload.debug;
                     outputData = conditionPayload;
+                    resolvedInput = {
+                        mode: conditionPayload.mode,
+                        expression: conditionPayload.expression,
+                        preview: conditionPayload.preview,
+                    };
                     await emit({
                         type: "step:condition",
                         runId,
@@ -1721,6 +1803,13 @@ export const runScenario = async ({ scenario, environment = {}, globals = {}, ru
                     });
                     assertionResults = assertionEvaluation.checks;
                     assertionSummary = assertionEvaluation;
+                    resolvedInput = {
+                        matchMode: assertionEvaluation.matchMode,
+                        checks: assertionEvaluation.checks.map((check) => ({
+                            name: check.name,
+                            enabled: check.enabled,
+                        })),
+                    };
                     // Downstream nodes can reference e.g. {{AssertNode1.passed}}.
                     outputData = {
                         passed: assertionEvaluation.passed,
@@ -1825,6 +1914,19 @@ export const runScenario = async ({ scenario, environment = {}, globals = {}, ru
                     const collectResults = foreachConfig.collectResults !== false;
                     // Thinned emission keeps stored events bounded (~100 iteration markers).
                     const iterationEmitStride = Math.max(1, Math.ceil(processLimit / 100));
+                    resolvedInput = {
+                        sourceMode: foreachConfig.sourceMode,
+                        itemsPath: foreachConfig.sourceMode === "inline"
+                            ? null
+                            : (foreachConfig.itemsPath ?? "").trim(),
+                        itemAlias: itemAlias || null,
+                        itemCount: items.length,
+                        maxIterations,
+                        delayMs: iterationDelayMs,
+                        onItemFailure,
+                        collectResults,
+                        items,
+                    };
                     const internalGraph = buildScenarioExecutionGraph(foreachConfig.nodes, foreachConfig.edges);
                     const internalScope = {
                         graph: internalGraph,
@@ -2008,6 +2110,21 @@ export const runScenario = async ({ scenario, environment = {}, globals = {}, ru
                     const writtenEnvironment = {};
                     const writtenGlobals = {};
                     const extractionOutcomes = [];
+                    resolvedInput = {
+                        assignments: (node.data.config.assignments ?? [])
+                            .filter((assignment) => assignment && assignment.enabled !== false)
+                            .map((assignment) => ({
+                            scope: assignment.scope === "global" ? "global" : "environment",
+                            key: assignment.key ?? "",
+                            ...(assignment.extractorType && assignment.extractorType !== "template"
+                                ? {
+                                    extractorType: assignment.extractorType,
+                                    source: assignment.source ?? "",
+                                    expression: assignment.expression ?? "",
+                                }
+                                : { value: assignment.value ?? "" }),
+                        })),
+                    };
                     for (const assignment of node.data.config.assignments ?? []) {
                         if (!assignment || assignment.enabled === false) {
                             continue;
@@ -2093,6 +2210,7 @@ export const runScenario = async ({ scenario, environment = {}, globals = {}, ru
                 }
                 if (node.type === "aggregator") {
                     const resolvedTemplate = resolveScenarioJsonTemplateString(node.data.config.template, templateValues);
+                    resolvedInput = { template: resolvedTemplate };
                     try {
                         outputData = JSON.parse(resolvedTemplate);
                     }
@@ -2238,6 +2356,7 @@ export const runScenario = async ({ scenario, environment = {}, globals = {}, ru
                     activeBranch,
                     ai: aiDetails,
                     inputData,
+                    resolvedInput: resolvedInputForEvent(),
                     outputData,
                     incomingEdgeId: incomingEdgeId ?? null,
                 });
@@ -2321,6 +2440,7 @@ export const runScenario = async ({ scenario, environment = {}, globals = {}, ru
                     activeBranch,
                     ai: aiDetails,
                     inputData,
+                    resolvedInput: resolvedInputForEvent(),
                     outputData,
                     incomingEdgeId: incomingEdgeId ?? null,
                 });
@@ -2399,6 +2519,7 @@ export const runScenario = async ({ scenario, environment = {}, globals = {}, ru
                     activeBranch,
                     ai: aiDetails,
                     inputData,
+                    resolvedInput: resolvedInputForEvent(),
                     outputData,
                     incomingEdgeId: incomingEdgeId ?? null,
                 });
@@ -2639,7 +2760,7 @@ export const runScenario = async ({ scenario, environment = {}, globals = {}, ru
         durationMs: Date.now() - startedAtMs,
         totalSteps: runtimeStepIds.length,
         completedSteps: Array.from(localStatuses.values()).filter(isTerminalStatus).length,
-        context: createContextSnapshot(runtimeContext),
+        context: snapshotContext(),
         workflowMeta: cloneWorkflowExecutionMeta(finalWorkflowMeta),
         nodeExecutions: runtimeStepIds.map((stepId) => {
             const descriptor = runtimeStepDescriptors.find((entry) => entry.stepId === stepId);