@codemation/core 0.7.0 → 0.8.0

package/dist/{runtime-3YVDd2vY.cjs → runtime-Dvo2ru5A.cjs}

@@ -562,7 +562,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
 			}
 		};
 	}
@@ -836,14 +837,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,
@@ -854,12 +1165,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 {
@@ -958,22 +1341,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 {
@@ -1117,6 +1484,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
@@ -1913,6 +2284,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,
@@ -1923,6 +2295,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 {
@@ -2062,6 +2452,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,
@@ -2582,6 +2973,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,
@@ -2672,6 +3064,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,
@@ -2685,6 +3078,10 @@ var RunContinuationService = class {
 			nodeId,
 			activationId,
 			config: def.config,
+			telemetry: base.telemetry.forNode({
+				nodeId,
+				activationId
+			}),
 			binary: base.binary.forNode({
 				nodeId,
 				activationId
@@ -3053,6 +3450,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"
 		};
 	}
@@ -3100,6 +3500,7 @@ var RunStartService = class {
 			workflowId: workflow.id,
 			nodeId: startAt,
 			parent,
+			policySnapshot,
 			subworkflowDepth: mergedExecutionOptions.subworkflowDepth ?? 0,
 			engineMaxNodeActivations: mergedExecutionOptions.maxNodeActivations,
 			engineMaxSubworkflowDepth: mergedExecutionOptions.maxSubworkflowDepth,
@@ -3198,6 +3599,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,
@@ -3850,19 +4252,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 {
@@ -3897,6 +4286,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,
@@ -4907,6 +5297,30 @@ var WorkflowRepositoryWebhookTriggerMatcherFactory = class {
 };
 
 //#endregion
+Object.defineProperty(exports, 'AllWorkflowsActiveWorkflowActivationPolicy', {
+  enumerable: true,
+  get: function () {
+    return AllWorkflowsActiveWorkflowActivationPolicy;
+  }
+});
+Object.defineProperty(exports, 'CatalogBackedCostTrackingTelemetryFactory', {
+  enumerable: true,
+  get: function () {
+    return CatalogBackedCostTrackingTelemetryFactory;
+  }
+});
+Object.defineProperty(exports, 'CodemationTelemetryAttributeNames', {
+  enumerable: true,
+  get: function () {
+    return CodemationTelemetryAttributeNames;
+  }
+});
+Object.defineProperty(exports, 'CodemationTelemetryMetricNames', {
+  enumerable: true,
+  get: function () {
+    return CodemationTelemetryMetricNames;
+  }
+});
 Object.defineProperty(exports, 'ConfigDrivenOffloadPolicy', {
   enumerable: true,
   get: function () {
@@ -4925,12 +5339,30 @@ Object.defineProperty(exports, 'CoreTokens', {
     return CoreTokens;
   }
 });
+Object.defineProperty(exports, 'CostTrackingTelemetryAttributeNames', {
+  enumerable: true,
+  get: function () {
+    return CostTrackingTelemetryAttributeNames;
+  }
+});
+Object.defineProperty(exports, 'CostTrackingTelemetryMetricNames', {
+  enumerable: true,
+  get: function () {
+    return CostTrackingTelemetryMetricNames;
+  }
+});
 Object.defineProperty(exports, 'CredentialResolverFactory', {
   enumerable: true,
   get: function () {
     return CredentialResolverFactory;
   }
 });
+Object.defineProperty(exports, 'CredentialUnboundError', {
+  enumerable: true,
+  get: function () {
+    return CredentialUnboundError;
+  }
+});
 Object.defineProperty(exports, 'DefaultAsyncSleeper', {
   enumerable: true,
   get: function () {
@@ -4991,6 +5423,18 @@ Object.defineProperty(exports, 'EngineWorkflowRunnerServiceFactory', {
     return EngineWorkflowRunnerServiceFactory;
   }
 });
+Object.defineProperty(exports, 'ExpRetryPolicy', {
+  enumerable: true,
+  get: function () {
+    return ExpRetryPolicy;
+  }
+});
+Object.defineProperty(exports, 'GenAiTelemetryAttributeNames', {
+  enumerable: true,
+  get: function () {
+    return GenAiTelemetryAttributeNames;
+  }
+});
 Object.defineProperty(exports, 'HintOnlyOffloadPolicy', {
   enumerable: true,
   get: function () {
@@ -5057,6 +5501,54 @@ Object.defineProperty(exports, 'MissingRuntimeTriggerToken', {
     return MissingRuntimeTriggerToken;
   }
 });
+Object.defineProperty(exports, 'NoOpCostTrackingTelemetry', {
+  enumerable: true,
+  get: function () {
+    return NoOpCostTrackingTelemetry;
+  }
+});
+Object.defineProperty(exports, 'NoOpCostTrackingTelemetryFactory', {
+  enumerable: true,
+  get: function () {
+    return NoOpCostTrackingTelemetryFactory;
+  }
+});
+Object.defineProperty(exports, 'NoOpExecutionTelemetry', {
+  enumerable: true,
+  get: function () {
+    return NoOpExecutionTelemetry;
+  }
+});
+Object.defineProperty(exports, 'NoOpExecutionTelemetryFactory', {
+  enumerable: true,
+  get: function () {
+    return NoOpExecutionTelemetryFactory;
+  }
+});
+Object.defineProperty(exports, 'NoOpNodeExecutionTelemetry', {
+  enumerable: true,
+  get: function () {
+    return NoOpNodeExecutionTelemetry;
+  }
+});
+Object.defineProperty(exports, 'NoOpTelemetryArtifactReference', {
+  enumerable: true,
+  get: function () {
+    return NoOpTelemetryArtifactReference;
+  }
+});
+Object.defineProperty(exports, 'NoOpTelemetrySpanScope', {
+  enumerable: true,
+  get: function () {
+    return NoOpTelemetrySpanScope;
+  }
+});
+Object.defineProperty(exports, 'NoRetryPolicy', {
+  enumerable: true,
+  get: function () {
+    return NoRetryPolicy;
+  }
+});
 Object.defineProperty(exports, 'NodeEventPublisher', {
   enumerable: true,
   get: function () {
@@ -5111,6 +5603,12 @@ Object.defineProperty(exports, 'PersistedWorkflowTokenRegistry', {
     return PersistedWorkflowTokenRegistry;
   }
 });
+Object.defineProperty(exports, 'RetryPolicy', {
+  enumerable: true,
+  get: function () {
+    return RetryPolicy;
+  }
+});
 Object.defineProperty(exports, 'RunFinishedAtFactory', {
   enumerable: true,
   get: function () {
@@ -5153,6 +5651,12 @@ Object.defineProperty(exports, 'StackTraceCallSitePathResolver', {
     return StackTraceCallSitePathResolver;
   }
 });
+Object.defineProperty(exports, 'StaticCostCatalog', {
+  enumerable: true,
+  get: function () {
+    return StaticCostCatalog;
+  }
+});
 Object.defineProperty(exports, 'UnavailableBinaryStorage', {
   enumerable: true,
   get: function () {
@@ -5207,6 +5711,12 @@ Object.defineProperty(exports, '__toESM', {
     return __toESM;
   }
 });
+Object.defineProperty(exports, 'branchRef', {
+  enumerable: true,
+  get: function () {
+    return branchRef;
+  }
+});
 Object.defineProperty(exports, 'chatModel', {
   enumerable: true,
   get: function () {
@@ -5261,6 +5771,12 @@ Object.defineProperty(exports, 'node', {
     return node;
   }
 });
+Object.defineProperty(exports, 'nodeRef', {
+  enumerable: true,
+  get: function () {
+    return nodeRef;
+  }
+});
 Object.defineProperty(exports, 'resolveItemExprsForExecution', {
   enumerable: true,
   get: function () {
@@ -5279,4 +5795,4 @@ Object.defineProperty(exports, 'tool', {
     return tool;
   }
 });
-//# sourceMappingURL=runtime-3YVDd2vY.cjs.map
+//# sourceMappingURL=runtime-Dvo2ru5A.cjs.map