@codemation/core 0.7.0 → 0.8.1

package/dist/{runtime-CJnObwsU.js → runtime-DUW6tIJ1.js}

@@ -535,7 +535,8 @@ var NodeExecutionSnapshotFactory = class {
 			error: {
 				message: args.error.message,
 				name: args.error.name,
-				stack: args.error.stack
+				stack: args.error.stack,
+				details: args.error.details
 			}
 		};
 	}
@@ -809,14 +810,324 @@ var DefaultAsyncSleeper = class {
 	}
 };
 
+//#endregion
+//#region src/contracts/emitPorts.ts
+const EMIT_PORTS_BRAND = Symbol.for("codemation.emitPorts");
+function emitPorts(ports) {
+	return {
+		[EMIT_PORTS_BRAND]: true,
+		ports
+	};
+}
+function isPortsEmission(value) {
+	return typeof value === "object" && value !== null && EMIT_PORTS_BRAND in value && value[EMIT_PORTS_BRAND] === true;
+}
+function isUnbrandedPortsEmissionShape(value) {
+	return typeof value === "object" && value !== null && "ports" in value && !isPortsEmission(value);
+}
+
+//#endregion
+//#region src/contracts/NoRetryPolicy.ts
+var NoRetryPolicy = class {
+	kind = "none";
+};
+
+//#endregion
+//#region src/contracts/RetryPolicy.ts
+var RetryPolicy = class {
+	kind = "fixed";
+	constructor(maxAttempts, delayMs) {
+		this.maxAttempts = maxAttempts;
+		this.delayMs = delayMs;
+		if (!Number.isFinite(maxAttempts) || maxAttempts < 1 || !Number.isInteger(maxAttempts)) throw new Error(`RetryPolicy.maxAttempts must be a positive integer, got ${maxAttempts}`);
+		if (!Number.isFinite(delayMs) || delayMs < 0) throw new Error(`RetryPolicy.delayMs must be a non-negative finite number, got ${delayMs}`);
+	}
+	/** Default for HTTP-style transient failures: 3 tries, 1s between attempts. */
+	static defaultForHttp = {
+		kind: "fixed",
+		maxAttempts: 3,
+		delayMs: 1e3
+	};
+	/** Default for LLM / agent calls: 3 tries, 2s fixed backoff. */
+	static defaultForAiAgent = {
+		kind: "fixed",
+		maxAttempts: 3,
+		delayMs: 2e3
+	};
+};
+
+//#endregion
+//#region src/contracts/ExpRetryPolicy.ts
+var ExpRetryPolicy = class {
+	kind = "exponential";
+	constructor(maxAttempts, initialDelayMs, multiplier, maxDelayMs, jitter) {
+		this.maxAttempts = maxAttempts;
+		this.initialDelayMs = initialDelayMs;
+		this.multiplier = multiplier;
+		this.maxDelayMs = maxDelayMs;
+		this.jitter = jitter;
+		if (!Number.isFinite(maxAttempts) || maxAttempts < 1 || !Number.isInteger(maxAttempts)) throw new Error(`ExpRetryPolicy.maxAttempts must be a positive integer, got ${maxAttempts}`);
+		if (!Number.isFinite(initialDelayMs) || initialDelayMs < 0) throw new Error(`ExpRetryPolicy.initialDelayMs must be a non-negative finite number, got ${initialDelayMs}`);
+		if (!Number.isFinite(multiplier) || multiplier < 1) throw new Error(`ExpRetryPolicy.multiplier must be >= 1, got ${multiplier}`);
+	}
+};
+
+//#endregion
+//#region src/contracts/credentialTypes.ts
+var CredentialUnboundError = class CredentialUnboundError extends Error {
+	constructor(bindingKey, acceptedTypes = []) {
+		super(CredentialUnboundError.createMessage(bindingKey, acceptedTypes));
+		this.bindingKey = bindingKey;
+		this.acceptedTypes = acceptedTypes;
+		this.name = "CredentialUnboundError";
+	}
+	static createMessage(bindingKey, acceptedTypes) {
+		const acceptedTypesSuffix = acceptedTypes.length > 0 ? ` Accepted credential types: ${acceptedTypes.join(", ")}.` : "";
+		return `Credential slot "${bindingKey.slotKey}" is not bound for workflow ${bindingKey.workflowId} node ${bindingKey.nodeId}.${acceptedTypesSuffix}`;
+	}
+};
+
+//#endregion
+//#region src/contracts/CostTrackingTelemetryContract.ts
+const CostTrackingTelemetryMetricNames = {
+	usage: "codemation.cost.usage",
+	estimatedCost: "codemation.cost.estimated"
+};
+const CostTrackingTelemetryAttributeNames = {
+	component: "cost.component",
+	provider: "cost.provider",
+	operation: "cost.operation",
+	pricingKey: "cost.pricing_key",
+	usageUnit: "cost.usage_unit",
+	currency: "cost.currency",
+	currencyScale: "cost.currency_scale",
+	estimateKind: "cost.estimate_kind"
+};
+
+//#endregion
+//#region src/contracts/NoOpCostTrackingTelemetry.ts
+var NoOpCostTrackingTelemetry = class {
+	async captureUsage(_) {}
+	forScope(_) {
+		return this;
+	}
+};
+
+//#endregion
+//#region src/contracts/NoOpCostTrackingTelemetryFactory.ts
+var NoOpCostTrackingTelemetryFactory = class {
+	create(_) {
+		return new NoOpCostTrackingTelemetry();
+	}
+};
+
+//#endregion
+//#region src/contracts/NoOpTelemetryArtifactReference.ts
+var NoOpTelemetryArtifactReference = class {
+	static value = {
+		artifactId: "telemetry-artifact-noop",
+		traceId: void 0,
+		spanId: void 0
+	};
+};
+
+//#endregion
+//#region src/contracts/NoOpTelemetrySpanScope.ts
+var NoOpTelemetrySpanScope = class {
+	static value = {
+		traceId: "00000000000000000000000000000000",
+		spanId: "0000000000000000",
+		addSpanEvent(_) {},
+		recordMetric(_) {},
+		attachArtifact(_) {
+			return NoOpTelemetryArtifactReference.value;
+		},
+		end(_ = {}) {}
+	};
+};
+
+//#endregion
+//#region src/contracts/NoOpNodeExecutionTelemetry.ts
+var NoOpNodeExecutionTelemetry = class NoOpNodeExecutionTelemetry {
+	static value = {
+		...NoOpTelemetrySpanScope.value,
+		forNode(_) {
+			return NoOpNodeExecutionTelemetry.value;
+		},
+		startChildSpan(_) {
+			return NoOpTelemetrySpanScope.value;
+		}
+	};
+};
+
+//#endregion
+//#region src/contracts/NoOpExecutionTelemetry.ts
+var NoOpExecutionTelemetry = class {
+	static value = {
+		traceId: "00000000000000000000000000000000",
+		spanId: "0000000000000000",
+		addSpanEvent(_) {},
+		recordMetric(_) {},
+		attachArtifact(_) {
+			return NoOpTelemetryArtifactReference.value;
+		},
+		forNode(_) {
+			return NoOpNodeExecutionTelemetry.value;
+		}
+	};
+};
+
+//#endregion
+//#region src/contracts/NoOpExecutionTelemetryFactory.ts
+var NoOpExecutionTelemetryFactory = class {
+	create(_) {
+		return NoOpExecutionTelemetry.value;
+	}
+};
+
+//#endregion
+//#region src/contracts/CodemationTelemetryAttributeNames.ts
+var CodemationTelemetryAttributeNames = class {
+	static workflowId = "codemation.workflow.id";
+	static runId = "codemation.run.id";
+	static nodeId = "codemation.node.id";
+	static activationId = "codemation.activation.id";
+	static nodeType = "codemation.node.type";
+	static nodeRole = "codemation.node.role";
+	static workflowFolder = "codemation.workflow.folder";
+	static connectionInvocationId = "codemation.connection.invocation_id";
+	static toolName = "codemation.tool.name";
+	static traceParentRunId = "codemation.parent.run.id";
+};
+
+//#endregion
+//#region src/contracts/GenAiTelemetryAttributeNames.ts
+var GenAiTelemetryAttributeNames = class {
+	static operationName = "gen_ai.operation.name";
+	static requestModel = "gen_ai.request.model";
+	static usageInputTokens = "gen_ai.usage.input_tokens";
+	static usageOutputTokens = "gen_ai.usage.output_tokens";
+	static usageTotalTokens = "gen_ai.usage.total_tokens";
+	static usageCacheReadInputTokens = "gen_ai.usage.cache_read.input_tokens";
+	static usageCacheCreationInputTokens = "gen_ai.usage.cache_creation.input_tokens";
+	static usageReasoningTokens = "codemation.gen_ai.usage.reasoning_tokens";
+};
+
+//#endregion
+//#region src/contracts/CodemationTelemetryMetricNames.ts
+var CodemationTelemetryMetricNames = class {
+	static agentTurns = "codemation.ai.turns";
+	static agentToolCalls = "codemation.ai.tool_calls";
+	static gmailMessagesEmitted = "codemation.gmail.messages_emitted";
+	static gmailAttachments = "codemation.gmail.attachments";
+	static gmailAttachmentBytes = "codemation.gmail.attachment_bytes";
+};
+
+//#endregion
+//#region src/contracts/runFinishedAtFactory.ts
+/** Derives workflow end time from persisted run root or node snapshots for run listings. */
+var RunFinishedAtFactory = class {
+	static resolveIso(state) {
+		if (state.finishedAt && state.status !== "running" && state.status !== "pending") return state.finishedAt;
+		if (state.status === "running" || state.status === "pending") return;
+		let max;
+		for (const snap of Object.values(state.nodeSnapshotsByNodeId)) if (snap?.finishedAt && (!max || snap.finishedAt > max)) max = snap.finishedAt;
+		return max;
+	}
+};
+
+//#endregion
+//#region src/contracts/workflowTypes.ts
+function nodeRef(nodeId) {
+	return nodeId;
+}
+const branchRef = (index) => `$${index}`;
+
+//#endregion
+//#region src/contracts/workflowActivationPolicy.ts
+/** Default for tests and harnesses: every workflow is treated as active (legacy behavior). */
+var AllWorkflowsActiveWorkflowActivationPolicy = class {
+	isActive(_workflowId) {
+		return true;
+	}
+};
+
+//#endregion
+//#region src/execution/ExecutionTelemetryCostTrackingDecoratorFactory.ts
+var ExecutionTelemetryCostTrackingDecoratorFactory = class {
+	decorateExecutionTelemetry(args) {
+		return {
+			traceId: args.telemetry.traceId,
+			spanId: args.telemetry.spanId,
+			costTracking: args.costTracking,
+			addSpanEvent: (event) => args.telemetry.addSpanEvent(event),
+			recordMetric: (metric) => args.telemetry.recordMetric(metric),
+			attachArtifact: (artifact) => args.telemetry.attachArtifact(artifact),
+			forNode: (nodeArgs) => {
+				const nodeTelemetry = args.telemetry.forNode(nodeArgs);
+				return this.decorateNodeExecutionTelemetry({
+					telemetry: nodeTelemetry,
+					costTracking: args.costTracking.forScope(nodeTelemetry)
+				});
+			}
+		};
+	}
+	decorateNodeExecutionTelemetry(args) {
+		return {
+			traceId: args.telemetry.traceId,
+			spanId: args.telemetry.spanId,
+			costTracking: args.costTracking,
+			addSpanEvent: (event) => args.telemetry.addSpanEvent(event),
+			recordMetric: (metric) => args.telemetry.recordMetric(metric),
+			attachArtifact: (artifact) => args.telemetry.attachArtifact(artifact),
+			end: (endArgs) => args.telemetry.end(endArgs),
+			startChildSpan: (spanArgs) => this.decorateTelemetrySpanScope({
+				scope: args.telemetry.startChildSpan(spanArgs),
+				costTracking: args.costTracking
+			}),
+			forNode: (nodeArgs) => {
+				const nodeTelemetry = args.telemetry.forNode(nodeArgs);
+				return this.decorateNodeExecutionTelemetry({
+					telemetry: nodeTelemetry,
+					costTracking: args.costTracking.forScope(nodeTelemetry)
+				});
+			}
+		};
+	}
+	decorateTelemetrySpanScope(args) {
+		return {
+			traceId: args.scope.traceId,
+			spanId: args.scope.spanId,
+			costTracking: args.costTracking.forScope(args.scope),
+			addSpanEvent: (event) => args.scope.addSpanEvent(event),
+			recordMetric: (metric) => args.scope.recordMetric(metric),
+			attachArtifact: (artifact) => args.scope.attachArtifact(artifact),
+			end: (endArgs) => args.scope.end(endArgs)
+		};
+	}
+};
+
 //#endregion
 //#region src/execution/DefaultExecutionContextFactory.ts
 var DefaultExecutionContextFactory = class {
-	constructor(binaryStorage = new UnavailableBinaryStorage(), currentDate = () => /* @__PURE__ */ new Date()) {
+	telemetryDecoratorFactory = new ExecutionTelemetryCostTrackingDecoratorFactory();
+	constructor(binaryStorage = new UnavailableBinaryStorage(), telemetryFactory = new NoOpExecutionTelemetryFactory(), costTrackingFactory = new NoOpCostTrackingTelemetryFactory(), currentDate = () => /* @__PURE__ */ new Date()) {
 		this.binaryStorage = binaryStorage;
+		this.telemetryFactory = telemetryFactory;
+		this.costTrackingFactory = costTrackingFactory;
 		this.currentDate = currentDate;
 	}
 	create(args) {
+		const baseTelemetry = args.telemetry ?? this.telemetryFactory.create({
+			runId: args.runId,
+			workflowId: args.workflowId,
+			parent: args.parent,
+			policySnapshot: args.policySnapshot
+		});
+		const telemetry = this.telemetryDecoratorFactory.decorateExecutionTelemetry({
+			telemetry: baseTelemetry,
+			costTracking: baseTelemetry.costTracking ?? this.costTrackingFactory.create({ telemetry: baseTelemetry })
+		});
 		return {
 			runId: args.runId,
 			workflowId: args.workflowId,
@@ -827,12 +1138,84 @@ var DefaultExecutionContextFactory = class {
 			now: this.currentDate,
 			data: args.data,
 			nodeState: args.nodeState,
+			telemetry,
 			binary: new DefaultExecutionBinaryService(this.binaryStorage, args.workflowId, args.runId, this.currentDate),
 			getCredential: args.getCredential
 		};
 	}
 };
 
+//#endregion
+//#region src/execution/CatalogBackedCostTrackingTelemetry.ts
+var CatalogBackedCostTrackingTelemetry = class CatalogBackedCostTrackingTelemetry {
+	constructor(currentScope, costCatalog) {
+		this.currentScope = currentScope;
+		this.costCatalog = costCatalog;
+	}
+	async captureUsage(args) {
+		const usageAttributes = this.createUsageAttributes(args);
+		await this.currentScope.recordMetric({
+			name: CostTrackingTelemetryMetricNames.usage,
+			value: args.quantity,
+			unit: args.usageUnit,
+			attributes: usageAttributes
+		});
+		const catalogEntry = this.costCatalog.findEntry(args);
+		if (!catalogEntry) return;
+		const estimatedAmountMinor = Math.round(args.quantity * catalogEntry.pricePerUnitMinor);
+		const costAttributes = this.createCostAttributes(args, catalogEntry.currency, catalogEntry.currencyScale);
+		await this.currentScope.recordMetric({
+			name: CostTrackingTelemetryMetricNames.estimatedCost,
+			value: estimatedAmountMinor,
+			unit: catalogEntry.currency,
+			attributes: costAttributes
+		});
+		return {
+			currency: catalogEntry.currency,
+			currencyScale: catalogEntry.currencyScale,
+			estimatedAmountMinor,
+			estimateKind: "catalog"
+		};
+	}
+	forScope(scope) {
+		return new CatalogBackedCostTrackingTelemetry(scope, this.costCatalog);
+	}
+	createUsageAttributes(args) {
+		return {
+			...args.attributes,
+			[CostTrackingTelemetryAttributeNames.component]: args.component,
+			[CostTrackingTelemetryAttributeNames.provider]: args.provider,
+			[CostTrackingTelemetryAttributeNames.operation]: args.operation,
+			[CostTrackingTelemetryAttributeNames.pricingKey]: args.pricingKey,
+			[CostTrackingTelemetryAttributeNames.usageUnit]: args.usageUnit
+		};
+	}
+	createCostAttributes(args, currency, currencyScale) {
+		return {
+			...args.attributes,
+			[CostTrackingTelemetryAttributeNames.component]: args.component,
+			[CostTrackingTelemetryAttributeNames.provider]: args.provider,
+			[CostTrackingTelemetryAttributeNames.operation]: args.operation,
+			[CostTrackingTelemetryAttributeNames.pricingKey]: args.pricingKey,
+			[CostTrackingTelemetryAttributeNames.usageUnit]: args.usageUnit,
+			[CostTrackingTelemetryAttributeNames.currency]: currency,
+			[CostTrackingTelemetryAttributeNames.currencyScale]: currencyScale,
+			[CostTrackingTelemetryAttributeNames.estimateKind]: "catalog"
+		};
+	}
+};
+
+//#endregion
+//#region src/execution/CatalogBackedCostTrackingTelemetryFactory.ts
+var CatalogBackedCostTrackingTelemetryFactory = class {
+	constructor(costCatalog) {
+		this.costCatalog = costCatalog;
+	}
+	create(args) {
+		return new CatalogBackedCostTrackingTelemetry(args.telemetry, this.costCatalog);
+	}
+};
+
 //#endregion
 //#region src/execution/InProcessRetryRunner.ts
 var InProcessRetryRunner = class InProcessRetryRunner {
@@ -931,22 +1314,6 @@ var ItemExprResolver = class {
 	}
 };
 
-//#endregion
-//#region src/contracts/emitPorts.ts
-const EMIT_PORTS_BRAND = Symbol.for("codemation.emitPorts");
-function emitPorts(ports) {
-	return {
-		[EMIT_PORTS_BRAND]: true,
-		ports
-	};
-}
-function isPortsEmission(value) {
-	return typeof value === "object" && value !== null && EMIT_PORTS_BRAND in value && value[EMIT_PORTS_BRAND] === true;
-}
-function isUnbrandedPortsEmissionShape(value) {
-	return typeof value === "object" && value !== null && "ports" in value && !isPortsEmission(value);
-}
-
 //#endregion
 //#region src/execution/NodeOutputNormalizer.ts
 var NodeOutputNormalizer = class {
@@ -1090,6 +1457,10 @@ var NodeActivationRequestComposer = class {
 			nodeId: definition.id,
 			activationId,
 			config: definition.config,
+			telemetry: args.base.telemetry.forNode({
+				nodeId: definition.id,
+				activationId
+			}),
 			binary: args.base.binary.forNode({
 				nodeId: definition.id,
 				activationId
@@ -1886,6 +2257,7 @@ var WorkflowRunExecutionContextFactory = class {
 			runId: args.runId,
 			workflowId: args.workflowId,
 			parent: args.parent,
+			policySnapshot: args.policySnapshot,
 			subworkflowDepth: args.subworkflowDepth,
 			engineMaxNodeActivations: args.engineMaxNodeActivations,
 			engineMaxSubworkflowDepth: args.engineMaxSubworkflowDepth,
@@ -1896,6 +2268,24 @@ var WorkflowRunExecutionContextFactory = class {
 	}
 };
 
+//#endregion
+//#region src/execution/StaticCostCatalog.ts
+var StaticCostCatalog = class {
+	entriesByKey;
+	constructor(entries) {
+		this.entriesByKey = new Map(entries.map((entry) => [this.createKeyFromEntry(entry), entry]));
+	}
+	findEntry(args) {
+		return this.entriesByKey.get(this.createKeyFromUsage(args));
+	}
+	createKeyFromEntry(entry) {
+		return `${entry.component}::${entry.provider}::${entry.operation}::${entry.pricingKey}::${entry.usageUnit}`;
+	}
+	createKeyFromUsage(args) {
+		return `${args.component}::${args.provider}::${args.operation}::${args.pricingKey}::${args.usageUnit}`;
+	}
+};
+
 //#endregion
 //#region src/planning/WorkflowTopologyPlanner.ts
 var WorkflowTopology = class WorkflowTopology {
@@ -2035,6 +2425,7 @@ var RunContinuationService = class {
 			workflowId: state.workflowId,
 			nodeId: args.nodeId,
 			parent: state.parent,
+			policySnapshot: state.policySnapshot,
 			subworkflowDepth: state.executionOptions?.subworkflowDepth ?? 0,
 			engineMaxNodeActivations: limits.engineMaxNodeActivations,
 			engineMaxSubworkflowDepth: limits.engineMaxSubworkflowDepth,
@@ -2555,6 +2946,7 @@ var RunContinuationService = class {
 			workflowId: args.state.workflowId,
 			nodeId: nextDefinition.id,
 			parent: args.state.parent,
+			policySnapshot: args.state.policySnapshot,
 			subworkflowDepth: args.state.executionOptions?.subworkflowDepth ?? 0,
 			engineMaxNodeActivations: webhookLimits.engineMaxNodeActivations,
 			engineMaxSubworkflowDepth: webhookLimits.engineMaxSubworkflowDepth,
@@ -2645,6 +3037,7 @@ var RunContinuationService = class {
 			workflowId: state.workflowId,
 			nodeId,
 			parent: state.parent,
+			policySnapshot: state.policySnapshot,
 			subworkflowDepth: state.executionOptions?.subworkflowDepth ?? 0,
 			engineMaxNodeActivations: limits.engineMaxNodeActivations,
 			engineMaxSubworkflowDepth: limits.engineMaxSubworkflowDepth,
@@ -2658,6 +3051,10 @@ var RunContinuationService = class {
 			nodeId,
 			activationId,
 			config: def.config,
+			telemetry: base.telemetry.forNode({
+				nodeId,
+				activationId
+			}),
 			binary: base.binary.forNode({
 				nodeId,
 				activationId
@@ -3026,6 +3423,9 @@ var RunPolicySnapshotFactory = class {
 		return {
 			retentionSeconds: prune?.runDataRetentionSeconds ?? defaults?.retentionSeconds,
 			binaryRetentionSeconds: prune?.binaryRetentionSeconds ?? defaults?.binaryRetentionSeconds,
+			telemetrySpanRetentionSeconds: prune?.telemetrySpanRetentionSeconds ?? defaults?.telemetrySpanRetentionSeconds,
+			telemetryArtifactRetentionSeconds: prune?.telemetryArtifactRetentionSeconds ?? defaults?.telemetryArtifactRetentionSeconds,
+			telemetryMetricRetentionSeconds: prune?.telemetryMetricRetentionSeconds ?? defaults?.telemetryMetricRetentionSeconds,
 			storagePolicy: typeof workflow.storagePolicy === "string" ? workflow.storagePolicy : defaults?.storagePolicy ?? "ALL"
 		};
 	}
@@ -3073,6 +3473,7 @@ var RunStartService = class {
 			workflowId: workflow.id,
 			nodeId: startAt,
 			parent,
+			policySnapshot,
 			subworkflowDepth: mergedExecutionOptions.subworkflowDepth ?? 0,
 			engineMaxNodeActivations: mergedExecutionOptions.maxNodeActivations,
 			engineMaxSubworkflowDepth: mergedExecutionOptions.maxSubworkflowDepth,
@@ -3171,6 +3572,7 @@ var RunStartService = class {
 			workflowId: request.workflow.id,
 			nodeId: WorkflowExecutableNodeClassifierFactory.create(request.workflow).firstExecutableNodeIdInDefinitionOrder(request.workflow) ?? "unknown_node",
 			parent: request.parent,
+			policySnapshot,
 			subworkflowDepth: mergedExecutionOptions.subworkflowDepth ?? 0,
 			engineMaxNodeActivations: mergedExecutionOptions.maxNodeActivations,
 			engineMaxSubworkflowDepth: mergedExecutionOptions.maxSubworkflowDepth,
@@ -3823,19 +4225,6 @@ var InMemoryRunDataFactory = class {
 	}
 };
 
-//#endregion
-//#region src/contracts/runFinishedAtFactory.ts
-/** Derives workflow end time from persisted run root or node snapshots for run listings. */
-var RunFinishedAtFactory = class {
-	static resolveIso(state) {
-		if (state.finishedAt && state.status !== "running" && state.status !== "pending") return state.finishedAt;
-		if (state.status === "running" || state.status === "pending") return;
-		let max;
-		for (const snap of Object.values(state.nodeSnapshotsByNodeId)) if (snap?.finishedAt && (!max || snap.finishedAt > max)) max = snap.finishedAt;
-		return max;
-	}
-};
-
 //#endregion
 //#region src/orchestration/NodeExecutionRequestHandlerService.ts
 var NodeExecutionRequestHandlerService = class {
@@ -3870,6 +4259,7 @@ var NodeExecutionRequestHandlerService = class {
 			workflowId: state.workflowId,
 			nodeId: request.nodeId,
 			parent: resolvedParent,
+			policySnapshot: state.policySnapshot,
 			subworkflowDepth: state.executionOptions?.subworkflowDepth ?? 0,
 			engineMaxNodeActivations: limits.engineMaxNodeActivations,
 			engineMaxSubworkflowDepth: limits.engineMaxSubworkflowDepth,
@@ -4880,5 +5270,5 @@ var WorkflowRepositoryWebhookTriggerMatcherFactory = class {
 };
 
 //#endregion
-export { chatModel as $, NodeExecutor as A, DefaultAsyncSleeper as B, RunPolicySnapshotFactory as C, PersistedWorkflowTokenRegistry as D, WorkflowSnapshotCodec as E, isPortsEmission as F, NodeEventPublisher as G, getOriginIndexFromItem as H, isUnbrandedPortsEmissionShape as I, ConnectionNodeIdFactory as J, WorkflowExecutableNodeClassifierFactory as K, ItemExprResolver as L, RunnableOutputBehaviorResolver as M, NodeOutputNormalizer as N, MissingRuntimeTriggerToken as O, emitPorts as P, resolveItemExprsInUnknown as Q, InProcessRetryRunner as R, ConfigDrivenOffloadPolicy as S, NodeInstanceFactory as T, DefaultExecutionBinaryService as U, CredentialResolverFactory as V, UnavailableBinaryStorage as W, itemExpr as X, isItemExpr as Y, resolveItemExprsForExecution as Z, EngineExecutionLimitsPolicy as _, CoreTokens as _t, InMemoryLiveWorkflowRepository as a, StackTraceCallSitePathResolver as at, HintOnlyOffloadPolicy as b, EngineFactory as c, delay as ct, InMemoryRunDataFactory as d, injectable as dt, getPersistedRuntimeTypeMetadata as et, InMemoryBinaryStorage as f, instanceCachingFactory as ft, ENGINE_EXECUTION_LIMITS_DEFAULTS as g, singleton as gt, RunTerminalPersistenceCoordinator as h, registry as ht, RunIntentService as i, PersistedRuntimeTypeMetadataStore as it, InProcessRetryRunnerFactory as j, NodeExecutorFactory as k, Engine as l, inject as lt, WorkflowPolicyErrorServices as m, predicateAwareClassFactory as mt, WorkflowRepositoryWebhookTriggerMatcher as n, tool as nt, EngineWorkflowRunnerServiceFactory as o, PersistedRuntimeTypeNameResolver as ot, WorkflowStoragePolicyEvaluator as p, instancePerContainerCachingFactory as pt, WorkflowExecutableNodeClassifier as q, RunIntentServiceFactory as r, InjectableRuntimeDecoratorComposer as rt, EngineWorkflowRunnerService as s, container$1 as st, WorkflowRepositoryWebhookTriggerMatcherFactory as t, node as tt, RunFinishedAtFactory as u, injectAll as ut, LocalOnlyScheduler as v, NodeInstanceFactoryFactory as w, DefaultDrivingScheduler as x, InlineDrivingScheduler as y, DefaultExecutionContextFactory as z };
-//# sourceMappingURL=runtime-CJnObwsU.js.map
+export { CostTrackingTelemetryMetricNames as $, NodeExecutor as A, inject as At, nodeRef as B, StaticCostCatalog as C, tool as Ct, PersistedWorkflowTokenRegistry as D, PersistedRuntimeTypeNameResolver as Dt, WorkflowSnapshotCodec as E, StackTraceCallSitePathResolver as Et, InProcessRetryRunner as F, predicateAwareClassFactory as Ft, NoOpExecutionTelemetryFactory as G, CodemationTelemetryMetricNames as H, CatalogBackedCostTrackingTelemetryFactory as I, registry as It, NoOpTelemetrySpanScope as J, NoOpExecutionTelemetry as K, DefaultExecutionContextFactory as L, singleton as Lt, RunnableOutputBehaviorResolver as M, injectable as Mt, NodeOutputNormalizer as N, instanceCachingFactory as Nt, MissingRuntimeTriggerToken as O, container$1 as Ot, ItemExprResolver as P, instancePerContainerCachingFactory as Pt, CostTrackingTelemetryAttributeNames as Q, AllWorkflowsActiveWorkflowActivationPolicy as R, CoreTokens as Rt, RunPolicySnapshotFactory as S, node as St, NodeInstanceFactory as T, PersistedRuntimeTypeMetadataStore as Tt, GenAiTelemetryAttributeNames as U, RunFinishedAtFactory as V, CodemationTelemetryAttributeNames as W, NoOpCostTrackingTelemetryFactory as X, NoOpTelemetryArtifactReference as Y, NoOpCostTrackingTelemetry as Z, LocalOnlyScheduler as _, itemExpr as _t, InMemoryLiveWorkflowRepository as a, isPortsEmission as at, DefaultDrivingScheduler as b, chatModel as bt, EngineFactory as c, CredentialResolverFactory as ct, InMemoryBinaryStorage as d, UnavailableBinaryStorage as dt, CredentialUnboundError as et, WorkflowStoragePolicyEvaluator as f, NodeEventPublisher as ft, EngineExecutionLimitsPolicy as g, isItemExpr as gt, ENGINE_EXECUTION_LIMITS_DEFAULTS as h, ConnectionNodeIdFactory as ht, RunIntentService as i, emitPorts as it, InProcessRetryRunnerFactory as j, injectAll as jt, NodeExecutorFactory as k, delay as kt, Engine as l, getOriginIndexFromItem as lt, RunTerminalPersistenceCoordinator as m, WorkflowExecutableNodeClassifier as mt, WorkflowRepositoryWebhookTriggerMatcher as n, RetryPolicy as nt, EngineWorkflowRunnerServiceFactory as o, isUnbrandedPortsEmissionShape as ot, WorkflowPolicyErrorServices as p, WorkflowExecutableNodeClassifierFactory as pt, NoOpNodeExecutionTelemetry as q, RunIntentServiceFactory as r, NoRetryPolicy as rt, EngineWorkflowRunnerService as s, DefaultAsyncSleeper as st, WorkflowRepositoryWebhookTriggerMatcherFactory as t, ExpRetryPolicy as tt, InMemoryRunDataFactory as u, DefaultExecutionBinaryService as ut, InlineDrivingScheduler as v, resolveItemExprsForExecution as vt, NodeInstanceFactoryFactory as w, InjectableRuntimeDecoratorComposer as wt, ConfigDrivenOffloadPolicy as x, getPersistedRuntimeTypeMetadata as xt, HintOnlyOffloadPolicy as y, resolveItemExprsInUnknown as yt, branchRef as z };
+//# sourceMappingURL=runtime-DUW6tIJ1.js.map