ultravisor 1.0.22 → 1.0.24

package/source/services/Ultravisor-ExecutionEngine.cjs

@@ -590,6 +590,191 @@ class UltravisorExecutionEngine extends libPictService
 			});
 	}
 
+	/**
+	 * Retry a completed/errored operation from its last failed node.
+	 *
+	 * Reads the persisted manifest, finds the node that errored, resets
+	 * it to WaitingForInput, rebuilds the graph, and re-dispatches the
+	 * work item through the coordinator. All prior node outputs
+	 * (materialized files, state writes) are preserved — only the
+	 * failed node re-runs.
+	 *
+	 * @param {string} pRunHash - The execution run hash to retry
+	 * @param {object} [pOptions] - Optional overrides
+	 *        - NodeHash: retry a specific node (default: auto-detect failed node)
+	 *        - SettingsOverrides: merge into the re-dispatched Settings
+	 * @param {function} fCallback - function(pError, pExecutionContext)
+	 */
+	retryFromCheckpoint(pRunHash, pOptions, fCallback)
+	{
+		if (typeof pOptions === 'function')
+		{
+			fCallback = pOptions;
+			pOptions = {};
+		}
+		pOptions = pOptions || {};
+
+		let tmpManifestService = this._getManifestService();
+		if (!tmpManifestService)
+		{
+			return fCallback(new Error('ExecutionEngine: UltravisorExecutionManifest service not found.'));
+		}
+
+		let tmpContext = tmpManifestService.getRun(pRunHash);
+		if (!tmpContext)
+		{
+			return fCallback(new Error(`ExecutionEngine: run [${pRunHash}] not found.`));
+		}
+
+		if (tmpContext.Status === 'Running' || tmpContext.Status === 'WaitingForInput')
+		{
+			return fCallback(new Error(`ExecutionEngine: run [${pRunHash}] is still active (${tmpContext.Status}). Cannot retry.`));
+		}
+
+		// Find the failed node — either specified or auto-detected from TaskManifests
+		let tmpTargetNode = pOptions.NodeHash || null;
+		if (!tmpTargetNode)
+		{
+			for (let tmpNodeHash of Object.keys(tmpContext.TaskManifests || {}))
+			{
+				let tmpManifest = tmpContext.TaskManifests[tmpNodeHash];
+				if (tmpManifest.Executions && tmpManifest.Executions.length > 0)
+				{
+					let tmpLastExec = tmpManifest.Executions[tmpManifest.Executions.length - 1];
+					if (tmpLastExec.Status === 'Error')
+					{
+						tmpTargetNode = tmpNodeHash;
+						break;
+					}
+				}
+			}
+		}
+
+		// Also check TaskOutputs for _BeaconError flag (beacon-dispatch failures)
+		if (!tmpTargetNode)
+		{
+			for (let tmpNodeHash of Object.keys(tmpContext.TaskOutputs || {}))
+			{
+				if (tmpContext.TaskOutputs[tmpNodeHash]._BeaconError)
+				{
+					tmpTargetNode = tmpNodeHash;
+					break;
+				}
+			}
+		}
+
+		if (!tmpTargetNode)
+		{
+			return fCallback(new Error(`ExecutionEngine: no failed node found in run [${pRunHash}].`));
+		}
+
+		this.log.info(`[Engine] retryFromCheckpoint: run=${pRunHash} node=${tmpTargetNode}`);
+		this._log(tmpContext, `Retrying from checkpoint: re-dispatching node [${tmpTargetNode}]`);
+
+		// Look up the operation definition to rebuild the graph
+		let tmpStateService = this.fable.servicesMap['UltravisorHypervisorState']
+			? Object.values(this.fable.servicesMap['UltravisorHypervisorState'])[0]
+			: null;
+		if (!tmpStateService)
+		{
+			return fCallback(new Error('ExecutionEngine: UltravisorHypervisorState service not found.'));
+		}
+		let tmpOperation = tmpStateService.getOperationSync(tmpContext.OperationHash);
+		if (!tmpOperation || !tmpOperation.Graph)
+		{
+			return fCallback(new Error(`ExecutionEngine: operation [${tmpContext.OperationHash}] not found.`));
+		}
+
+		// Rebuild the graph context so traversal works
+		this._rebuildGraphContext(tmpContext, tmpOperation);
+
+		// Clear the failed node's error state
+		delete tmpContext.TaskOutputs[tmpTargetNode];
+		if (tmpContext.TaskManifests[tmpTargetNode])
+		{
+			// Keep the execution history but mark the new attempt
+			tmpContext.TaskManifests[tmpTargetNode].Executions.push({
+				Status: 'Retrying',
+				AttemptNumber: tmpContext.TaskManifests[tmpTargetNode].Executions.length,
+				StartTime: new Date().toISOString(),
+				StartTimeMs: Date.now()
+			});
+		}
+
+		// Re-add the node as WaitingForInput so the coordinator
+		// picks it up. Use the same ResumeEventName the original
+		// beacon-dispatch used ('Complete' for successful retry).
+		tmpContext.WaitingTasks[tmpTargetNode] = {
+			PromptMessage: '',
+			OutputAddress: '',
+			ResumeEventName: 'Complete',
+			Timestamp: new Date().toISOString()
+		};
+		tmpContext.Status = 'WaitingForInput';
+		tmpContext.StopTime = null;
+
+		// Clear operation-level errors from the previous run
+		tmpContext.Errors = tmpContext.Errors.filter(
+			(e) => e.NodeHash !== tmpTargetNode);
+
+		// Persist the updated manifest
+		if (tmpContext.StagingPath)
+		{
+			tmpManifestService._writeManifest(tmpContext, tmpContext.StagingPath);
+		}
+
+		this.log.info(`ExecutionEngine: run [${pRunHash}] reset to WaitingForInput at node [${tmpTargetNode}]. Re-dispatch the work item to continue.`);
+
+		// Now re-dispatch the beacon work item through the coordinator.
+		// The node's original Settings are in the operation graph.
+		let tmpCoordinator = this.fable.servicesMap['UltravisorBeaconCoordinator']
+			? Object.values(this.fable.servicesMap['UltravisorBeaconCoordinator'])[0]
+			: null;
+
+		if (tmpCoordinator && tmpContext._NodeMap && tmpContext._NodeMap[tmpTargetNode])
+		{
+			let tmpNodeDef = tmpContext._NodeMap[tmpTargetNode];
+			let tmpSettings = Object.assign({}, tmpNodeDef.Settings || {}, pOptions.SettingsOverrides || {});
+
+			// Resolve state addresses in Settings (same as original dispatch)
+			let tmpStateManager = this._getStateManager();
+			if (tmpStateManager)
+			{
+				for (let tmpKey of Object.keys(tmpSettings))
+				{
+					let tmpVal = tmpSettings[tmpKey];
+					if (typeof tmpVal === 'string' && tmpVal.indexOf('.') !== -1)
+					{
+						let tmpResolved = tmpStateManager.getAddress(tmpVal, tmpContext, tmpTargetNode);
+						if (tmpResolved !== undefined && tmpResolved !== tmpVal)
+						{
+							tmpSettings[tmpKey] = tmpResolved;
+						}
+					}
+				}
+			}
+
+			let tmpWorkItemInfo = {
+				RunHash: pRunHash,
+				NodeHash: tmpTargetNode,
+				OperationHash: tmpContext.OperationHash,
+				Capability: tmpNodeDef.Capability || tmpSettings.Capability || '',
+				Action: tmpNodeDef.Action || tmpSettings.Action || '',
+				Settings: tmpSettings,
+				TimeoutMs: tmpNodeDef.TimeoutMs || 600000
+			};
+
+			tmpCoordinator.enqueueWorkItem(tmpWorkItemInfo);
+			this.log.info(`ExecutionEngine: re-dispatched work item for node [${tmpTargetNode}]`);
+		}
+		else
+		{
+			this.log.warn(`ExecutionEngine: could not re-dispatch — coordinator or node definition not available. Run is waiting; resume manually.`);
+		}
+
+		return fCallback(null, tmpContext);
+	}
+
 	// ====================================================================
 	// Internal: Event Queue Processing
 	// ====================================================================
@@ -608,7 +793,22 @@ class UltravisorExecutionEngine extends libPictService
 			if (Object.keys(pContext.WaitingTasks).length > 0)
 			{
 				pContext.Status = 'WaitingForInput';
-				this._log(pContext, 'Operation paused: waiting for user input.');
+				// Use each waiting task's PromptMessage — set by the task
+				// when it returned {WaitingForInput:true, ...}. That's
+				// where tasks already describe what they're waiting for
+				// ("Waiting for Beacon (...)", "Waiting for LLM response",
+				// "Please provide a value"). A hardcoded "user input"
+				// log misled operators for beacon/LLM waits that never
+				// involve the user.
+				let tmpWaitHashes = Object.keys(pContext.WaitingTasks);
+				let tmpReasons = [];
+				for (let i = 0; i < tmpWaitHashes.length; i++)
+				{
+					let tmpWait = pContext.WaitingTasks[tmpWaitHashes[i]];
+					if (tmpWait && tmpWait.PromptMessage) tmpReasons.push(tmpWait.PromptMessage);
+				}
+				let tmpReason = tmpReasons.length ? tmpReasons.join('; ') : 'waiting for input';
+				this._log(pContext, 'Operation paused: ' + tmpReason + '.');
 			}
 			return fCallback(null);
 		}
@@ -687,8 +887,8 @@ class UltravisorExecutionEngine extends libPictService
 			return fCallback(null);
 		}
 
-		// Resolve incoming state connections
-		let tmpResolvedSettings = this._resolveStateConnections(pNodeHash, tmpNode, pContext);
+		// Resolve incoming state connections (pass definition for type-aware resolution)
+		let tmpResolvedSettings = this._resolveStateConnections(pNodeHash, tmpNode, pContext, tmpDefinition);
 
 		// Get the manifest service for recording
 		let tmpManifestService = this._getManifestService();
@@ -952,7 +1152,7 @@ class UltravisorExecutionEngine extends libPictService
 	 * @param {object} pContext - The execution context.
 	 * @returns {object} The resolved settings object.
 	 */
-	_resolveStateConnections(pNodeHash, pNode, pContext)
+	_resolveStateConnections(pNodeHash, pNode, pContext, pDefinition)
 	{
 		// Start with a copy of the node's static settings
 		// Nodes may store config in Settings or Data (flow editor uses Data)
@@ -991,10 +1191,23 @@ class UltravisorExecutionEngine extends libPictService
 				tmpSourceValue = this._resolveTemplate(tmpConn.Data.Template, tmpTemplateContext);
 			}
 
+			// Determine which settings key to write under. When a
+			// state connection explicitly declares `Data.StateKey`,
+			// honor it — this lets operations fan state into a
+			// setting whose name doesn't match any physical port
+			// (e.g. the storyboard's parameter-sweep connection
+			// routes a value-input's InputValue into the sweep
+			// task's `ParameterSets` setting even though the sweep
+			// only exposes event trigger ports). Falls through to
+			// the target port name for backward compatibility.
+			let tmpSettingsKey = (tmpConn.Data && typeof(tmpConn.Data.StateKey) === 'string' && tmpConn.Data.StateKey)
+				? tmpConn.Data.StateKey
+				: tmpTargetPortName;
+
 			// Write the resolved value into settings
-			if (tmpTargetPortName && tmpSourceValue !== undefined)
+			if (tmpSettingsKey && tmpSourceValue !== undefined)
 			{
-				tmpSettings[tmpTargetPortName] = tmpSourceValue;
+				tmpSettings[tmpSettingsKey] = tmpSourceValue;
 			}
 		}
 
@@ -1002,12 +1215,35 @@ class UltravisorExecutionEngine extends libPictService
 		// (e.g. "{~D:Record.Operation.InputFilePath~}" -> actual value from state)
 		let tmpTemplateContext = tmpStateManager.buildTemplateContext(pContext);
 
+		// Build a type lookup from the task definition's SettingsInputs.
+		// Object and Array typed settings should NOT have their contents
+		// template-resolved — they carry configuration (like MappingConfiguration)
+		// whose {~D:Record.Field~} expressions are meant for downstream consumers
+		// (e.g. TabularTransform), not for the execution engine.
+		let tmpSettingsTypeMap = {};
+		if (pDefinition && Array.isArray(pDefinition.SettingsInputs))
+		{
+			for (let s = 0; s < pDefinition.SettingsInputs.length; s++)
+			{
+				tmpSettingsTypeMap[pDefinition.SettingsInputs[s].Name] = pDefinition.SettingsInputs[s].DataType || 'String';
+			}
+		}
+
 		let tmpSettingsKeys = Object.keys(tmpSettings);
 		for (let i = 0; i < tmpSettingsKeys.length; i++)
 		{
 			let tmpKey = tmpSettingsKeys[i];
 			let tmpVal = tmpSettings[tmpKey];
 
+			// Skip template resolution for Object and Array typed settings.
+			// These carry opaque configuration (e.g. mapping rules) whose
+			// template expressions belong to the consuming service, not the engine.
+			let tmpDeclaredType = tmpSettingsTypeMap[tmpKey];
+			if (tmpDeclaredType === 'Object' || tmpDeclaredType === 'Array')
+			{
+				continue;
+			}
+
 			if (typeof(tmpVal) === 'string' && tmpVal.indexOf('{~') >= 0)
 			{
 				// When the entire value is a single {~D:Record.X~} expression,

package/source/services/Ultravisor-ExecutionManifest.cjs

@@ -541,6 +541,7 @@ class UltravisorExecutionManifest extends libPictService
 
 		this._emitExecutionEvent('ExecutionComplete', pExecutionContext.Hash,
 		{
+			OperationHash: pExecutionContext.OperationHash,
 			Status: pExecutionContext.Status,
 			ElapsedMs: pExecutionContext.ElapsedMs,
 			ErrorCount: pExecutionContext.Errors.length