@codemation/core 0.8.1 → 0.10.1

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

@@ -1,7 +1,7 @@
 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 } from "node:crypto";
+import { createHash, randomUUID } from "node:crypto";
 import { ReadableStream } from "node:stream/web";
 
 //#region src/di/CoreTokens.ts
@@ -137,6 +137,56 @@ function chatModel(options = {}) {
 	return InjectableRuntimeDecoratorComposer.compose("chatModel", options, import.meta.url);
 }
 
+//#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");
@@ -205,6 +255,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
 /**
@@ -255,6 +326,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_${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_${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
 /**
@@ -315,6 +749,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$1) {
+		return this.outgoingByNodeAndPort.get(nodeId)?.get(output$1) ?? [];
+	}
+};
+
+//#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}. */
@@ -633,6 +1130,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
 /**
@@ -773,6 +1312,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 {
@@ -933,31 +1486,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
@@ -985,6 +1561,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 {
@@ -998,6 +1596,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
@@ -1023,19 +1627,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) {
@@ -1043,15 +1634,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 {
@@ -1091,6 +1673,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)
+				});
 			}
 		};
 	}
@@ -1102,7 +1691,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)
+				});
+			}
 		};
 	}
 };
@@ -1111,11 +1707,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({
@@ -1140,7 +1737,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
 		};
 	}
 };
@@ -1573,13 +2172,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({
@@ -1973,7 +2576,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) {
@@ -1998,12 +2606,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 () => {
@@ -2100,12 +2709,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) {
@@ -2132,13 +2745,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);
 		});
 	}
 };
@@ -2263,7 +2880,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
 		});
 	}
 };
@@ -2430,7 +3048,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();
@@ -2951,7 +3570,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,
@@ -3042,7 +3662,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 {
@@ -3434,7 +4055,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;
@@ -3448,6 +4069,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();
@@ -3478,9 +4101,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 = {};
@@ -3559,7 +4201,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,
@@ -3577,7 +4237,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,
@@ -3599,7 +4260,7 @@ var RunStartService = class {
 		return {
 			outputsByNode: { ...currentState?.outputsByNode ?? {} },
 			nodeSnapshotsByNodeId: { ...currentState?.nodeSnapshotsByNodeId ?? {} },
-			connectionInvocations: currentState?.connectionInvocations ? [...currentState.connectionInvocations] : void 0,
+			connectionInvocations: [],
 			mutableState: mutableState ?? currentState?.mutableState
 		};
 	}
@@ -3752,6 +4413,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
@@ -4225,6 +4937,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 {
@@ -4264,7 +5098,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);
@@ -4654,7 +5489,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;
@@ -4666,6 +5501,8 @@ var TriggerRuntimeService = class {
 		this.emitHandler = emitHandler;
 		this.executionLimitsPolicy = executionLimitsPolicy;
 		this.diagnostics = diagnostics;
+		this.pollingTriggerRuntime = pollingTriggerRuntime;
+		this.pollingTriggerDedupWindow = pollingTriggerDedupWindow;
 		this.credentialResolverFactory = credentialResolverFactory;
 	}
 	async startTriggers() {
@@ -4721,6 +5558,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();
@@ -4730,6 +5568,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({
@@ -4742,12 +5583,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);
@@ -4766,6 +5604,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
@@ -4806,6 +5645,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;
@@ -4823,6 +5663,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";
 	}
@@ -4959,7 +5815,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);
@@ -4974,12 +5830,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,
@@ -5270,5 +6129,5 @@ var WorkflowRepositoryWebhookTriggerMatcherFactory = class {
 };
 
 //#endregion
-export { CostTrackingTelemetryMetricNames as $, NodeExecutor as A, inject as At, nodeRef as B, StaticCostCatalog as C, tool as Ct, PersistedWorkflowTokenRegistry as D, PersistedRuntimeTypeNameResolver as Dt, WorkflowSnapshotCodec as E, StackTraceCallSitePathResolver as Et, InProcessRetryRunner as F, predicateAwareClassFactory as Ft, NoOpExecutionTelemetryFactory as G, CodemationTelemetryMetricNames as H, CatalogBackedCostTrackingTelemetryFactory as I, registry as It, NoOpTelemetrySpanScope as J, NoOpExecutionTelemetry as K, DefaultExecutionContextFactory as L, singleton as Lt, RunnableOutputBehaviorResolver as M, injectable as Mt, NodeOutputNormalizer as N, instanceCachingFactory as Nt, MissingRuntimeTriggerToken as O, container$1 as Ot, ItemExprResolver as P, instancePerContainerCachingFactory as Pt, CostTrackingTelemetryAttributeNames as Q, AllWorkflowsActiveWorkflowActivationPolicy as R, CoreTokens as Rt, RunPolicySnapshotFactory as S, node as St, NodeInstanceFactory as T, PersistedRuntimeTypeMetadataStore as Tt, GenAiTelemetryAttributeNames as U, RunFinishedAtFactory as V, CodemationTelemetryAttributeNames as W, NoOpCostTrackingTelemetryFactory as X, NoOpTelemetryArtifactReference as Y, NoOpCostTrackingTelemetry as Z, LocalOnlyScheduler as _, itemExpr as _t, InMemoryLiveWorkflowRepository as a, isPortsEmission as at, DefaultDrivingScheduler as b, chatModel as bt, EngineFactory as c, CredentialResolverFactory as ct, InMemoryBinaryStorage as d, UnavailableBinaryStorage as dt, CredentialUnboundError as et, WorkflowStoragePolicyEvaluator as f, NodeEventPublisher as ft, EngineExecutionLimitsPolicy as g, isItemExpr as gt, ENGINE_EXECUTION_LIMITS_DEFAULTS as h, ConnectionNodeIdFactory as ht, RunIntentService as i, emitPorts as it, InProcessRetryRunnerFactory as j, injectAll as jt, NodeExecutorFactory as k, delay as kt, Engine as l, getOriginIndexFromItem as lt, RunTerminalPersistenceCoordinator as m, WorkflowExecutableNodeClassifier as mt, WorkflowRepositoryWebhookTriggerMatcher as n, RetryPolicy as nt, EngineWorkflowRunnerServiceFactory as o, isUnbrandedPortsEmissionShape as ot, WorkflowPolicyErrorServices as p, WorkflowExecutableNodeClassifierFactory as pt, NoOpNodeExecutionTelemetry as q, RunIntentServiceFactory as r, NoRetryPolicy as rt, EngineWorkflowRunnerService as s, DefaultAsyncSleeper as st, WorkflowRepositoryWebhookTriggerMatcherFactory as t, ExpRetryPolicy as tt, InMemoryRunDataFactory as u, DefaultExecutionBinaryService as ut, InlineDrivingScheduler as v, resolveItemExprsForExecution as vt, NodeInstanceFactoryFactory as w, InjectableRuntimeDecoratorComposer as wt, ConfigDrivenOffloadPolicy as x, getPersistedRuntimeTypeMetadata as xt, HintOnlyOffloadPolicy as y, resolveItemExprsInUnknown as yt, branchRef as z };
-//# sourceMappingURL=runtime-DUW6tIJ1.js.map
+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