@codemation/core 0.10.1 → 0.11.0

package/dist/{runtime-BGNbRnqs.js → runtime-Duf3ClPw.js}

@@ -1,8 +1,8 @@
 import "reflect-metadata";
 import { container as container$1, delay, inject, injectAll, injectable, instanceCachingFactory, instancePerContainerCachingFactory, predicateAwareClassFactory, registry, singleton } from "tsyringe";
 import { ZodError, z } from "zod";
-import { createHash, randomUUID } from "node:crypto";
 import { ReadableStream } from "node:stream/web";
+import { createHash } from "node:crypto";
 
 //#region src/di/CoreTokens.ts
 const CoreTokens = {
@@ -25,7 +25,8 @@ const CoreTokens = {
 	BinaryStorage: Symbol.for("codemation.core.BinaryStorage"),
 	WebhookBasePath: Symbol.for("codemation.core.WebhookBasePath"),
 	EngineExecutionLimitsPolicy: Symbol.for("codemation.core.EngineExecutionLimitsPolicy"),
-	WorkflowActivationPolicy: Symbol.for("codemation.core.WorkflowActivationPolicy")
+	WorkflowActivationPolicy: Symbol.for("codemation.core.WorkflowActivationPolicy"),
+	AgentMcpIntegration: Symbol.for("codemation.core.AgentMcpIntegration")
 };
 
 //#endregion
@@ -291,6 +292,25 @@ var ConnectionNodeIdFactory = class {
 		const normalized = this.normalizeToolName(toolName);
 		return `${parentNodeId}${this.connectionSegment}tool${this.connectionSegment}${normalized}`;
 	}
+	static mcpConnectionNodeId(parentNodeId, serverId) {
+		return `${parentNodeId}${this.connectionSegment}mcp${this.connectionSegment}${serverId}`;
+	}
+	static isMcpConnectionNodeId(nodeId) {
+		return nodeId.includes(`${this.connectionSegment}mcp${this.connectionSegment}`);
+	}
+	static parseMcpConnectionNodeId(nodeId) {
+		if (!this.isMcpConnectionNodeId(nodeId)) return;
+		const marker = `${this.connectionSegment}mcp${this.connectionSegment}`;
+		const idx = nodeId.lastIndexOf(marker);
+		if (idx < 0) return;
+		const parentNodeId = nodeId.slice(0, idx);
+		const serverId = nodeId.slice(idx + marker.length);
+		if (!parentNodeId || !serverId) return;
+		return {
+			parentNodeId,
+			serverId
+		};
+	}
 	static isLanguageModelConnectionNodeId(nodeId) {
 		return nodeId.endsWith(`${this.connectionSegment}llm`);
 	}
@@ -329,12 +349,12 @@ var ConnectionNodeIdFactory = class {
 //#endregion
 //#region src/ai/AgentConnectionNodeCollector.ts
 const AgentConnectionNodeCollector = new class {
-	collect(parentNodeId, agentConfig) {
+	collect(parentNodeId, agentConfig, mcpServerResolver) {
 		const collected = [];
-		this.collectInto(parentNodeId, agentConfig, collected);
+		this.collectInto(parentNodeId, agentConfig, collected, mcpServerResolver);
 		return collected;
 	}
-	collectInto(parentNodeId, agentConfig, collected) {
+	collectInto(parentNodeId, agentConfig, collected, mcpServerResolver) {
 		collected.push({
 			nodeId: ConnectionNodeIdFactory.languageModelConnectionNodeId(parentNodeId),
 			parentNodeId,
@@ -358,13 +378,35 @@ const AgentConnectionNodeCollector = new class {
 				icon: tool$1.presentation?.icon,
 				credentialSource: tool$1
 			});
-			this.collectNestedAgentTools(toolNodeId, tool$1, collected);
+			this.collectNestedAgentTools(toolNodeId, tool$1, collected, mcpServerResolver);
+		}
+		if (mcpServerResolver) {
+			const mcpServers = agentConfig.mcpServers;
+			for (const serverId of mcpServers ?? []) {
+				const decl = mcpServerResolver(serverId);
+				if (!decl) continue;
+				const acceptedTypes = decl.acceptedCredentialTypes ?? [];
+				collected.push({
+					nodeId: ConnectionNodeIdFactory.mcpConnectionNodeId(parentNodeId, serverId),
+					parentNodeId,
+					connectionName: "tools",
+					role: "tool",
+					name: decl.displayName,
+					typeName: serverId,
+					icon: "lucide:plug",
+					credentialSource: { getCredentialRequirements: () => [{
+						slotKey: "credential",
+						label: decl.displayName,
+						acceptedTypes
+					}] }
+				});
+			}
 		}
 	}
-	collectNestedAgentTools(toolNodeId, tool$1, collected) {
+	collectNestedAgentTools(toolNodeId, tool$1, collected, mcpServerResolver) {
 		if (!this.isNodeBackedAgentTool(tool$1)) return;
 		const innerAgent = tool$1 instanceof NodeBackedToolConfig ? tool$1.node : tool$1.node;
-		this.collectInto(toolNodeId, innerAgent, collected);
+		this.collectInto(toolNodeId, innerAgent, collected, mcpServerResolver);
 	}
 	/**
 	* After JSON round-trip (persisted snapshots), tools are plain objects — `instanceof NodeBackedToolConfig` fails.
@@ -655,10 +697,13 @@ var WorkflowBuilder = class {
 //#region src/workflow/definition/ConnectionInvocationIdFactory.ts
 /**
 * Unique ids for persisted connection invocation history rows (LLM/tool calls under an owning node).
+*
+* Uses Web Crypto's `randomUUID` so this module is safe in browser-bundle contexts —
+* paired with `NodeIterationIdFactory` which had the same `node:crypto` regression.
 */
 var ConnectionInvocationIdFactory = class {
 	static create() {
-		return `cinv_${randomUUID()}`;
+		return `cinv_${globalThis.crypto.randomUUID()}`;
 	}
 	/** Deterministic id for tests when a stable sequence is needed. */
 	static createForTest(runId, connectionNodeId, sequence) {
@@ -674,10 +719,14 @@ var ConnectionInvocationIdFactory = class {
 * Activations are per-batch (one scheduled execution of a node, possibly with N items).
 * Iterations refine that to one identifier per item-index inside the batch loop, so per-item
 * connection invocations and telemetry can be grouped without time-window heuristics.
+*
+* Uses Web Crypto's `randomUUID` (Node 19+ and all modern browsers) so this module is safe
+* to include in the browser entry. Importing `node:crypto` here previously leaked into the
+* canvas client bundle through `browser.ts` and OOM'd consumers' Turbopack builds.
 */
 var NodeIterationIdFactory = class {
 	static create() {
-		return `iter_${randomUUID()}`;
+		return `iter_${globalThis.crypto.randomUUID()}`;
 	}
 	/** Deterministic id for tests when a stable sequence is needed. */
 	static createForTest(seed, sequence) {
@@ -927,6 +976,10 @@ var UnavailableBinaryStorage = class {
 		return { exists: false };
 	}
 	async delete() {}
+	async deleteMany() {}
+	async listByPrefix() {
+		return [];
+	}
 };
 
 //#endregion
@@ -995,7 +1048,8 @@ var NodeExecutionSnapshotFactory = class {
 			inputsByPort: args.inputsByPort,
 			outputs: args.outputs,
 			usedPinnedOutput: fromPinnedOutput,
-			error: void 0
+			error: void 0,
+			...args.previous?.childRunId !== void 0 ? { childRunId: args.previous.childRunId } : {}
 		};
 	}
 	static skipped(args) {
@@ -1012,7 +1066,8 @@ var NodeExecutionSnapshotFactory = class {
 			updatedAt: args.finishedAt,
 			inputsByPort: args.inputsByPort,
 			outputs: args.outputs,
-			error: void 0
+			error: void 0,
+			...args.previous?.childRunId !== void 0 ? { childRunId: args.previous.childRunId } : {}
 		};
 	}
 	static failed(args) {
@@ -1034,7 +1089,8 @@ var NodeExecutionSnapshotFactory = class {
 				name: args.error.name,
 				stack: args.error.stack,
 				details: args.error.details
-			}
+			},
+			...args.previous?.childRunId !== void 0 ? { childRunId: args.previous.childRunId } : {}
 		};
 	}
 };
@@ -1363,6 +1419,20 @@ var DefaultAsyncSleeper = class {
 	}
 };
 
+//#endregion
+//#region src/contracts/NoOpAgentMcpIntegration.ts
+/**
+* No-op implementation of AgentMcpIntegration.
+* Registered by the core engine runtime as a fallback when the host does not
+* supply a real implementation (e.g. in unit tests or headless engine setups).
+* Always returns an empty tool map so the agent runs with node-backed tools only.
+*/
+var NoOpAgentMcpIntegration = class {
+	async prepareMcpTools() {
+		return /* @__PURE__ */ new Map();
+	}
+};
+
 //#endregion
 //#region src/contracts/emitPorts.ts
 const EMIT_PORTS_BRAND = Symbol.for("codemation.emitPorts");
@@ -1602,6 +1672,10 @@ var CodemationTelemetryAttributeNames = class {
 	static iterationIndex = "codemation.iteration.index";
 	/** Set when this span/metric was recorded under a sub-agent triggered by an outer LLM/tool call. */
 	static parentInvocationId = "codemation.parent.invocation_id";
+	/** MCP server id on spans created for callTool invocations. */
+	static mcpServerId = "mcp.server_id";
+	/** MCP tool name on spans created for callTool invocations. */
+	static mcpToolName = "mcp.tool_name";
 };
 
 //#endregion
@@ -1817,18 +1891,21 @@ var CatalogBackedCostTrackingTelemetryFactory = class {
 
 //#endregion
 //#region src/execution/InProcessRetryRunner.ts
+/** Maximum permitted retry attempts — workflow-declared values above this are clamped. */
+const HARD_MAX_RETRY_ATTEMPTS = 10;
 var InProcessRetryRunner = class InProcessRetryRunner {
 	constructor(sleeper) {
 		this.sleeper = sleeper;
 	}
-	async run(policy, work) {
-		const spec = InProcessRetryRunner.normalizePolicy(policy);
+	async run(policy, work, shouldRetry, warn) {
+		const spec = InProcessRetryRunner.normalizePolicy(policy, warn);
 		let lastError;
 		for (let attempt = 1; attempt <= spec.maxAttempts; attempt++) try {
 			return await work();
 		} catch (error) {
 			lastError = error;
 			if (attempt >= spec.maxAttempts) break;
+			if (shouldRetry !== void 0 && !shouldRetry(error)) break;
 			const delayMs = InProcessRetryRunner.delayAfterFailureMs(spec, attempt);
 			await this.sleeper.sleep(delayMs);
 		}
@@ -1843,7 +1920,7 @@ var InProcessRetryRunner = class InProcessRetryRunner {
 		if (spec.maxDelayMs !== void 0 && ms > spec.maxDelayMs) ms = spec.maxDelayMs;
 		return Math.max(0, Math.floor(ms));
 	}
-	static normalizePolicy(policy) {
+	static normalizePolicy(policy, warn) {
 		if (policy === void 0) return {
 			kind: "none",
 			maxAttempts: 1
@@ -1859,17 +1936,19 @@ var InProcessRetryRunner = class InProcessRetryRunner {
 		};
 		if (kind === "fixed") {
 			const p = policy;
+			const raw = InProcessRetryRunner.assertPositiveInt(p.maxAttempts, "fixed.maxAttempts");
 			return {
 				kind: "fixed",
-				maxAttempts: InProcessRetryRunner.assertPositiveInt(p.maxAttempts, "fixed.maxAttempts"),
+				maxAttempts: InProcessRetryRunner.clampMaxAttempts(raw, warn),
 				delayMs: InProcessRetryRunner.assertNonNegativeFinite(p.delayMs, "fixed.delayMs")
 			};
 		}
 		if (kind === "exponential") {
 			const p = policy;
+			const raw = InProcessRetryRunner.assertPositiveInt(p.maxAttempts, "exponential.maxAttempts");
 			return {
 				kind: "exponential",
-				maxAttempts: InProcessRetryRunner.assertPositiveInt(p.maxAttempts, "exponential.maxAttempts"),
+				maxAttempts: InProcessRetryRunner.clampMaxAttempts(raw, warn),
 				initialDelayMs: InProcessRetryRunner.assertNonNegativeFinite(p.initialDelayMs, "exponential.initialDelayMs"),
 				multiplier: InProcessRetryRunner.assertMultiplier(p.multiplier),
 				maxDelayMs: p.maxDelayMs === void 0 ? void 0 : InProcessRetryRunner.assertNonNegativeFinite(p.maxDelayMs, "exponential.maxDelayMs"),
@@ -1881,6 +1960,13 @@ var InProcessRetryRunner = class InProcessRetryRunner {
 			maxAttempts: 1
 		};
 	}
+	static clampMaxAttempts(requested, warn) {
+		if (requested > HARD_MAX_RETRY_ATTEMPTS) {
+			warn?.(`Retry policy maxAttempts (${requested}) exceeds hard ceiling (${HARD_MAX_RETRY_ATTEMPTS}); clamping to ${HARD_MAX_RETRY_ATTEMPTS}.`);
+			return HARD_MAX_RETRY_ATTEMPTS;
+		}
+		return requested;
+	}
 	static assertPositiveInt(value, label) {
 		if (typeof value !== "number" || !Number.isFinite(value) || value < 1 || !Number.isInteger(value)) throw new Error(`Retry policy ${label} must be a positive integer`);
 		return value;
@@ -2083,12 +2169,24 @@ var NodeExecutor = class {
 		this.outputBehaviorResolver = outputBehaviorResolver ?? new RunnableOutputBehaviorResolver();
 	}
 	async execute(request) {
+		await this.assertRequiredCredentialsBound(request);
 		const policy = request.ctx.config.retryPolicy;
 		return await this.retryRunner.run(policy, async () => {
 			const nodeInstance = this.nodeInstanceFactory.createByType(request.ctx.config.type);
 			if (request.kind === "multi") return await this.executeMultiInputActivation(request, nodeInstance);
 			return await this.executeSingleInputNode(request, nodeInstance);
-		});
+		}, (error) => !this.isCredentialError(error));
+	}
+	async assertRequiredCredentialsBound(request) {
+		if (!request.ctx.getCredential) return;
+		for (const req of request.ctx.config.getCredentialRequirements?.() ?? []) {
+			if (req.optional) continue;
+			await request.ctx.getCredential(req.slotKey);
+		}
+	}
+	isCredentialError(e) {
+		if (e instanceof CredentialUnboundError) return true;
+		return (e instanceof Error ? e.cause : void 0) instanceof CredentialUnboundError;
 	}
 	async executeMultiInputActivation(request, node$1) {
 		const multiInputNode = node$1;
@@ -2398,16 +2496,20 @@ var WorkflowSnapshotCodec = class {
 			name: workflow.name,
 			workflowErrorHandlerConfigured: workflow.workflowErrorHandler !== void 0,
 			...workflow.connections !== void 0 && workflow.connections.length > 0 ? { connections: workflow.connections } : {},
-			nodes: workflow.nodes.map((node$1) => ({
-				id: node$1.id,
-				kind: node$1.kind,
-				name: node$1.name,
-				nodeTokenId: this.resolveTokenId(node$1.type),
-				configTokenId: this.resolveTokenId(node$1.config.type),
-				tokenName: this.resolveTokenName(node$1.type),
-				configTokenName: this.resolveTokenName(node$1.config.type),
-				config: this.serializeConfig(node$1.config)
-			})),
+			nodes: workflow.nodes.map((node$1) => {
+				const inspectorSummaryRows = this.safeInspectorSummary(node$1.config);
+				return {
+					id: node$1.id,
+					kind: node$1.kind,
+					name: node$1.name,
+					nodeTokenId: this.resolveTokenId(node$1.type),
+					configTokenId: this.resolveTokenId(node$1.config.type),
+					tokenName: this.resolveTokenName(node$1.type),
+					configTokenName: this.resolveTokenName(node$1.config.type),
+					config: this.serializeConfig(node$1.config),
+					...inspectorSummaryRows !== void 0 ? { inspectorSummary: inspectorSummaryRows } : {}
+				};
+			}),
 			edges: workflow.edges.map((edge) => ({
 				from: {
 					nodeId: edge.from.nodeId,
@@ -2447,6 +2549,34 @@ var WorkflowSnapshotCodec = class {
 			return fallback;
 		}
 	}
+	/**
+	* Safely call `config.inspectorSummary()` and return a plain JSON-safe array, or undefined.
+	* Returns undefined if the method is absent, throws, or produces no valid rows.
+	*/
+	safeInspectorSummary(config) {
+		const fn = config.inspectorSummary;
+		if (typeof fn !== "function") return void 0;
+		let raw;
+		try {
+			raw = fn.call(config);
+		} catch {
+			return;
+		}
+		if (!Array.isArray(raw)) return void 0;
+		const rows = [];
+		for (const entry of raw) {
+			if (!entry || typeof entry !== "object") continue;
+			const { label, value } = entry;
+			if (typeof label !== "string" || typeof value !== "string") continue;
+			const trimmedLabel = label.trim();
+			if (trimmedLabel.length === 0) continue;
+			rows.push({
+				label: trimmedLabel,
+				value
+			});
+		}
+		return rows.length > 0 ? rows : void 0;
+	}
 	injectTokenIds(target, source) {
 		const type = this.asTypeToken(source.type);
 		if (type) target.tokenId = this.tokenRegistry.getTokenId(type) ?? this.resolveTokenName(type) ?? "unknown";
@@ -2691,6 +2821,18 @@ var NodeRunStateWriter = class {
 			await this.publishNodeEvent("nodeFailed", snapshot);
 		});
 	}
+	setChildRunId(args) {
+		return this.enqueue(async () => {
+			const state = await this.loadState();
+			const previous = state.nodeSnapshotsByNodeId?.[args.nodeId];
+			if (!previous) return;
+			const updated = {
+				...previous,
+				childRunId: args.childRunId
+			};
+			await this.saveSnapshot(state, updated);
+		});
+	}
 	appendConnectionInvocation(args) {
 		return this.enqueue(async () => {
 			const state = await this.loadState();
@@ -2705,6 +2847,8 @@ var NodeRunStateWriter = class {
 				status: args.status,
 				managedInput: args.managedInput,
 				managedOutput: args.managedOutput,
+				statusLabel: args.statusLabel,
+				subjectName: args.subjectName,
 				error: args.error,
 				queuedAt: args.queuedAt,
 				startedAt: args.startedAt,
@@ -3067,7 +3211,7 @@ var RunContinuationService = class {
 		});
 		const completedActivations = (state.engineCounters?.completedNodeActivations ?? 0) + 1;
 		const engineCounters = { completedNodeActivations: completedActivations };
-		const maxNodeActivations = state.executionOptions?.maxNodeActivations ?? Number.MAX_SAFE_INTEGER;
+		const maxNodeActivations = state.executionOptions?.maxNodeActivations ?? this.executionLimitsPolicy.createRootExecutionOptions().maxNodeActivations;
 		if (this.semantics.isStopConditionSatisfied(state.control?.stopCondition, args.nodeId)) {
 			const completedState = this.persistedRunStateTerminalBuilder.mergeTerminal({
 				state,
@@ -3391,7 +3535,7 @@ var RunContinuationService = class {
 		});
 		const completedActivations = (args.state.engineCounters?.completedNodeActivations ?? 0) + 1;
 		const engineCounters = { completedNodeActivations: completedActivations };
-		const maxNodeActivations = args.state.executionOptions?.maxNodeActivations ?? Number.MAX_SAFE_INTEGER;
+		const maxNodeActivations = args.state.executionOptions?.maxNodeActivations ?? this.executionLimitsPolicy.createRootExecutionOptions().maxNodeActivations;
 		if (this.semantics.isStopConditionSatisfied(args.state.control?.stopCondition, args.args.nodeId)) {
 			const completedState = this.persistedRunStateTerminalBuilder.mergeTerminal({
 				state: args.state,
@@ -4620,25 +4764,24 @@ var InlineDrivingScheduler = class {
 		this.scheduledRuns.delete(runId);
 		try {
 			const q = this.queuesByRunId.get(runId) ?? [];
-			while (q.length > 0) {
-				const { request } = q.shift();
-				const cont = this.continuation;
-				if (!cont) throw new Error("InlineDrivingScheduler is missing a continuation (setContinuation was not called)");
-				await cont.markNodeRunning({
-					runId: request.runId,
-					activationId: request.activationId,
-					nodeId: request.nodeId,
-					inputsByPort: request.kind === "multi" ? request.inputsByPort : { in: request.input }
-				});
-				let outputs;
-				try {
-					outputs = await this.nodeExecutor.execute(request);
-				} catch (e) {
-					await this.resumeAfterExecutionError(cont, request, this.asError(e));
-					continue;
-				}
-				await this.resumeAfterExecutionResult(cont, request, outputs ?? {});
+			if (q.length === 0) return;
+			const { request } = q.shift();
+			const cont = this.continuation;
+			if (!cont) throw new Error("InlineDrivingScheduler is missing a continuation (setContinuation was not called)");
+			await cont.markNodeRunning({
+				runId: request.runId,
+				activationId: request.activationId,
+				nodeId: request.nodeId,
+				inputsByPort: request.kind === "multi" ? request.inputsByPort : { in: request.input }
+			});
+			let outputs;
+			try {
+				outputs = await this.nodeExecutor.execute(request);
+			} catch (e) {
+				await this.resumeAfterExecutionError(cont, request, this.asError(e));
+				return;
 			}
+			await this.resumeAfterExecutionResult(cont, request, outputs ?? {});
 		} finally {
 			if ((this.queuesByRunId.get(runId)?.length ?? 0) === 0) this.queuesByRunId.delete(runId);
 			this.drainingRuns.delete(runId);
@@ -4648,10 +4791,10 @@ var InlineDrivingScheduler = class {
 	scheduleDrain(runId) {
 		if (this.drainingRuns.has(runId) || this.scheduledRuns.has(runId)) return;
 		this.scheduledRuns.add(runId);
-		setTimeout(() => {
+		setImmediate(() => {
 			this.scheduledRuns.delete(runId);
 			this.drainRun(runId);
-		}, 0);
+		});
 	}
 	async resumeAfterExecutionResult(continuation, request, outputs) {
 		try {
@@ -4901,6 +5044,12 @@ var InMemoryBinaryStorage = class {
 	async delete(storageKey) {
 		this.values.delete(storageKey);
 	}
+	async deleteMany(storageKeys) {
+		for (const key of storageKeys) this.values.delete(key);
+	}
+	async listByPrefix(prefix) {
+		return Array.from(this.values.keys()).filter((key) => key.startsWith(prefix));
+	}
 };
 
 //#endregion
@@ -6129,5 +6278,5 @@ var WorkflowRepositoryWebhookTriggerMatcherFactory = class {
 };
 
 //#endregion
-export { NoOpCostTrackingTelemetryFactory as $, singleton as $t, PersistedWorkflowTokenRegistry as A, AgentConfigInspector as At, DefaultExecutionContextFactory as B, InjectableRuntimeDecoratorComposer as Bt, DefaultDrivingScheduler as C, WorkflowBuilder as Ct, NodeInstanceFactoryFactory as D, WhenBuilder as Dt, StaticCostCatalog as E, ChainCursor as Et, RunnableOutputBehaviorResolver as F, NodeBackedToolConfig as Ft, CodemationTelemetryAttributeNames as G, delay as Gt, nodeRef as H, StackTraceCallSitePathResolver as Ht, NodeOutputNormalizer as I, chatModel as It, NoOpExecutionTelemetryFactory as J, injectable as Jt, AllWorkflowsActiveWorkflowActivationPolicy as K, inject as Kt, ItemExprResolver as L, getPersistedRuntimeTypeMetadata as Lt, NodeExecutorFactory as M, itemExpr as Mt, NodeExecutor as N, resolveItemExprsForExecution as Nt, NodeInstanceFactory as O, AgentConnectionNodeCollector as Ot, InProcessRetryRunnerFactory as P, resolveItemExprsInUnknown as Pt, NoOpTelemetryArtifactReference as Q, registry as Qt, InProcessRetryRunner as R, node as Rt, HintOnlyOffloadPolicy as S, ConnectionInvocationIdFactory as St, RunPolicySnapshotFactory as T, NodeIdSlugifier as Tt, CodemationTelemetryMetricNames as U, PersistedRuntimeTypeNameResolver as Ut, branchRef as V, PersistedRuntimeTypeMetadataStore as Vt, GenAiTelemetryAttributeNames as W, container$1 as Wt, NoOpNodeExecutionTelemetry as X, instancePerContainerCachingFactory as Xt, NoOpExecutionTelemetry as Y, instanceCachingFactory as Yt, NoOpTelemetrySpanScope as Z, predicateAwareClassFactory as Zt, RunTerminalPersistenceCoordinator as _, ConnectionInvocationEventPublisher as _t, InMemoryLiveWorkflowRepository as a, RetryPolicy as at, LocalOnlyScheduler as b, WorkflowExecutableNodeClassifier as bt, EngineFactory as c, isPortsEmission as ct, PollingTriggerRuntime as d, CredentialResolverFactory as dt, CoreTokens as en, NoOpCostTrackingTelemetry as et, PollingTriggerDedupWindow as f, getOriginIndexFromItem as ft, WorkflowPolicyErrorServices as g, NodeEventPublisher as gt, WorkflowStoragePolicyEvaluator as h, UnavailableBinaryStorage as ht, RunIntentService as i, ExpRetryPolicy as it, MissingRuntimeTriggerToken as j, isItemExpr as jt, WorkflowSnapshotCodec as k, ConnectionNodeIdFactory as kt, Engine as l, isUnbrandedPortsEmissionShape as lt, InMemoryBinaryStorage as m, DefaultExecutionBinaryService as mt, WorkflowRepositoryWebhookTriggerMatcher as n, CostTrackingTelemetryMetricNames as nt, EngineWorkflowRunnerServiceFactory as o, NoRetryPolicy as ot, InMemoryRunDataFactory as p, ChildExecutionScopeFactory as pt, RunFinishedAtFactory as q, injectAll as qt, RunIntentServiceFactory as r, CredentialUnboundError as rt, EngineWorkflowRunnerService as s, emitPorts as st, WorkflowRepositoryWebhookTriggerMatcherFactory as t, CostTrackingTelemetryAttributeNames as tt, NoOpPollingTriggerLogger as u, DefaultAsyncSleeper as ut, ENGINE_EXECUTION_LIMITS_DEFAULTS as v, DefaultWorkflowGraphFactory as vt, ConfigDrivenOffloadPolicy as w, WorkflowDefinitionError as wt, InlineDrivingScheduler as x, NodeIterationIdFactory as xt, EngineExecutionLimitsPolicy as y, WorkflowExecutableNodeClassifierFactory as yt, CatalogBackedCostTrackingTelemetryFactory as z, tool as zt };
-//# sourceMappingURL=runtime-BGNbRnqs.js.map
+export { NoOpCostTrackingTelemetryFactory as $, registry as $t, PersistedWorkflowTokenRegistry as A, ConnectionNodeIdFactory as At, DefaultExecutionContextFactory as B, tool as Bt, DefaultDrivingScheduler as C, ConnectionInvocationIdFactory as Ct, NodeInstanceFactoryFactory as D, ChainCursor as Dt, StaticCostCatalog as E, NodeIdSlugifier as Et, RunnableOutputBehaviorResolver as F, resolveItemExprsInUnknown as Ft, CodemationTelemetryAttributeNames as G, container$1 as Gt, nodeRef as H, PersistedRuntimeTypeMetadataStore as Ht, NodeOutputNormalizer as I, NodeBackedToolConfig as It, NoOpExecutionTelemetryFactory as J, injectAll as Jt, AllWorkflowsActiveWorkflowActivationPolicy as K, delay as Kt, ItemExprResolver as L, chatModel as Lt, NodeExecutorFactory as M, isItemExpr as Mt, NodeExecutor as N, itemExpr as Nt, NodeInstanceFactory as O, WhenBuilder as Ot, InProcessRetryRunnerFactory as P, resolveItemExprsForExecution as Pt, NoOpTelemetryArtifactReference as Q, predicateAwareClassFactory as Qt, InProcessRetryRunner as R, getPersistedRuntimeTypeMetadata as Rt, HintOnlyOffloadPolicy as S, NodeIterationIdFactory as St, RunPolicySnapshotFactory as T, WorkflowDefinitionError as Tt, CodemationTelemetryMetricNames as U, StackTraceCallSitePathResolver as Ut, branchRef as V, InjectableRuntimeDecoratorComposer as Vt, GenAiTelemetryAttributeNames as W, PersistedRuntimeTypeNameResolver as Wt, NoOpNodeExecutionTelemetry as X, instanceCachingFactory as Xt, NoOpExecutionTelemetry as Y, injectable as Yt, NoOpTelemetrySpanScope as Z, instancePerContainerCachingFactory as Zt, RunTerminalPersistenceCoordinator as _, NodeEventPublisher as _t, InMemoryLiveWorkflowRepository as a, RetryPolicy as at, LocalOnlyScheduler as b, WorkflowExecutableNodeClassifierFactory as bt, EngineFactory as c, isPortsEmission as ct, PollingTriggerRuntime as d, DefaultAsyncSleeper as dt, singleton as en, NoOpCostTrackingTelemetry as et, PollingTriggerDedupWindow as f, CredentialResolverFactory as ft, WorkflowPolicyErrorServices as g, UnavailableBinaryStorage as gt, WorkflowStoragePolicyEvaluator as h, DefaultExecutionBinaryService as ht, RunIntentService as i, ExpRetryPolicy as it, MissingRuntimeTriggerToken as j, AgentConfigInspector as jt, WorkflowSnapshotCodec as k, AgentConnectionNodeCollector as kt, Engine as l, isUnbrandedPortsEmissionShape as lt, InMemoryBinaryStorage as m, ChildExecutionScopeFactory as mt, WorkflowRepositoryWebhookTriggerMatcher as n, CostTrackingTelemetryMetricNames as nt, EngineWorkflowRunnerServiceFactory as o, NoRetryPolicy as ot, InMemoryRunDataFactory as p, getOriginIndexFromItem as pt, RunFinishedAtFactory as q, inject as qt, RunIntentServiceFactory as r, CredentialUnboundError as rt, EngineWorkflowRunnerService as s, emitPorts as st, WorkflowRepositoryWebhookTriggerMatcherFactory as t, CoreTokens as tn, CostTrackingTelemetryAttributeNames as tt, NoOpPollingTriggerLogger as u, NoOpAgentMcpIntegration as ut, ENGINE_EXECUTION_LIMITS_DEFAULTS as v, ConnectionInvocationEventPublisher as vt, ConfigDrivenOffloadPolicy as w, WorkflowBuilder as wt, InlineDrivingScheduler as x, WorkflowExecutableNodeClassifier as xt, EngineExecutionLimitsPolicy as y, DefaultWorkflowGraphFactory as yt, CatalogBackedCostTrackingTelemetryFactory as z, node as zt };
+//# sourceMappingURL=runtime-Duf3ClPw.js.map