@codemation/core 0.6.0 → 0.8.0

package/dist/{runtime-DVBwxFvX.cjs → runtime-Dvo2ru5A.cjs}

@@ -165,43 +165,43 @@ function chatModel(options = {}) {
 }
 
 //#endregion
-//#region src/contracts/itemValue.ts
-const ITEM_VALUE_BRAND = Symbol.for("codemation.itemValue");
-function itemValue(fn) {
+//#region src/contracts/itemExpr.ts
+const ITEM_EXPR_BRAND = Symbol.for("codemation.itemExpr");
+function itemExpr(fn) {
 	return {
-		[ITEM_VALUE_BRAND]: true,
+		[ITEM_EXPR_BRAND]: true,
 		fn
 	};
 }
-function isItemValue(value) {
+function isItemExpr(value) {
 	if (typeof value !== "object" || value === null) return false;
 	const v = value;
-	if (v[ITEM_VALUE_BRAND] === true) return true;
+	if (v[ITEM_EXPR_BRAND] === true) return true;
 	const keys = Object.keys(v);
 	if (keys.length === 1 && keys[0] === "fn" && typeof v.fn === "function") return true;
-	for (const sym of Object.getOwnPropertySymbols(v)) if (sym.description === "codemation.itemValue" && v[sym] === true) return true;
+	for (const sym of Object.getOwnPropertySymbols(v)) if (sym.description === "codemation.itemExpr" && v[sym] === true) return true;
 	return false;
 }
-function containsItemValueInUnknown(value, seen = /* @__PURE__ */ new WeakSet()) {
-	if (isItemValue(value)) return true;
+function containsItemExprInUnknown(value, seen = /* @__PURE__ */ new WeakSet()) {
+	if (isItemExpr(value)) return true;
 	if (value === null || typeof value !== "object") return false;
 	if (seen.has(value)) return false;
 	seen.add(value);
-	if (Array.isArray(value)) return value.some((entry) => containsItemValueInUnknown(entry, seen));
-	for (const entry of Object.values(value)) if (containsItemValueInUnknown(entry, seen)) return true;
+	if (Array.isArray(value)) return value.some((entry) => containsItemExprInUnknown(entry, seen));
+	for (const entry of Object.values(value)) if (containsItemExprInUnknown(entry, seen)) return true;
 	return false;
 }
 /**
-* Deep-resolves {@link itemValue} leaves. Returns a new graph (does not mutate the original config object).
+* Deep-resolves {@link itemExpr} leaves. Returns a new graph (does not mutate the original config object).
 */
-async function resolveItemValuesInUnknown(value, args, seen = /* @__PURE__ */ new WeakSet()) {
-	if (isItemValue(value)) return await Promise.resolve(value.fn(args));
+async function resolveItemExprsInUnknown(value, args, seen = /* @__PURE__ */ new WeakSet()) {
+	if (isItemExpr(value)) return await Promise.resolve(value.fn(args));
 	if (value === null || typeof value !== "object") return value;
 	if (seen.has(value)) return value;
 	seen.add(value);
 	if (Array.isArray(value)) {
 		const out$1 = [];
-		for (let i = 0; i < value.length; i++) out$1.push(await resolveItemValuesInUnknown(value[i], args, seen));
+		for (let i = 0; i < value.length; i++) out$1.push(await resolveItemExprsInUnknown(value[i], args, seen));
 		return out$1;
 	}
 	const rec = value;
@@ -209,14 +209,14 @@ async function resolveItemValuesInUnknown(value, args, seen = /* @__PURE__ */ ne
 	const proto = Object.getPrototypeOf(value);
 	if (proto !== Object.prototype && proto !== null && entries.length === 0) return value;
 	const out = Object.create(proto);
-	for (const [k, v] of entries) out[k] = await resolveItemValuesInUnknown(v, args, seen);
+	for (const [k, v] of entries) out[k] = await resolveItemExprsInUnknown(v, args, seen);
 	return out;
 }
 /**
-* Clones runnable config (best-effort) so per-item {@link itemValue} resolution never mutates shared instances.
+* Clones runnable config (best-effort) so per-item {@link itemExpr} resolution never mutates shared instances.
 */
-async function resolveItemValuesForExecution(config, nodeCtx, item, itemIndex, items) {
-	const ivArgs = {
+async function resolveItemExprsForExecution(config, nodeCtx, item, itemIndex, items) {
+	const exprArgs = {
 		item,
 		itemIndex,
 		items,
@@ -228,8 +228,8 @@ async function resolveItemValuesForExecution(config, nodeCtx, item, itemIndex, i
 			data: nodeCtx.data
 		}
 	};
-	if (!containsItemValueInUnknown(config)) return;
-	return await resolveItemValuesInUnknown(config, ivArgs);
+	if (!containsItemExprInUnknown(config)) return;
+	return await resolveItemExprsInUnknown(config, exprArgs);
 }
 
 //#endregion
@@ -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 {
@@ -941,14 +1324,14 @@ var InProcessRetryRunner = class InProcessRetryRunner {
 };
 
 //#endregion
-//#region src/execution/ItemValueResolver.ts
+//#region src/execution/ItemExprResolver.ts
 /**
-* Resolves {@link import("../contracts/itemValue").ItemValue} leaves on runnable config before {@link RunnableNode.execute}.
+* Resolves {@link import("../contracts/itemExpr").ItemExpr} leaves on runnable config before {@link RunnableNode.execute}.
 */
-var ItemValueResolver = class {
+var ItemExprResolver = class {
 	async resolveConfigForItem(ctx, item, itemIndex, items) {
-		if (!ctx) throw new Error("ItemValueResolver.resolveConfigForItem: ctx is required");
-		const resolvedConfig = await resolveItemValuesForExecution(ctx.config, ctx, item, itemIndex, items);
+		if (!ctx) throw new Error("ItemExprResolver.resolveConfigForItem: ctx is required");
+		const resolvedConfig = await resolveItemExprsForExecution(ctx.config, ctx, item, itemIndex, items);
 		const merged = resolvedConfig !== void 0 && resolvedConfig !== null ? resolvedConfig : ctx.config;
 		if (merged === void 0 || merged === null) return ctx;
 		return {
@@ -958,22 +1341,6 @@ var ItemValueResolver = 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
@@ -1131,12 +1502,12 @@ var NodeActivationRequestComposer = class {
 var NodeExecutor = class {
 	fanInMerger = new FanInMergeByOriginMerger();
 	outputNormalizer = new NodeOutputNormalizer();
-	itemValueResolver;
+	itemExprResolver;
 	outputBehaviorResolver;
-	constructor(nodeInstanceFactory, retryRunner, itemValueResolver, outputBehaviorResolver) {
+	constructor(nodeInstanceFactory, retryRunner, itemExprResolver, outputBehaviorResolver) {
 		this.nodeInstanceFactory = nodeInstanceFactory;
 		this.retryRunner = retryRunner;
-		this.itemValueResolver = itemValueResolver ?? new ItemValueResolver();
+		this.itemExprResolver = itemExprResolver ?? new ItemExprResolver();
 		this.outputBehaviorResolver = outputBehaviorResolver ?? new RunnableOutputBehaviorResolver();
 	}
 	async execute(request) {
@@ -1207,7 +1578,7 @@ var NodeExecutor = class {
 			const syntheticItem = { json: {} };
 			const parsed = inputSchema.parse(syntheticItem.json);
 			const runnableCtx = request.ctx;
-			const resolvedCtx = await this.itemValueResolver.resolveConfigForItem(runnableCtx, syntheticItem, 0, inputBatch);
+			const resolvedCtx = await this.itemExprResolver.resolveConfigForItem(runnableCtx, syntheticItem, 0, inputBatch);
 			const args = {
 				input: parsed,
 				item: syntheticItem,
@@ -1228,7 +1599,7 @@ var NodeExecutor = class {
 			this.assertItemJsonNotTopLevelArray(request.nodeId, item);
 			const parsed = inputSchema.parse(item.json);
 			const runnableCtx = request.ctx;
-			const resolvedCtx = await this.itemValueResolver.resolveConfigForItem(runnableCtx, item, i, inputBatch);
+			const resolvedCtx = await this.itemExprResolver.resolveConfigForItem(runnableCtx, item, i, inputBatch);
 			const ctx = this.pickExecutionContext(runnableCtx, resolvedCtx);
 			const args = {
 				input: parsed,
@@ -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 () {
@@ -5039,10 +5483,10 @@ Object.defineProperty(exports, 'InlineDrivingScheduler', {
     return InlineDrivingScheduler;
   }
 });
-Object.defineProperty(exports, 'ItemValueResolver', {
+Object.defineProperty(exports, 'ItemExprResolver', {
   enumerable: true,
   get: function () {
-    return ItemValueResolver;
+    return ItemExprResolver;
   }
 });
 Object.defineProperty(exports, 'LocalOnlyScheduler', {
@@ -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 () {
@@ -5231,10 +5741,10 @@ Object.defineProperty(exports, 'getPersistedRuntimeTypeMetadata', {
     return getPersistedRuntimeTypeMetadata;
   }
 });
-Object.defineProperty(exports, 'isItemValue', {
+Object.defineProperty(exports, 'isItemExpr', {
   enumerable: true,
   get: function () {
-    return isItemValue;
+    return isItemExpr;
   }
 });
 Object.defineProperty(exports, 'isPortsEmission', {
@@ -5249,10 +5759,10 @@ Object.defineProperty(exports, 'isUnbrandedPortsEmissionShape', {
     return isUnbrandedPortsEmissionShape;
   }
 });
-Object.defineProperty(exports, 'itemValue', {
+Object.defineProperty(exports, 'itemExpr', {
   enumerable: true,
   get: function () {
-    return itemValue;
+    return itemExpr;
   }
 });
 Object.defineProperty(exports, 'node', {
@@ -5261,16 +5771,22 @@ Object.defineProperty(exports, 'node', {
     return node;
   }
 });
-Object.defineProperty(exports, 'resolveItemValuesForExecution', {
+Object.defineProperty(exports, 'nodeRef', {
+  enumerable: true,
+  get: function () {
+    return nodeRef;
+  }
+});
+Object.defineProperty(exports, 'resolveItemExprsForExecution', {
   enumerable: true,
   get: function () {
-    return resolveItemValuesForExecution;
+    return resolveItemExprsForExecution;
   }
 });
-Object.defineProperty(exports, 'resolveItemValuesInUnknown', {
+Object.defineProperty(exports, 'resolveItemExprsInUnknown', {
   enumerable: true,
   get: function () {
-    return resolveItemValuesInUnknown;
+    return resolveItemExprsInUnknown;
   }
 });
 Object.defineProperty(exports, 'tool', {
@@ -5279,4 +5795,4 @@ Object.defineProperty(exports, 'tool', {
     return tool;
   }
 });
-//# sourceMappingURL=runtime-DVBwxFvX.cjs.map
+//# sourceMappingURL=runtime-Dvo2ru5A.cjs.map