@codemation/core 0.8.0 → 0.10.0

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

@@ -164,6 +164,56 @@ function chatModel(options = {}) {
 	return InjectableRuntimeDecoratorComposer.compose("chatModel", options, require("url").pathToFileURL(__filename).href);
 }
 
+//#endregion
+//#region src/ai/NodeBackedToolConfig.ts
+var NodeBackedToolConfig = class {
+	type;
+	toolKind = "nodeBacked";
+	description;
+	presentation;
+	inputSchemaValue;
+	outputSchemaValue;
+	mapInputValue;
+	mapOutputValue;
+	constructor(name, node$1, options) {
+		this.name = name;
+		this.node = node$1;
+		this.type = node$1.type;
+		this.description = options.description;
+		this.presentation = options.presentation;
+		this.inputSchemaValue = options.inputSchema;
+		this.outputSchemaValue = options.outputSchema;
+		this.mapInputValue = options.mapInput;
+		this.mapOutputValue = options.mapOutput;
+	}
+	getCredentialRequirements() {
+		return this.node.getCredentialRequirements?.() ?? [];
+	}
+	getInputSchema() {
+		return this.inputSchemaValue;
+	}
+	getOutputSchema() {
+		return this.outputSchemaValue;
+	}
+	toNodeItem(args) {
+		const mapped = this.mapInputValue?.(args) ?? args.input;
+		if (this.isItem(mapped)) return mapped;
+		return { json: mapped };
+	}
+	toToolOutput(args) {
+		const raw = this.mapOutputValue?.(args) ?? this.readDefaultToolOutput(args.outputs);
+		return this.outputSchemaValue.parse(raw);
+	}
+	readDefaultToolOutput(outputs) {
+		const firstMainItem = outputs.main?.[0];
+		if (!firstMainItem) throw new Error(`Node-backed tool "${this.name}" did not produce a main output item.`);
+		return firstMainItem.json;
+	}
+	isItem(value) {
+		return typeof value === "object" && value !== null && "json" in value;
+	}
+};
+
 //#endregion
 //#region src/contracts/itemExpr.ts
 const ITEM_EXPR_BRAND = Symbol.for("codemation.itemExpr");
@@ -232,6 +282,27 @@ async function resolveItemExprsForExecution(config, nodeCtx, item, itemIndex, it
 	return await resolveItemExprsInUnknown(config, exprArgs);
 }
 
+//#endregion
+//#region src/ai/AgentConfigInspectorFactory.ts
+var AgentConfigInspector = class {
+	static isAgentNodeConfig(config) {
+		if (!config) return false;
+		const candidate = config;
+		return !!candidate.chatModel && this.hasCompatibleMessageConfiguration(candidate);
+	}
+	static hasCompatibleMessageConfiguration(candidate) {
+		const messages = candidate.messages;
+		if (messages === void 0 || messages === null) return false;
+		if (Array.isArray(messages)) return messages.length > 0;
+		if (typeof messages === "object") {
+			if (isItemExpr(messages)) return true;
+			const o = messages;
+			return Array.isArray(o.prompt) && o.prompt.length > 0 || typeof o.buildMessages === "function";
+		}
+		return false;
+	}
+};
+
 //#endregion
 //#region src/workflow/definition/ConnectionNodeIdFactory.ts
 /**
@@ -282,6 +353,369 @@ var ConnectionNodeIdFactory = class {
 	}
 };
 
+//#endregion
+//#region src/ai/AgentConnectionNodeCollector.ts
+const AgentConnectionNodeCollector = new class {
+	collect(parentNodeId, agentConfig) {
+		const collected = [];
+		this.collectInto(parentNodeId, agentConfig, collected);
+		return collected;
+	}
+	collectInto(parentNodeId, agentConfig, collected) {
+		collected.push({
+			nodeId: ConnectionNodeIdFactory.languageModelConnectionNodeId(parentNodeId),
+			parentNodeId,
+			connectionName: "llm",
+			role: "languageModel",
+			name: agentConfig.chatModel.presentation?.label ?? agentConfig.chatModel.name,
+			typeName: agentConfig.chatModel.name,
+			icon: agentConfig.chatModel.presentation?.icon,
+			credentialSource: agentConfig.chatModel
+		});
+		for (const tool$1 of agentConfig.tools ?? []) {
+			const toolNodeId = ConnectionNodeIdFactory.toolConnectionNodeId(parentNodeId, tool$1.name);
+			const isNestedAgent = this.isNodeBackedAgentTool(tool$1);
+			collected.push({
+				nodeId: toolNodeId,
+				parentNodeId,
+				connectionName: "tools",
+				role: isNestedAgent ? "nestedAgent" : "tool",
+				name: tool$1.presentation?.label ?? tool$1.name,
+				typeName: tool$1.name,
+				icon: tool$1.presentation?.icon,
+				credentialSource: tool$1
+			});
+			this.collectNestedAgentTools(toolNodeId, tool$1, collected);
+		}
+	}
+	collectNestedAgentTools(toolNodeId, tool$1, collected) {
+		if (!this.isNodeBackedAgentTool(tool$1)) return;
+		const innerAgent = tool$1 instanceof NodeBackedToolConfig ? tool$1.node : tool$1.node;
+		this.collectInto(toolNodeId, innerAgent, collected);
+	}
+	/**
+	* After JSON round-trip (persisted snapshots), tools are plain objects — `instanceof NodeBackedToolConfig` fails.
+	* Detect node-backed tools structurally via {@link NodeBackedToolConfig#toolKind}.
+	*/
+	isNodeBackedAgentTool(tool$1) {
+		if (tool$1 instanceof NodeBackedToolConfig) return AgentConfigInspector.isAgentNodeConfig(tool$1.node);
+		if (!tool$1 || typeof tool$1 !== "object") return false;
+		const t = tool$1;
+		if (t.toolKind !== "nodeBacked") return false;
+		return AgentConfigInspector.isAgentNodeConfig(t.node);
+	}
+}();
+
+//#endregion
+//#region src/workflow/dsl/WhenBuilder.ts
+var WhenBuilder = class WhenBuilder {
+	constructor(wf, from, branchPort) {
+		this.wf = wf;
+		this.from = from;
+		this.branchPort = branchPort;
+	}
+	addBranch(steps) {
+		const created = [];
+		let prev = null;
+		for (const cfg of steps) {
+			const ref = this.wf.add(cfg);
+			created.push(ref);
+			if (!prev) this.wf.connect(this.from, ref, this.branchPort, "in");
+			else this.wf.connect(prev, ref, "main", "in");
+			prev = ref;
+		}
+		for (const cfg of steps) {
+			const maybe = cfg;
+			if (!Array.isArray(maybe.upstreamRefs) || maybe.upstreamRefs.length === 0) continue;
+			maybe.upstreamRefs = maybe.upstreamRefs.map((r) => {
+				if (typeof r !== "string") return r;
+				const nodeId = created[parseInt(r.slice(1), 10)]?.id;
+				return nodeId ? { nodeId } : { nodeId: r };
+			});
+		}
+		return this;
+	}
+	when = (branch, steps, ...more) => {
+		const list = Array.isArray(steps) ? steps : [steps, ...more];
+		const port = branch ? "true" : "false";
+		const b = new WhenBuilder(this.wf, this.from, port);
+		b.addBranch(list);
+		return b;
+	};
+	build() {
+		return this.wf.build();
+	}
+};
+
+//#endregion
+//#region src/workflow/dsl/ChainCursorResolver.ts
+var ChainCursor = class ChainCursor {
+	constructor(wf, endpoints) {
+		this.wf = wf;
+		this.endpoints = endpoints;
+	}
+	then(config) {
+		const next = this.wf.add(config);
+		const inputPortHint = this.resolveSharedInputPortHint();
+		for (const e of this.endpoints) this.wf.connect(e.node, next, e.output);
+		return new ChainCursor(this.wf, [{
+			node: next,
+			output: "main",
+			...inputPortHint ? { inputPortHint } : {}
+		}]);
+	}
+	thenIntoInputHints(config) {
+		const next = this.wf.add(config);
+		for (const e of this.endpoints) this.wf.connect(e.node, next, e.output, e.inputPortHint ?? "in");
+		return new ChainCursor(this.wf, [{
+			node: next,
+			output: "main"
+		}]);
+	}
+	when = ((arg1, steps, ...more) => {
+		if (this.endpoints.length !== 1) throw new Error("ChainCursor.when(...) is only supported from a single cursor endpoint");
+		const cursor = this.endpoints[0].node;
+		if (typeof arg1 === "boolean") {
+			const list = Array.isArray(steps) ? steps : steps ? [steps, ...more] : more;
+			const port = arg1 ? "true" : "false";
+			const b = new WhenBuilder(this.wf, cursor, port);
+			b.addBranch(list);
+			return b;
+		}
+		const branches = arg1;
+		const wfAny = this.wf;
+		const buildBranch = (port, branchSteps) => {
+			const list = branchSteps ?? [];
+			let prev = null;
+			for (const cfg of list) {
+				const ref = wfAny.add(cfg);
+				if (!prev) wfAny.connect(cursor, ref, port, "in");
+				else wfAny.connect(prev, ref, "main", "in");
+				prev = ref;
+			}
+			if (!prev) return {
+				end: cursor,
+				endOutput: port,
+				inputPortHint: port
+			};
+			return {
+				end: prev,
+				endOutput: "main",
+				inputPortHint: port
+			};
+		};
+		const t = buildBranch("true", branches.true);
+		const f = buildBranch("false", branches.false);
+		return new ChainCursor(this.wf, [{
+			node: t.end,
+			output: t.endOutput,
+			inputPortHint: t.inputPortHint
+		}, {
+			node: f.end,
+			output: f.endOutput,
+			inputPortHint: f.inputPortHint
+		}]);
+	});
+	route(branches) {
+		if (this.endpoints.length !== 1) throw new Error("ChainCursor.route(...) is only supported from a single cursor endpoint");
+		const cursor = this.endpoints[0];
+		const nextEndpoints = [];
+		for (const [port, branchFactory] of Object.entries(branches)) {
+			if (!branchFactory) continue;
+			const builtBranch = branchFactory(new ChainCursor(this.wf, [{
+				node: cursor.node,
+				output: port,
+				inputPortHint: port
+			}]));
+			if (!builtBranch) continue;
+			nextEndpoints.push(...builtBranch.endpoints);
+		}
+		return new ChainCursor(this.wf, nextEndpoints);
+	}
+	build() {
+		return this.wf.build();
+	}
+	resolveSharedInputPortHint() {
+		const first = this.endpoints[0]?.inputPortHint;
+		if (!first) return;
+		return this.endpoints.every((endpoint) => endpoint.inputPortHint === first) ? first : void 0;
+	}
+};
+
+//#endregion
+//#region src/workflow/dsl/NodeIdSlugifier.ts
+/**
+* Converts a human-readable node label into a stable, URL-safe identifier segment.
+*
+* Rules:
+* - Lowercase the entire string.
+* - Replace every run of characters outside `[a-z0-9]` with a single `-`.
+* - Strip any leading or trailing `-` characters.
+* - Return `""` for blank/empty input.
+*/
+const NodeIdSlugifier = { slugify(label) {
+	if (!label) return "";
+	return label.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+} };
+
+//#endregion
+//#region src/workflow/dsl/WorkflowDefinitionError.ts
+/**
+* Thrown by {@link WorkflowBuilder.build} when the workflow definition is structurally invalid.
+*
+* Common causes:
+* - A node has an empty effective id (label is blank and no explicit `id` was given).
+* - Two or more nodes share the same effective id (label slugs collide or explicit ids clash).
+*
+* Fix: provide an explicit `id:` on the offending node configs.
+*/
+var WorkflowDefinitionError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "WorkflowDefinitionError";
+	}
+};
+
+//#endregion
+//#region src/workflow/dsl/WorkflowBuilder.ts
+var WorkflowBuilder = class {
+	nodes = [];
+	edges = [];
+	constructor(meta, options) {
+		this.meta = meta;
+		this.options = options;
+	}
+	add(config) {
+		const id = config.id ?? NodeIdSlugifier.slugify(config.name ?? "");
+		this.nodes.push({
+			id,
+			kind: config.kind,
+			type: config.type,
+			name: config.name,
+			config
+		});
+		return {
+			id,
+			kind: config.kind,
+			name: config.name
+		};
+	}
+	connect(from, to, fromOutput = "main", toInput = "in") {
+		this.edges.push({
+			from: {
+				nodeId: from.id,
+				output: fromOutput
+			},
+			to: {
+				nodeId: to.id,
+				input: toInput
+			}
+		});
+	}
+	trigger(config) {
+		const ref = this.add(config);
+		return new ChainCursor(this, [{
+			node: ref,
+			output: "main"
+		}]);
+	}
+	start(config) {
+		const ref = this.add(config);
+		return new ChainCursor(this, [{
+			node: ref,
+			output: "main"
+		}]);
+	}
+	build() {
+		this.validateNodeIds();
+		return {
+			...this.meta,
+			nodes: this.nodes,
+			edges: this.edges
+		};
+	}
+	validateNodeIds() {
+		const entries = [];
+		for (const node$1 of this.nodes) {
+			const tokenName = typeof node$1.type === "function" ? node$1.type.name : String(node$1.type);
+			entries.push({
+				nodeId: node$1.id,
+				tokenName,
+				label: node$1.name ?? ""
+			});
+			if (AgentConfigInspector.isAgentNodeConfig(node$1.config)) for (const child of AgentConnectionNodeCollector.collect(node$1.id, node$1.config)) entries.push({
+				nodeId: child.nodeId,
+				tokenName: child.typeName,
+				label: child.name
+			});
+		}
+		const emptyIds = [];
+		const seenIds = /* @__PURE__ */ new Map();
+		const duplicateIds = [];
+		for (const entry of entries) {
+			if (!entry.nodeId) {
+				emptyIds.push(entry);
+				continue;
+			}
+			const existing = seenIds.get(entry.nodeId);
+			if (existing) {
+				if (!duplicateIds.includes(existing)) duplicateIds.push(existing);
+				duplicateIds.push(entry);
+			} else seenIds.set(entry.nodeId, entry);
+		}
+		if (emptyIds.length === 0 && duplicateIds.length === 0) return;
+		const lines = ["WorkflowBuilder.build() found invalid node ids:"];
+		if (emptyIds.length > 0) {
+			lines.push("  Empty ids (label is blank and no explicit id was given):");
+			for (const e of emptyIds) lines.push(`    - type "${e.tokenName}" label "${e.label}"`);
+		}
+		if (duplicateIds.length > 0) {
+			lines.push("  Duplicate ids:");
+			for (const e of duplicateIds) lines.push(`    - id "${e.nodeId}" type "${e.tokenName}" label "${e.label}"`);
+		}
+		lines.push("  Fix: set an explicit `id:` on each offending node config.");
+		throw new WorkflowDefinitionError(lines.join("\n"));
+	}
+};
+
+//#endregion
+//#region src/workflow/definition/ConnectionInvocationIdFactory.ts
+/**
+* Unique ids for persisted connection invocation history rows (LLM/tool calls under an owning node).
+*/
+var ConnectionInvocationIdFactory = class {
+	static create() {
+		return `cinv_${(0, node_crypto.randomUUID)()}`;
+	}
+	/** Deterministic id for tests when a stable sequence is needed. */
+	static createForTest(runId, connectionNodeId, sequence) {
+		return `cinv_${runId}_${connectionNodeId}_${sequence}`;
+	}
+};
+
+//#endregion
+//#region src/workflow/definition/NodeIterationIdFactory.ts
+/**
+* Unique ids for one per-item iteration of a runnable node's execute loop.
+*
+* 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.
+*/
+var NodeIterationIdFactory = class {
+	static create() {
+		return `iter_${(0, node_crypto.randomUUID)()}`;
+	}
+	/** Deterministic id for tests when a stable sequence is needed. */
+	static createForTest(seed, sequence) {
+		return `iter_${seed}_${sequence}`;
+	}
+	/** Deterministic id derived from a connection node id (for sub-agent / tool-call scopes). */
+	static createForConnection(connectionNodeId, sequence) {
+		return `iter_${connectionNodeId}_${sequence}`;
+	}
+};
+
 //#endregion
 //#region src/workflow/definition/WorkflowExecutableNodeClassifier.ts
 /**
@@ -342,6 +776,69 @@ var WorkflowExecutableNodeClassifierFactory = class {
 	}
 };
 
+//#endregion
+//#region src/workflow/graph/ExecutableGraph.ts
+var ExecutableGraph = class {
+	outgoingByNodeAndPort = /* @__PURE__ */ new Map();
+	constructor(def) {
+		for (const e of def.edges) {
+			const byPort = this.outgoingByNodeAndPort.get(e.from.nodeId) ?? /* @__PURE__ */ new Map();
+			const next = byPort.get(e.from.output) ?? [];
+			next.push({
+				nodeId: e.to.nodeId,
+				input: e.to.input
+			});
+			byPort.set(e.from.output, next);
+			this.outgoingByNodeAndPort.set(e.from.nodeId, byPort);
+		}
+	}
+	next(nodeId, output) {
+		return this.outgoingByNodeAndPort.get(nodeId)?.get(output) ?? [];
+	}
+};
+
+//#endregion
+//#region src/workflow/graph/DefaultWorkflowGraphFactory.ts
+var DefaultWorkflowGraphFactory = class {
+	create(def) {
+		return new ExecutableGraph(def);
+	}
+};
+
+//#endregion
+//#region src/events/ConnectionInvocationEventPublisher.ts
+/**
+* Publishes per-invocation lifecycle records onto the run {@link RunEventBus}.
+*
+* Surgical, per-invocation events let the UI update the right-side inspector
+* timeline as each LLM round / tool call transitions through `running` → `completed`
+* (or `failed`) without depending on a coarse `runSaved` poll.
+*/
+var ConnectionInvocationEventPublisher = class {
+	constructor(eventBus, parent) {
+		this.eventBus = eventBus;
+		this.parent = parent;
+	}
+	async publish(record) {
+		if (!this.eventBus) return;
+		const kind = this.kindFor(record);
+		if (!kind) return;
+		await this.eventBus.publish({
+			kind,
+			runId: record.runId,
+			workflowId: record.workflowId,
+			parent: this.parent,
+			at: record.updatedAt,
+			record
+		});
+	}
+	kindFor(record) {
+		if (record.status === "running" || record.status === "queued") return "connectionInvocationStarted";
+		if (record.status === "completed") return "connectionInvocationCompleted";
+		if (record.status === "failed") return "connectionInvocationFailed";
+	}
+};
+
 //#endregion
 //#region src/events/NodeEventPublisher.ts
 /** Publishes node lifecycle snapshots onto the run {@link RunEventBus}. */
@@ -660,6 +1157,48 @@ var ActivationEnqueueService = class {
 	}
 };
 
+//#endregion
+//#region src/execution/ChildExecutionScopeFactory.ts
+/**
+* Builds a re-rooted child execution context for sub-agent (and other deeply-nested) invocations.
+*
+* At the orchestrator's `agent.tool.call` boundary the inner runtime needs a ctx whose:
+* - `nodeId` is the tool's connection node id (so inner LLM/tool connection ids derive correctly),
+* - `activationId` is fresh (so its connection-invocation rows are uniquely identifiable),
+* - `telemetry` parents children under the tool-call span (not the orchestrator's node span),
+* - `binary` is scoped to the new (nodeId, activationId),
+* - `parentInvocationId` points back to the tool-call invocation for downstream lineage.
+*
+* Registered via factory in {@link EngineRuntimeRegistrar} so constructors stay free of parameter
+* decorators (Next/SWC and coverage tooling cannot parse them on in-repo sources).
+*/
+var ChildExecutionScopeFactory = class {
+	constructor(activationIdFactory) {
+		this.activationIdFactory = activationIdFactory;
+	}
+	forSubAgent(args) {
+		const childActivationId = this.activationIdFactory.makeActivationId();
+		const childTelemetry = args.parentSpan.asNodeTelemetry({
+			nodeId: args.childNodeId,
+			activationId: childActivationId
+		});
+		const childBinary = args.parentCtx.binary.forNode({
+			nodeId: args.childNodeId,
+			activationId: childActivationId
+		});
+		return {
+			...args.parentCtx,
+			nodeId: args.childNodeId,
+			activationId: childActivationId,
+			config: args.childConfig,
+			telemetry: childTelemetry,
+			binary: childBinary,
+			parentInvocationId: args.parentInvocationId,
+			iterationId: void 0
+		};
+	}
+};
+
 //#endregion
 //#region src/contracts/itemMeta.ts
 /**
@@ -800,6 +1339,20 @@ var NodeActivationRequestInputPreparer = class {
 	}
 };
 
+//#endregion
+//#region src/execution/NodeInstantiationError.ts
+var NodeInstantiationError = class extends Error {
+	name = "NodeInstantiationError";
+	originalError;
+	constructor(nodeId, nodeType, originalError) {
+		super(`Failed to instantiate node "${nodeId}" (type ${nodeType}): ${originalError.message}`);
+		this.nodeId = nodeId;
+		this.nodeType = nodeType;
+		this.originalError = originalError;
+		this.stack = originalError.stack;
+	}
+};
+
 //#endregion
 //#region src/execution/CredentialResolverFactory.ts
 var CredentialResolverFactory = class {
@@ -960,31 +1513,54 @@ var NoOpTelemetryArtifactReference = class {
 
 //#endregion
 //#region src/contracts/NoOpTelemetrySpanScope.ts
+/**
+* Standalone no-op {@link NodeExecutionTelemetry} value used as the return for `asNodeTelemetry`.
+*
+* Defined here (instead of in `NoOpNodeExecutionTelemetry.ts`) so that {@link NoOpTelemetrySpanScope}
+* can return it without importing the other module — both no-ops share this leaf.
+*/
+const noOpNodeExecutionTelemetry = {
+	traceId: "00000000000000000000000000000000",
+	spanId: "0000000000000000",
+	addSpanEvent(_) {},
+	recordMetric(_) {},
+	attachArtifact(_) {
+		return NoOpTelemetryArtifactReference.value;
+	},
+	end(_ = {}) {},
+	asNodeTelemetry(_) {
+		return noOpNodeExecutionTelemetry;
+	},
+	forNode(_) {
+		return noOpNodeExecutionTelemetry;
+	},
+	startChildSpan(_) {
+		return noOpTelemetrySpanScope;
+	}
+};
+const noOpTelemetrySpanScope = {
+	traceId: "00000000000000000000000000000000",
+	spanId: "0000000000000000",
+	addSpanEvent(_) {},
+	recordMetric(_) {},
+	attachArtifact(_) {
+		return NoOpTelemetryArtifactReference.value;
+	},
+	end(_ = {}) {},
+	asNodeTelemetry(_) {
+		return noOpNodeExecutionTelemetry;
+	}
+};
 var NoOpTelemetrySpanScope = class {
-	static value = {
-		traceId: "00000000000000000000000000000000",
-		spanId: "0000000000000000",
-		addSpanEvent(_) {},
-		recordMetric(_) {},
-		attachArtifact(_) {
-			return NoOpTelemetryArtifactReference.value;
-		},
-		end(_ = {}) {}
-	};
+	static value = noOpTelemetrySpanScope;
+	/** Internal: the shared no-op {@link NodeExecutionTelemetry} that {@link NoOpNodeExecutionTelemetry} re-exposes. */
+	static nodeExecutionTelemetryValue = noOpNodeExecutionTelemetry;
 };
 
 //#endregion
 //#region src/contracts/NoOpNodeExecutionTelemetry.ts
-var NoOpNodeExecutionTelemetry = class NoOpNodeExecutionTelemetry {
-	static value = {
-		...NoOpTelemetrySpanScope.value,
-		forNode(_) {
-			return NoOpNodeExecutionTelemetry.value;
-		},
-		startChildSpan(_) {
-			return NoOpTelemetrySpanScope.value;
-		}
-	};
+var NoOpNodeExecutionTelemetry = class {
+	static value = NoOpTelemetrySpanScope.nodeExecutionTelemetryValue;
 };
 
 //#endregion
@@ -1012,6 +1588,28 @@ var NoOpExecutionTelemetryFactory = 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/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/contracts/CodemationTelemetryAttributeNames.ts
 var CodemationTelemetryAttributeNames = class {
@@ -1025,6 +1623,12 @@ var CodemationTelemetryAttributeNames = class {
 	static connectionInvocationId = "codemation.connection.invocation_id";
 	static toolName = "codemation.tool.name";
 	static traceParentRunId = "codemation.parent.run.id";
+	/** Per-item iteration that emitted this span/metric. Set on spans recorded inside a runnable per-item loop. */
+	static iterationId = "codemation.iteration.id";
+	/** Item index (0-based) of the iteration. */
+	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";
 };
 
 //#endregion
@@ -1050,19 +1654,6 @@ var CodemationTelemetryMetricNames = class {
 	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) {
@@ -1070,15 +1661,6 @@ function nodeRef(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 {
@@ -1118,6 +1700,13 @@ var ExecutionTelemetryCostTrackingDecoratorFactory = class {
 					telemetry: nodeTelemetry,
 					costTracking: args.costTracking.forScope(nodeTelemetry)
 				});
+			},
+			asNodeTelemetry: (rescope) => {
+				const nodeTelemetry = args.telemetry.asNodeTelemetry(rescope);
+				return this.decorateNodeExecutionTelemetry({
+					telemetry: nodeTelemetry,
+					costTracking: args.costTracking.forScope(nodeTelemetry)
+				});
 			}
 		};
 	}
@@ -1129,7 +1718,14 @@ var ExecutionTelemetryCostTrackingDecoratorFactory = class {
 			addSpanEvent: (event) => args.scope.addSpanEvent(event),
 			recordMetric: (metric) => args.scope.recordMetric(metric),
 			attachArtifact: (artifact) => args.scope.attachArtifact(artifact),
-			end: (endArgs) => args.scope.end(endArgs)
+			end: (endArgs) => args.scope.end(endArgs),
+			asNodeTelemetry: (rescope) => {
+				const nodeTelemetry = args.scope.asNodeTelemetry(rescope);
+				return this.decorateNodeExecutionTelemetry({
+					telemetry: nodeTelemetry,
+					costTracking: args.costTracking.forScope(nodeTelemetry)
+				});
+			}
 		};
 	}
 };
@@ -1138,11 +1734,12 @@ var ExecutionTelemetryCostTrackingDecoratorFactory = class {
 //#region src/execution/DefaultExecutionContextFactory.ts
 var DefaultExecutionContextFactory = class {
 	telemetryDecoratorFactory = new ExecutionTelemetryCostTrackingDecoratorFactory();
-	constructor(binaryStorage = new UnavailableBinaryStorage(), telemetryFactory = new NoOpExecutionTelemetryFactory(), costTrackingFactory = new NoOpCostTrackingTelemetryFactory(), currentDate = () => /* @__PURE__ */ new Date()) {
+	constructor(binaryStorage = new UnavailableBinaryStorage(), telemetryFactory = new NoOpExecutionTelemetryFactory(), costTrackingFactory = new NoOpCostTrackingTelemetryFactory(), currentDate = () => /* @__PURE__ */ new Date(), collections) {
 		this.binaryStorage = binaryStorage;
 		this.telemetryFactory = telemetryFactory;
 		this.costTrackingFactory = costTrackingFactory;
 		this.currentDate = currentDate;
+		this.collections = collections;
 	}
 	create(args) {
 		const baseTelemetry = args.telemetry ?? this.telemetryFactory.create({
@@ -1167,7 +1764,9 @@ var DefaultExecutionContextFactory = class {
 			nodeState: args.nodeState,
 			telemetry,
 			binary: new DefaultExecutionBinaryService(this.binaryStorage, args.workflowId, args.runId, this.currentDate),
-			getCredential: args.getCredential
+			getCredential: args.getCredential,
+			testContext: args.testContext,
+			collections: this.collections
 		};
 	}
 };
@@ -1600,13 +2199,17 @@ var NodeExecutor = class {
 			const parsed = inputSchema.parse(item.json);
 			const runnableCtx = request.ctx;
 			const resolvedCtx = await this.itemExprResolver.resolveConfigForItem(runnableCtx, item, i, inputBatch);
-			const ctx = this.pickExecutionContext(runnableCtx, resolvedCtx);
+			const iterationCtx = {
+				...this.pickExecutionContext(runnableCtx, resolvedCtx),
+				iterationId: NodeIterationIdFactory.create(),
+				itemIndex: i
+			};
 			const args = {
 				input: parsed,
 				item,
 				itemIndex: i,
 				items: inputBatch,
-				ctx
+				ctx: iterationCtx
 			};
 			const raw = await Promise.resolve(node$1.execute(args));
 			const normalized = this.outputNormalizer.normalizeExecuteResult({
@@ -2000,7 +2603,12 @@ var NodeInstanceFactory = class {
 	}
 	createNodes(workflow) {
 		const nodeInstances = /* @__PURE__ */ new Map();
-		for (const definition of workflow.nodes) nodeInstances.set(definition.id, this.createNode(definition));
+		for (const definition of workflow.nodes) try {
+			nodeInstances.set(definition.id, this.createNode(definition));
+		} catch (err) {
+			if (err instanceof NodeInstantiationError) throw err;
+			throw new NodeInstantiationError(definition.id, typeof definition.type === "function" ? definition.type.name : String(definition.type), err instanceof Error ? err : new Error(String(err)));
+		}
 		return nodeInstances;
 	}
 	createNode(definition) {
@@ -2025,12 +2633,13 @@ var NodeInstanceFactoryFactory = class {
 //#region src/execution/NodeRunStateWriter.ts
 var NodeRunStateWriter = class {
 	chain = Promise.resolve();
-	constructor(workflowExecutionRepository, runId, workflowId, parent, publishNodeEvent) {
+	constructor(workflowExecutionRepository, runId, workflowId, parent, publishNodeEvent, publishConnectionInvocationEvent) {
 		this.workflowExecutionRepository = workflowExecutionRepository;
 		this.runId = runId;
 		this.workflowId = workflowId;
 		this.parent = parent;
 		this.publishNodeEvent = publishNodeEvent;
+		this.publishConnectionInvocationEvent = publishConnectionInvocationEvent;
 	}
 	markQueued(args) {
 		return this.enqueue(async () => {
@@ -2127,12 +2736,16 @@ var NodeRunStateWriter = class {
 				queuedAt: args.queuedAt,
 				startedAt: args.startedAt,
 				finishedAt: args.finishedAt,
-				updatedAt
+				updatedAt,
+				iterationId: args.iterationId,
+				itemIndex: args.itemIndex,
+				parentInvocationId: args.parentInvocationId
 			};
 			await this.workflowExecutionRepository.save({
 				...state,
 				connectionInvocations: [...state.connectionInvocations ?? [], record]
 			});
+			if (this.publishConnectionInvocationEvent) await this.publishConnectionInvocationEvent(record);
 		});
 	}
 	enqueue(work) {
@@ -2159,13 +2772,17 @@ var NodeRunStateWriter = class {
 //#endregion
 //#region src/execution/NodeRunStateWriterFactory.ts
 var NodeRunStateWriterFactory = class {
-	constructor(workflowExecutionRepository, nodeEventPublisher) {
+	constructor(workflowExecutionRepository, nodeEventPublisher, eventBus) {
 		this.workflowExecutionRepository = workflowExecutionRepository;
 		this.nodeEventPublisher = nodeEventPublisher;
+		this.eventBus = eventBus;
 	}
 	create(runId, workflowId, parent) {
+		const connectionInvocationEventPublisher = new ConnectionInvocationEventPublisher(this.eventBus, parent);
 		return new NodeRunStateWriter(this.workflowExecutionRepository, runId, workflowId, parent, async (kind, snapshot) => {
 			await this.nodeEventPublisher.publish(kind, snapshot);
+		}, async (record) => {
+			await connectionInvocationEventPublisher.publish(record);
 		});
 	}
 };
@@ -2290,7 +2907,8 @@ var WorkflowRunExecutionContextFactory = class {
 			engineMaxSubworkflowDepth: args.engineMaxSubworkflowDepth,
 			data: args.data,
 			nodeState: args.nodeState,
-			getCredential: this.credentialResolverFactory.create(args.workflowId, args.nodeId)
+			getCredential: this.credentialResolverFactory.create(args.workflowId, args.nodeId),
+			testContext: args.testContext
 		});
 	}
 };
@@ -2457,7 +3075,8 @@ var RunContinuationService = class {
 			engineMaxNodeActivations: limits.engineMaxNodeActivations,
 			engineMaxSubworkflowDepth: limits.engineMaxSubworkflowDepth,
 			data,
-			nodeState: this.nodeStatePublisherFactory.create(state.runId, state.workflowId, state.parent)
+			nodeState: this.nodeStatePublisherFactory.create(state.runId, state.workflowId, state.parent),
+			testContext: state.executionOptions?.testContext
 		});
 		data.setOutputs(args.nodeId, args.outputs);
 		const completedAt = (/* @__PURE__ */ new Date()).toISOString();
@@ -2978,7 +3597,8 @@ var RunContinuationService = class {
 			engineMaxNodeActivations: webhookLimits.engineMaxNodeActivations,
 			engineMaxSubworkflowDepth: webhookLimits.engineMaxSubworkflowDepth,
 			data,
-			nodeState: this.nodeStatePublisherFactory.create(args.state.runId, args.state.workflowId, args.state.parent)
+			nodeState: this.nodeStatePublisherFactory.create(args.state.runId, args.state.workflowId, args.state.parent),
+			testContext: args.state.executionOptions?.testContext
 		});
 		const request = this.nodeActivationRequestComposer.createFromPlannedActivation({
 			next,
@@ -3069,7 +3689,8 @@ var RunContinuationService = class {
 			engineMaxNodeActivations: limits.engineMaxNodeActivations,
 			engineMaxSubworkflowDepth: limits.engineMaxSubworkflowDepth,
 			data,
-			nodeState: this.nodeStatePublisherFactory.create(state.runId, state.workflowId, state.parent)
+			nodeState: this.nodeStatePublisherFactory.create(state.runId, state.workflowId, state.parent),
+			testContext: state.executionOptions?.testContext
 		});
 		const activationId = pendingExecution.activationId;
 		return {
@@ -3461,7 +4082,7 @@ var RunPolicySnapshotFactory = class {
 //#endregion
 //#region src/orchestration/RunStartService.ts
 var RunStartService = class {
-	constructor(runIdFactory, workflowExecutionRepository, runDataFactory, workflowSnapshotFactory, planningFactory, nodeStatePublisherFactory, runExecutionContextFactory, nodeActivationRequestComposer, activationEnqueueService, semantics, waiters, workflowPolicyRuntimeDefaults, executionLimitsPolicy) {
+	constructor(runIdFactory, workflowExecutionRepository, runDataFactory, workflowSnapshotFactory, planningFactory, nodeStatePublisherFactory, runExecutionContextFactory, nodeActivationRequestComposer, activationEnqueueService, semantics, waiters, workflowPolicyRuntimeDefaults, executionLimitsPolicy, nodeEventPublisher, persistedRunStateTerminalBuilder) {
 		this.runIdFactory = runIdFactory;
 		this.workflowExecutionRepository = workflowExecutionRepository;
 		this.runDataFactory = runDataFactory;
@@ -3475,6 +4096,8 @@ var RunStartService = class {
 		this.waiters = waiters;
 		this.workflowPolicyRuntimeDefaults = workflowPolicyRuntimeDefaults;
 		this.executionLimitsPolicy = executionLimitsPolicy;
+		this.nodeEventPublisher = nodeEventPublisher;
+		this.persistedRunStateTerminalBuilder = persistedRunStateTerminalBuilder;
 	}
 	async runWorkflow(workflow, startAt, items, parent, executionOptions, persistedStateOverrides) {
 		const runId = this.runIdFactory.makeRunId();
@@ -3505,9 +4128,28 @@ var RunStartService = class {
 			engineMaxNodeActivations: mergedExecutionOptions.maxNodeActivations,
 			engineMaxSubworkflowDepth: mergedExecutionOptions.maxSubworkflowDepth,
 			data,
-			nodeState: this.nodeStatePublisherFactory.create(runId, workflow.id, parent)
+			nodeState: this.nodeStatePublisherFactory.create(runId, workflow.id, parent),
+			testContext: mergedExecutionOptions.testContext
 		});
-		const { topology, planner } = this.planningFactory.create(workflow);
+		let planning;
+		try {
+			planning = this.planningFactory.create(workflow);
+		} catch (err) {
+			if (err instanceof NodeInstantiationError) return await this.failRunDuringPlanning({
+				runId,
+				workflowId: workflow.id,
+				startedAt,
+				parent,
+				executionOptions: mergedExecutionOptions,
+				control: void 0,
+				workflowSnapshot,
+				mutableState,
+				policySnapshot,
+				err
+			});
+			throw err;
+		}
+		const { topology, planner } = planning;
 		const startDefinition = topology.defsById.get(startAt);
 		if (!startDefinition) throw new Error(`Unknown start nodeId: ${startAt}`);
 		const initialNodeSnapshotsByNodeId = {};
@@ -3586,7 +4228,25 @@ var RunStartService = class {
 			policySnapshot,
 			engineCounters: { completedNodeActivations: 0 }
 		});
-		const { topology, planner } = this.planningFactory.create(request.workflow);
+		let planningFromState;
+		try {
+			planningFromState = this.planningFactory.create(request.workflow);
+		} catch (err) {
+			if (err instanceof NodeInstantiationError) return await this.failRunDuringPlanning({
+				runId,
+				workflowId: request.workflow.id,
+				startedAt,
+				parent: request.parent,
+				executionOptions: mergedExecutionOptions,
+				control,
+				workflowSnapshot,
+				mutableState,
+				policySnapshot,
+				err
+			});
+			throw err;
+		}
+		const { topology, planner } = planningFromState;
 		const plan = CurrentStateFrontierPlanner.createFromTopology(topology).plan({
 			currentState: this.createRunCurrentState(request.currentState, mutableState),
 			stopCondition: control.stopCondition,
@@ -3604,7 +4264,8 @@ var RunStartService = class {
 			engineMaxNodeActivations: mergedExecutionOptions.maxNodeActivations,
 			engineMaxSubworkflowDepth: mergedExecutionOptions.maxSubworkflowDepth,
 			data,
-			nodeState: this.nodeStatePublisherFactory.create(runId, request.workflow.id, request.parent)
+			nodeState: this.nodeStatePublisherFactory.create(runId, request.workflow.id, request.parent),
+			testContext: mergedExecutionOptions.testContext
 		});
 		return await this.scheduleInitialPlan({
 			runId,
@@ -3626,7 +4287,7 @@ var RunStartService = class {
 		return {
 			outputsByNode: { ...currentState?.outputsByNode ?? {} },
 			nodeSnapshotsByNodeId: { ...currentState?.nodeSnapshotsByNodeId ?? {} },
-			connectionInvocations: currentState?.connectionInvocations ? [...currentState.connectionInvocations] : void 0,
+			connectionInvocations: [],
 			mutableState: mutableState ?? currentState?.mutableState
 		};
 	}
@@ -3779,6 +4440,57 @@ var RunStartService = class {
 		this.waiters.resolveRunCompletion(result);
 		return result;
 	}
+	async failRunDuringPlanning(args) {
+		const finishedAt = (/* @__PURE__ */ new Date()).toISOString();
+		const failedSnapshot = NodeExecutionSnapshotFactory.failed({
+			previous: void 0,
+			runId: args.runId,
+			workflowId: args.workflowId,
+			nodeId: args.err.nodeId,
+			activationId: "planning_failure",
+			parent: args.parent,
+			finishedAt,
+			inputsByPort: {},
+			error: args.err
+		});
+		const failedState = this.persistedRunStateTerminalBuilder.mergeTerminal({
+			state: {
+				runId: args.runId,
+				workflowId: args.workflowId,
+				startedAt: args.startedAt,
+				parent: args.parent,
+				executionOptions: args.executionOptions,
+				control: args.control,
+				workflowSnapshot: args.workflowSnapshot,
+				mutableState: args.mutableState,
+				policySnapshot: args.policySnapshot,
+				engineCounters: { completedNodeActivations: 0 },
+				status: "pending",
+				pending: void 0,
+				queue: [],
+				outputsByNode: {},
+				nodeSnapshotsByNodeId: {},
+				connectionInvocations: []
+			},
+			engineCounters: { completedNodeActivations: 0 },
+			status: "failed",
+			queue: [],
+			outputsByNode: {},
+			nodeSnapshotsByNodeId: { [args.err.nodeId]: failedSnapshot },
+			finishedAtIso: finishedAt
+		});
+		await this.workflowExecutionRepository.save(failedState);
+		await this.nodeEventPublisher.publish("nodeFailed", failedSnapshot);
+		const result = {
+			runId: args.runId,
+			workflowId: args.workflowId,
+			startedAt: args.startedAt,
+			status: "failed",
+			error: { message: args.err.message }
+		};
+		this.waiters.resolveRunCompletion(result);
+		return result;
+	}
 };
 
 //#endregion
@@ -4252,6 +4964,128 @@ var InMemoryRunDataFactory = class {
 	}
 };
 
+//#endregion
+//#region src/triggers/polling/PollingTriggerDedupWindow.ts
+/**
+* Merges processed-ID windows for polling triggers, capping the total to avoid unbounded growth.
+* Plugin code receives an instance of this class via {@link PollingTriggerHandle.dedup}.
+*/
+var PollingTriggerDedupWindow = class PollingTriggerDedupWindow {
+	static defaultCapN = 2e3;
+	merge(previous, incoming, capN = PollingTriggerDedupWindow.defaultCapN) {
+		const merged = new Set(previous);
+		for (const id of incoming) merged.add(id);
+		const result = [...merged];
+		if (result.length <= capN) return result;
+		return result.slice(result.length - capN);
+	}
+};
+
+//#endregion
+//#region src/triggers/polling/PollingTriggerRuntime.ts
+/**
+* Generic polling-trigger runtime. Owns the set-interval loop, overlap guard, and persistence.
+* Constructed by {@link import("../../runtime/EngineFactory").EngineFactory} and exposed to plugin
+* authors via {@link import("../../contracts/runtimeTypes").TriggerSetupContext}.polling.
+*/
+var PollingTriggerRuntime = class {
+	activeTriggers = /* @__PURE__ */ new Set();
+	intervalsByTrigger = /* @__PURE__ */ new Map();
+	busyTriggers = /* @__PURE__ */ new Set();
+	constructor(triggerSetupStateRepository, logger) {
+		this.triggerSetupStateRepository = triggerSetupStateRepository;
+		this.logger = logger;
+	}
+	async start(args) {
+		let first;
+		try {
+			first = await this.runCycle(args, { seedState: args.seedState });
+		} catch (err) {
+			this.logError(`Polling trigger initial cycle failed for ${this.describe(args.trigger)}`, err);
+		}
+		this.ensureLoop(args);
+		return first;
+	}
+	async stop(trigger) {
+		const key = this.toKey(trigger);
+		const interval = this.intervalsByTrigger.get(key);
+		if (interval !== void 0) {
+			clearInterval(interval);
+			this.intervalsByTrigger.delete(key);
+		}
+		this.busyTriggers.delete(key);
+		this.activeTriggers.delete(key);
+		this.logger.debug(`Polling trigger stopped for ${this.describe(trigger)}`);
+	}
+	ensureLoop(args) {
+		const key = this.toKey(args.trigger);
+		if (this.activeTriggers.has(key)) {
+			this.logger.debug(`Polling trigger already active for ${this.describe(args.trigger)}`);
+			return;
+		}
+		this.activeTriggers.add(key);
+		const intervalMs = Math.max(args.intervalMs, 25);
+		const interval = setInterval(() => {
+			this.runCycle(args, { seedState: void 0 }).catch((err) => {
+				this.logError(`Polling trigger cycle failed for ${this.describe(args.trigger)}`, err);
+			});
+		}, intervalMs);
+		this.intervalsByTrigger.set(key, interval);
+		this.logger.info(`Polling trigger started for ${this.describe(args.trigger)} (interval ${intervalMs}ms)`);
+	}
+	async runCycle(args, opts) {
+		const key = this.toKey(args.trigger);
+		if (this.busyTriggers.has(key)) {
+			this.logger.debug(`Polling trigger skipping overlapping tick for ${this.describe(args.trigger)}`);
+			return;
+		}
+		this.busyTriggers.add(key);
+		try {
+			const loaded = await this.triggerSetupStateRepository.load(args.trigger);
+			const previousState = loaded !== void 0 ? loaded.state : opts.seedState;
+			const controller = new AbortController();
+			const { items, nextState } = await args.runCycle({
+				previousState,
+				signal: controller.signal
+			});
+			await this.triggerSetupStateRepository.save({
+				trigger: args.trigger,
+				updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+				state: nextState
+			});
+			if (items.length > 0) {
+				this.logger.info(`Polling trigger emitting ${items.length} item(s) for ${this.describe(args.trigger)}`);
+				await args.emit(items);
+			}
+			return nextState;
+		} finally {
+			this.busyTriggers.delete(key);
+		}
+	}
+	toKey(trigger) {
+		return `${trigger.workflowId}:${trigger.nodeId}`;
+	}
+	describe(trigger) {
+		return `${trigger.workflowId}.${trigger.nodeId}`;
+	}
+	logError(message, error) {
+		if (error instanceof Error) {
+			this.logger.error(message, error);
+			return;
+		}
+		this.logger.error(`${message}: ${String(error)}`);
+	}
+};
+
+//#endregion
+//#region src/triggers/polling/PollingTriggerLogger.ts
+var NoOpPollingTriggerLogger = class {
+	info() {}
+	warn() {}
+	error() {}
+	debug() {}
+};
+
 //#endregion
 //#region src/orchestration/NodeExecutionRequestHandlerService.ts
 var NodeExecutionRequestHandlerService = class {
@@ -4291,7 +5125,8 @@ var NodeExecutionRequestHandlerService = class {
 			engineMaxNodeActivations: limits.engineMaxNodeActivations,
 			engineMaxSubworkflowDepth: limits.engineMaxSubworkflowDepth,
 			data,
-			nodeState: this.nodeStatePublisherFactory.create(state.runId, state.workflowId, resolvedParent)
+			nodeState: this.nodeStatePublisherFactory.create(state.runId, state.workflowId, resolvedParent),
+			testContext: state.executionOptions?.testContext
 		});
 		const inputsByPort = pendingExecution.inputsByPort;
 		const portKeys = Object.keys(inputsByPort);
@@ -4681,7 +5516,7 @@ var EngineWorkflowPlanningFactory = class {
 var TriggerRuntimeService = class {
 	credentialResolverFactory;
 	triggerCleanupHandlesByKey = /* @__PURE__ */ new Map();
-	constructor(workflowRepository, workflowActivationPolicy, runIdFactory, runDataFactory, executionContextFactory, credentialResolverFactory, nodeExecutionStatePublisherFactory, nodeResolver, triggerSetupStateRepository, emitHandler, executionLimitsPolicy, diagnostics) {
+	constructor(workflowRepository, workflowActivationPolicy, runIdFactory, runDataFactory, executionContextFactory, credentialResolverFactory, nodeExecutionStatePublisherFactory, nodeResolver, triggerSetupStateRepository, emitHandler, executionLimitsPolicy, diagnostics, pollingTriggerRuntime, pollingTriggerDedupWindow) {
 		this.workflowRepository = workflowRepository;
 		this.workflowActivationPolicy = workflowActivationPolicy;
 		this.runIdFactory = runIdFactory;
@@ -4693,6 +5528,8 @@ var TriggerRuntimeService = class {
 		this.emitHandler = emitHandler;
 		this.executionLimitsPolicy = executionLimitsPolicy;
 		this.diagnostics = diagnostics;
+		this.pollingTriggerRuntime = pollingTriggerRuntime;
+		this.pollingTriggerDedupWindow = pollingTriggerDedupWindow;
 		this.credentialResolverFactory = credentialResolverFactory;
 	}
 	async startTriggers() {
@@ -4748,6 +5585,7 @@ var TriggerRuntimeService = class {
 	async startTriggersForWorkflow(wf) {
 		for (const def of wf.nodes) {
 			if (def.kind !== "trigger") continue;
+			if (def.config.triggerKind === "test") continue;
 			const node$1 = this.nodeResolver.resolve(def.type);
 			const data = this.runDataFactory.create();
 			const triggerRunId = this.runIdFactory.makeRunId();
@@ -4757,6 +5595,9 @@ var TriggerRuntimeService = class {
 			};
 			await this.stopTrigger(trigger);
 			const previousState = await this.triggerSetupStateRepository.load(trigger);
+			const emit = this.emitHandler.emit.bind(this.emitHandler, wf, def.id);
+			const registerCleanup = this.registerTriggerCleanupHandle.bind(this, trigger);
+			const polling = this.buildPollingHandle(trigger, emit);
 			let nextState;
 			try {
 				nextState = await node$1.setup({
@@ -4769,12 +5610,9 @@ var TriggerRuntimeService = class {
 					trigger,
 					config: def.config,
 					previousState: previousState?.state,
-					registerCleanup: (cleanup) => {
-						this.registerTriggerCleanupHandle(trigger, cleanup);
-					},
-					emit: async (items) => {
-						await this.emitHandler.emit(wf, def.id, items);
-					}
+					registerCleanup,
+					emit,
+					polling
 				});
 			} catch (triggerError) {
 				await this.stopTrigger(trigger);
@@ -4793,6 +5631,7 @@ var TriggerRuntimeService = class {
 	async stopTriggersForWorkflow(workflow) {
 		for (const node$1 of workflow.nodes) {
 			if (node$1.kind !== "trigger") continue;
+			if (node$1.config.triggerKind === "test") continue;
 			await this.stopTrigger({
 				workflowId: workflow.id,
 				nodeId: node$1.id
@@ -4833,6 +5672,7 @@ var TriggerRuntimeService = class {
 		const out = [];
 		for (const def of wf.nodes) {
 			if (def.kind !== "trigger") continue;
+			if (def.config.triggerKind === "test") continue;
 			out.push(this.describeTriggerNode(def));
 		}
 		return out;
@@ -4850,6 +5690,22 @@ var TriggerRuntimeService = class {
 		if (this.diagnostics) this.diagnostics.warn(message);
 		else console.warn(`[engine] ${message}`);
 	}
+	buildPollingHandle(trigger, emit) {
+		const runtime = this.pollingTriggerRuntime;
+		return {
+			dedup: this.pollingTriggerDedupWindow,
+			start: async (args) => {
+				this.registerTriggerCleanupHandle(trigger, { stop: async () => {
+					await runtime.stop(trigger);
+				} });
+				return runtime.start({
+					trigger,
+					emit,
+					...args
+				});
+			}
+		};
+	}
 	isTestableTriggerNode(node$1) {
 		return typeof node$1.getTestItems === "function";
 	}
@@ -4986,7 +5842,7 @@ var EngineFactory = class {
 		const waiters = new EngineWaiters();
 		const credentialResolverFactory = new CredentialResolverFactory(deps.credentialSessions);
 		const nodeEventPublisher = new NodeEventPublisher(deps.eventBus);
-		const nodeStatePublisherFactory = new NodeRunStateWriterFactory(deps.workflowExecutionRepository, nodeEventPublisher);
+		const nodeStatePublisherFactory = new NodeRunStateWriterFactory(deps.workflowExecutionRepository, nodeEventPublisher, deps.eventBus);
 		const planningFactory = new EngineWorkflowPlanningFactory(deps.workflowNodeInstanceFactory);
 		const executionLimitsPolicy = deps.executionLimitsPolicy ?? new EngineExecutionLimitsPolicy();
 		const workflowSnapshotCodec = deps.workflowSnapshotCodec ?? new WorkflowSnapshotCodec(deps.tokenRegistry);
@@ -5001,12 +5857,15 @@ var EngineFactory = class {
 		const storagePolicyEvaluator = new WorkflowStoragePolicyEvaluator(deps.nodeResolver);
 		const terminalPersistence = new RunTerminalPersistenceCoordinator(deps.workflowExecutionRepository, storagePolicyEvaluator);
 		const policyErrorServices = new WorkflowPolicyErrorServices(deps.nodeResolver);
-		const runStartService = new RunStartService(deps.runIdFactory, deps.workflowExecutionRepository, deps.runDataFactory, workflowSnapshotCodec, planningFactory, nodeStatePublisherFactory, runExecutionContextFactory, nodeActivationRequestComposer, activationEnqueueService, semantics, waiters, deps.workflowPolicyRuntimeDefaults, executionLimitsPolicy);
+		const runStartService = new RunStartService(deps.runIdFactory, deps.workflowExecutionRepository, deps.runDataFactory, workflowSnapshotCodec, planningFactory, nodeStatePublisherFactory, runExecutionContextFactory, nodeActivationRequestComposer, activationEnqueueService, semantics, waiters, deps.workflowPolicyRuntimeDefaults, executionLimitsPolicy, nodeEventPublisher, persistedRunStateTerminalBuilder);
 		const runContinuationService = new RunContinuationService(deps.activationIdFactory, deps.workflowExecutionRepository, deps.runDataFactory, runExecutionContextFactory, workflowSnapshotResolver, planningFactory, nodeStatePublisherFactory, credentialResolverFactory, nodeActivationRequestComposer, persistedRunStateTerminalBuilder, activationEnqueueService, nodeEventPublisher, semantics, waiters, policyErrorServices, terminalPersistence, executionLimitsPolicy);
 		const nodeExecutionRequestHandler = new NodeExecutionRequestHandlerService(deps.workflowExecutionRepository, workflowSnapshotResolver, deps.runDataFactory, runExecutionContextFactory, nodeStatePublisherFactory, nodeActivationRequestComposer, deps.nodeExecutor, runContinuationService, executionLimitsPolicy);
+		const pollingTriggerLogger = deps.pollingTriggerLogger ?? new NoOpPollingTriggerLogger();
+		const pollingTriggerDedupWindow = new PollingTriggerDedupWindow();
+		const pollingTriggerRuntime = new PollingTriggerRuntime(deps.triggerSetupStateRepository, pollingTriggerLogger);
 		const triggerRuntime = new TriggerRuntimeService(deps.workflowRepository, deps.workflowActivationPolicy, deps.runIdFactory, deps.runDataFactory, deps.executionContextFactory, credentialResolverFactory, nodeStatePublisherFactory, deps.nodeResolver, deps.triggerSetupStateRepository, { emit: async (workflow, triggerNodeId, items) => {
 			await runStartService.runWorkflow(workflow, triggerNodeId, items, void 0);
-		} }, executionLimitsPolicy, deps.triggerRuntimeDiagnostics);
+		} }, executionLimitsPolicy, deps.triggerRuntimeDiagnostics, pollingTriggerRuntime, pollingTriggerDedupWindow);
 		const engine = new Engine({
 			liveWorkflowRepository: deps.liveWorkflowRepository,
 			tokenRegistry: deps.tokenRegistry,
@@ -5297,6 +6156,18 @@ var WorkflowRepositoryWebhookTriggerMatcherFactory = class {
 };
 
 //#endregion
+Object.defineProperty(exports, 'AgentConfigInspector', {
+  enumerable: true,
+  get: function () {
+    return AgentConfigInspector;
+  }
+});
+Object.defineProperty(exports, 'AgentConnectionNodeCollector', {
+  enumerable: true,
+  get: function () {
+    return AgentConnectionNodeCollector;
+  }
+});
 Object.defineProperty(exports, 'AllWorkflowsActiveWorkflowActivationPolicy', {
   enumerable: true,
   get: function () {
@@ -5309,6 +6180,18 @@ Object.defineProperty(exports, 'CatalogBackedCostTrackingTelemetryFactory', {
     return CatalogBackedCostTrackingTelemetryFactory;
   }
 });
+Object.defineProperty(exports, 'ChainCursor', {
+  enumerable: true,
+  get: function () {
+    return ChainCursor;
+  }
+});
+Object.defineProperty(exports, 'ChildExecutionScopeFactory', {
+  enumerable: true,
+  get: function () {
+    return ChildExecutionScopeFactory;
+  }
+});
 Object.defineProperty(exports, 'CodemationTelemetryAttributeNames', {
   enumerable: true,
   get: function () {
@@ -5327,6 +6210,18 @@ Object.defineProperty(exports, 'ConfigDrivenOffloadPolicy', {
     return ConfigDrivenOffloadPolicy;
   }
 });
+Object.defineProperty(exports, 'ConnectionInvocationEventPublisher', {
+  enumerable: true,
+  get: function () {
+    return ConnectionInvocationEventPublisher;
+  }
+});
+Object.defineProperty(exports, 'ConnectionInvocationIdFactory', {
+  enumerable: true,
+  get: function () {
+    return ConnectionInvocationIdFactory;
+  }
+});
 Object.defineProperty(exports, 'ConnectionNodeIdFactory', {
   enumerable: true,
   get: function () {
@@ -5387,6 +6282,12 @@ Object.defineProperty(exports, 'DefaultExecutionContextFactory', {
     return DefaultExecutionContextFactory;
   }
 });
+Object.defineProperty(exports, 'DefaultWorkflowGraphFactory', {
+  enumerable: true,
+  get: function () {
+    return DefaultWorkflowGraphFactory;
+  }
+});
 Object.defineProperty(exports, 'ENGINE_EXECUTION_LIMITS_DEFAULTS', {
   enumerable: true,
   get: function () {
@@ -5531,6 +6432,12 @@ Object.defineProperty(exports, 'NoOpNodeExecutionTelemetry', {
     return NoOpNodeExecutionTelemetry;
   }
 });
+Object.defineProperty(exports, 'NoOpPollingTriggerLogger', {
+  enumerable: true,
+  get: function () {
+    return NoOpPollingTriggerLogger;
+  }
+});
 Object.defineProperty(exports, 'NoOpTelemetryArtifactReference', {
   enumerable: true,
   get: function () {
@@ -5549,6 +6456,12 @@ Object.defineProperty(exports, 'NoRetryPolicy', {
     return NoRetryPolicy;
   }
 });
+Object.defineProperty(exports, 'NodeBackedToolConfig', {
+  enumerable: true,
+  get: function () {
+    return NodeBackedToolConfig;
+  }
+});
 Object.defineProperty(exports, 'NodeEventPublisher', {
   enumerable: true,
   get: function () {
@@ -5567,6 +6480,12 @@ Object.defineProperty(exports, 'NodeExecutorFactory', {
     return NodeExecutorFactory;
   }
 });
+Object.defineProperty(exports, 'NodeIdSlugifier', {
+  enumerable: true,
+  get: function () {
+    return NodeIdSlugifier;
+  }
+});
 Object.defineProperty(exports, 'NodeInstanceFactory', {
   enumerable: true,
   get: function () {
@@ -5579,6 +6498,12 @@ Object.defineProperty(exports, 'NodeInstanceFactoryFactory', {
     return NodeInstanceFactoryFactory;
   }
 });
+Object.defineProperty(exports, 'NodeIterationIdFactory', {
+  enumerable: true,
+  get: function () {
+    return NodeIterationIdFactory;
+  }
+});
 Object.defineProperty(exports, 'NodeOutputNormalizer', {
   enumerable: true,
   get: function () {
@@ -5603,6 +6528,18 @@ Object.defineProperty(exports, 'PersistedWorkflowTokenRegistry', {
     return PersistedWorkflowTokenRegistry;
   }
 });
+Object.defineProperty(exports, 'PollingTriggerDedupWindow', {
+  enumerable: true,
+  get: function () {
+    return PollingTriggerDedupWindow;
+  }
+});
+Object.defineProperty(exports, 'PollingTriggerRuntime', {
+  enumerable: true,
+  get: function () {
+    return PollingTriggerRuntime;
+  }
+});
 Object.defineProperty(exports, 'RetryPolicy', {
   enumerable: true,
   get: function () {
@@ -5663,6 +6600,24 @@ Object.defineProperty(exports, 'UnavailableBinaryStorage', {
     return UnavailableBinaryStorage;
   }
 });
+Object.defineProperty(exports, 'WhenBuilder', {
+  enumerable: true,
+  get: function () {
+    return WhenBuilder;
+  }
+});
+Object.defineProperty(exports, 'WorkflowBuilder', {
+  enumerable: true,
+  get: function () {
+    return WorkflowBuilder;
+  }
+});
+Object.defineProperty(exports, 'WorkflowDefinitionError', {
+  enumerable: true,
+  get: function () {
+    return WorkflowDefinitionError;
+  }
+});
 Object.defineProperty(exports, 'WorkflowExecutableNodeClassifier', {
   enumerable: true,
   get: function () {
@@ -5795,4 +6750,4 @@ Object.defineProperty(exports, 'tool', {
     return tool;
   }
 });
-//# sourceMappingURL=runtime-Dvo2ru5A.cjs.map
+//# sourceMappingURL=runtime-DKXJwTNv.cjs.map