@codemation/core 1.0.0 → 2.0.0

package/dist/index.js

@@ -1,7 +1,6 @@
-import { $ as CostTrackingTelemetryMetricNames, At as inject, B as nodeRef, Ct as tool, Dt as PersistedRuntimeTypeNameResolver, Et as StackTraceCallSitePathResolver, F as InProcessRetryRunner, Ft as predicateAwareClassFactory, G as NoOpExecutionTelemetryFactory, H as CodemationTelemetryMetricNames, It as registry, J as NoOpTelemetrySpanScope, K as NoOpExecutionTelemetry, L as DefaultExecutionContextFactory, Lt as singleton, M as RunnableOutputBehaviorResolver, Mt as injectable, N as NodeOutputNormalizer, Nt as instanceCachingFactory, Ot as container, P as ItemExprResolver, Pt as instancePerContainerCachingFactory, Q as CostTrackingTelemetryAttributeNames, R as AllWorkflowsActiveWorkflowActivationPolicy, Rt as CoreTokens, St as node, Tt as PersistedRuntimeTypeMetadataStore, U as GenAiTelemetryAttributeNames, V as RunFinishedAtFactory, W as CodemationTelemetryAttributeNames, X as NoOpCostTrackingTelemetryFactory, Y as NoOpTelemetryArtifactReference, Z as NoOpCostTrackingTelemetry, _t as itemExpr, a as InMemoryLiveWorkflowRepository, at as isPortsEmission, bt as chatModel, ct as CredentialResolverFactory, d as InMemoryBinaryStorage, dt as UnavailableBinaryStorage, et as CredentialUnboundError, ft as NodeEventPublisher, g as EngineExecutionLimitsPolicy, gt as isItemExpr, ht as ConnectionNodeIdFactory, i as RunIntentService, it as emitPorts, jt as injectAll, kt as delay, lt as getOriginIndexFromItem, mt as WorkflowExecutableNodeClassifier, nt as RetryPolicy, ot as isUnbrandedPortsEmissionShape, pt as WorkflowExecutableNodeClassifierFactory, q as NoOpNodeExecutionTelemetry, rt as NoRetryPolicy, st as DefaultAsyncSleeper, tt as ExpRetryPolicy, u as InMemoryRunDataFactory, ut as DefaultExecutionBinaryService, vt as resolveItemExprsForExecution, wt as InjectableRuntimeDecoratorComposer, xt as getPersistedRuntimeTypeMetadata, yt as resolveItemExprsInUnknown, z as branchRef } from "./runtime-u6O644ST.js";
-import { i as WhenBuilder, n as WorkflowBuilder, r as ChainCursor, t as InMemoryRunEventBus } from "./InMemoryRunEventBusRegistry-C2U83Hmv.js";
+import { $ as NoOpCostTrackingTelemetryFactory, $t as singleton, At as AgentConfigInspector, B as DefaultExecutionContextFactory, Bt as InjectableRuntimeDecoratorComposer, Ct as WorkflowBuilder, Dt as WhenBuilder, Et as ChainCursor, F as RunnableOutputBehaviorResolver, Ft as NodeBackedToolConfig, G as CodemationTelemetryAttributeNames, Gt as delay, H as nodeRef, Ht as StackTraceCallSitePathResolver, I as NodeOutputNormalizer, It as chatModel, J as NoOpExecutionTelemetryFactory, Jt as injectable, K as AllWorkflowsActiveWorkflowActivationPolicy, Kt as inject, L as ItemExprResolver, Lt as getPersistedRuntimeTypeMetadata, Mt as itemExpr, Nt as resolveItemExprsForExecution, Ot as AgentConnectionNodeCollector, Pt as resolveItemExprsInUnknown, Q as NoOpTelemetryArtifactReference, Qt as registry, R as InProcessRetryRunner, Rt as node, St as ConnectionInvocationIdFactory, Tt as NodeIdSlugifier, U as CodemationTelemetryMetricNames, Ut as PersistedRuntimeTypeNameResolver, V as branchRef, Vt as PersistedRuntimeTypeMetadataStore, W as GenAiTelemetryAttributeNames, Wt as container, X as NoOpNodeExecutionTelemetry, Xt as instancePerContainerCachingFactory, Y as NoOpExecutionTelemetry, Yt as instanceCachingFactory, Z as NoOpTelemetrySpanScope, Zt as predicateAwareClassFactory, _t as ConnectionInvocationEventPublisher, a as InMemoryLiveWorkflowRepository, at as RetryPolicy, bt as WorkflowExecutableNodeClassifier, ct as isPortsEmission, d as PollingTriggerRuntime, dt as CredentialResolverFactory, en as CoreTokens, et as NoOpCostTrackingTelemetry, f as PollingTriggerDedupWindow, ft as getOriginIndexFromItem, gt as NodeEventPublisher, ht as UnavailableBinaryStorage, i as RunIntentService, it as ExpRetryPolicy, jt as isItemExpr, kt as ConnectionNodeIdFactory, lt as isUnbrandedPortsEmissionShape, m as InMemoryBinaryStorage, mt as DefaultExecutionBinaryService, nt as CostTrackingTelemetryMetricNames, ot as NoRetryPolicy, p as InMemoryRunDataFactory, pt as ChildExecutionScopeFactory, q as RunFinishedAtFactory, qt as injectAll, rt as CredentialUnboundError, st as emitPorts, tt as CostTrackingTelemetryAttributeNames, u as NoOpPollingTriggerLogger, ut as DefaultAsyncSleeper, vt as DefaultWorkflowGraphFactory, wt as WorkflowDefinitionError, xt as NodeIterationIdFactory, y as EngineExecutionLimitsPolicy, yt as WorkflowExecutableNodeClassifierFactory, zt as tool } from "./runtime-BGNbRnqs.js";
+import { t as InMemoryRunEventBus } from "./InMemoryRunEventBusRegistry-sM4z4n_i.js";
 import { ZodError, z } from "zod";
-import { randomUUID } from "node:crypto";
 
 //#region src/contracts/Clock.ts
 var SystemClock = class {
@@ -24,7 +23,7 @@ var DefinedNodeRegistry = class {
 
 //#endregion
 //#region src/authoring/defineNode.types.ts
-const definedNodeCredentialRequirementFactory = {
+const definedNodeCredentialRequirementFactory$1 = {
 	create(bindings) {
 		if (!bindings) return [];
 		return Object.entries(bindings).map(([slotKey, binding]) => {
@@ -54,13 +53,13 @@ const definedNodeCredentialRequirementFactory = {
 		return key.replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/[-_.]+/g, " ").replace(/\s+/g, " ").trim().replace(/^./, (character) => character.toUpperCase());
 	}
 };
-const definedNodeCredentialAccessorFactory = { create(bindings, ctx) {
+const definedNodeCredentialAccessorFactory$1 = { create(bindings, ctx) {
 	if (!bindings) return {};
 	const entries = Object.keys(bindings).map((slotKey) => [slotKey, () => ctx.getCredential(slotKey)]);
 	return Object.fromEntries(entries);
 } };
 function defineNode(options) {
-	const credentialRequirements = definedNodeCredentialRequirementFactory.create(options.credentials);
+	const credentialRequirements = definedNodeCredentialRequirementFactory$1.create(options.credentials);
 	const DefinedNodeRuntime = class {
 		kind = "node";
 		outputPorts = ["main"];
@@ -69,7 +68,7 @@ function defineNode(options) {
 			const ctx = args.ctx;
 			const context = {
 				config: ctx.config.config,
-				credentials: definedNodeCredentialAccessorFactory.create(options.credentials, ctx),
+				credentials: definedNodeCredentialAccessorFactory$1.create(options.credentials, ctx),
 				execution: ctx
 			};
 			const payload = {
@@ -115,7 +114,7 @@ function defineNode(options) {
 	return definition;
 }
 function defineBatchNode(options) {
-	const credentialRequirements = definedNodeCredentialRequirementFactory.create(options.credentials);
+	const credentialRequirements = definedNodeCredentialRequirementFactory$1.create(options.credentials);
 	const DefinedNodeRuntime = class {
 		kind = "node";
 		outputPorts = ["main"];
@@ -124,7 +123,7 @@ function defineBatchNode(options) {
 			const ctx = args.ctx;
 			const context = {
 				config: ctx.config.config,
-				credentials: definedNodeCredentialAccessorFactory.create(options.credentials, ctx),
+				credentials: definedNodeCredentialAccessorFactory$1.create(options.credentials, ctx),
 				execution: ctx
 			};
 			return [...await options.run(args.items.map((item) => item.json), context)];
@@ -332,75 +331,286 @@ function callableTool(options) {
 }
 
 //#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;
+//#region src/authoring/DefinedCollectionRegistry.ts
+var DefinedCollectionRegistry = class {
+	static definitions = /* @__PURE__ */ new Map();
+	static register(definition) {
+		this.definitions.set(definition.name, definition);
 	}
-	getCredentialRequirements() {
-		return this.node.getCredentialRequirements?.() ?? [];
+	static resolve(name) {
+		return this.definitions.get(name);
 	}
-	getInputSchema() {
-		return this.inputSchemaValue;
+	static list() {
+		return Array.from(this.definitions.values());
 	}
-	getOutputSchema() {
-		return this.outputSchemaValue;
+};
+
+//#endregion
+//#region src/authoring/defineCollection.types.ts
+var CollectionColumnBuilderImpl = class {
+	_nullable;
+	_default;
+	constructor(_type) {
+		this._type = _type;
+		this._nullable = true;
+	}
+	notNull() {
+		this._nullable = false;
+		return this;
+	}
+	default(value) {
+		this._default = value;
+		this._nullable = false;
+		return this;
 	}
-	toNodeItem(args) {
-		const mapped = this.mapInputValue?.(args) ?? args.input;
-		if (this.isItem(mapped)) return mapped;
-		return { json: mapped };
+};
+const c = {
+	text() {
+		return new CollectionColumnBuilderImpl("text");
+	},
+	int() {
+		return new CollectionColumnBuilderImpl("int");
+	},
+	bigint() {
+		return new CollectionColumnBuilderImpl("bigint");
+	},
+	double() {
+		return new CollectionColumnBuilderImpl("double");
+	},
+	bool() {
+		return new CollectionColumnBuilderImpl("bool");
+	},
+	timestamptz() {
+		return new CollectionColumnBuilderImpl("timestamptz");
+	},
+	jsonb() {
+		return new CollectionColumnBuilderImpl("jsonb");
+	},
+	uuid() {
+		return new CollectionColumnBuilderImpl("uuid");
 	}
-	toToolOutput(args) {
-		const raw = this.mapOutputValue?.(args) ?? this.readDefaultToolOutput(args.outputs);
-		return this.outputSchemaValue.parse(raw);
+};
+/**
+* Validates that a name follows the required pattern: lowercase + underscores, starts with letter.
+*/
+function validateCollectionName(name) {
+	if (!/^[a-z][a-z0-9_]*$/.test(name)) throw new Error(`Collection name "${name}" must start with a lowercase letter and contain only lowercase letters, digits, and underscores.`);
+}
+/**
+* Validates that all field names follow the required pattern.
+*/
+function validateFieldNames(fields) {
+	const pattern = /^[a-z][a-z0-9_]*$/;
+	const reserved = [
+		"id",
+		"created_at",
+		"updated_at"
+	];
+	for (const fieldName of Object.keys(fields)) {
+		if (reserved.includes(fieldName)) throw new Error(`Field name "${fieldName}" is reserved for internal use.`);
+		if (!pattern.test(fieldName)) throw new Error(`Field name "${fieldName}" must start with a lowercase letter and contain only lowercase letters, digits, and underscores.`);
 	}
-	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;
+}
+/**
+* Validates that all indexed fields exist in the declared fields.
+*/
+function validateIndexes(indexes, fieldNames) {
+	for (const index of indexes) for (const fieldName of index.on) if (!fieldNames.has(fieldName)) throw new Error(`Index references non-existent field "${fieldName}".`);
+}
+function defineCollection(options) {
+	validateCollectionName(options.name);
+	const fields = {};
+	for (const [fieldName, builder] of Object.entries(options.fields)) {
+		const columnBuilder = builder;
+		fields[fieldName] = {
+			type: columnBuilder._type,
+			nullable: columnBuilder._nullable,
+			default: columnBuilder._default
+		};
 	}
-	isItem(value) {
-		return typeof value === "object" && value !== null && "json" in value;
+	validateFieldNames(fields);
+	const fieldNames = new Set(Object.keys(fields));
+	const indexes = options.indexes ?? [];
+	validateIndexes(indexes, fieldNames);
+	const definition = {
+		name: options.name,
+		fields,
+		indexes
+	};
+	DefinedCollectionRegistry.register(definition);
+	return {
+		kind: "defined-collection",
+		definition,
+		register(context) {
+			context.registerCollection(definition);
+		}
+	};
+}
+
+//#endregion
+//#region src/authoring/definePollingTriggerInternals.ts
+const definedNodeCredentialRequirementFactory = {
+	create(bindings) {
+		if (!bindings) return [];
+		return Object.entries(bindings).map(([slotKey, binding]) => {
+			if (typeof binding === "string" || this.isCredentialType(binding)) return {
+				slotKey,
+				label: this.humanize(slotKey),
+				acceptedTypes: [this.resolveTypeId(binding)]
+			};
+			const types = Array.isArray(binding.type) ? binding.type : [binding.type];
+			return {
+				slotKey,
+				label: binding.label ?? this.humanize(slotKey),
+				acceptedTypes: types.map((entry) => this.resolveTypeId(entry)),
+				optional: binding.optional,
+				helpText: binding.helpText,
+				helpUrl: binding.helpUrl
+			};
+		});
+	},
+	isCredentialType(value) {
+		return Boolean(value) && typeof value === "object" && "definition" in value && typeof value.definition?.typeId === "string";
+	},
+	resolveTypeId(type) {
+		return typeof type === "string" ? type : type.definition.typeId;
+	},
+	humanize(key) {
+		return key.replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/[-_.]+/g, " ").replace(/\s+/g, " ").trim().replace(/^./, (character) => character.toUpperCase());
 	}
 };
+const definedNodeCredentialAccessorFactory = { create(bindings, ctx) {
+	if (!bindings) return {};
+	const entries = Object.keys(bindings).map((slotKey) => [slotKey, () => ctx.getCredential(slotKey)]);
+	return Object.fromEntries(entries);
+} };
 
 //#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;
+//#region src/authoring/definePollingTrigger.types.ts
+/**
+* TriggerNodeConfig produced by `DefinedPollingTrigger.create(...)`.
+* Holds user configuration and credential requirements for the engine.
+* The setup state type is opaque `JsonValue | undefined` — the runtime
+* uses an internal wrapped shape that plugin authors never see.
+*/
+var DefinedPollingTriggerConfig = class {
+	kind = "trigger";
+	type;
+	icon;
+	constructor(name, cfg, typeToken, icon, credentialRequirements, id) {
+		this.name = name;
+		this.cfg = cfg;
+		this.credentialRequirements = credentialRequirements;
+		this.id = id;
+		this.type = typeToken;
+		this.icon = icon;
+	}
+	getCredentialRequirements() {
+		return this.credentialRequirements;
 	}
 };
+function isWrappedState(value) {
+	return value !== null && typeof value === "object" && "seenKeys" in value && Array.isArray(value.seenKeys);
+}
+/**
+* Declarative helper for authoring polling triggers.
+*
+* ```ts
+* export const onNewMail = definePollingTrigger({
+*   key: "my-plugin.on-new-mail",
+*   title: "On new mail",
+*   configSchema: z.object({ folder: z.string() }),
+*   credentials: { auth: myOAuthCredentialType },
+*   initialState: () => ({ lastSeenId: undefined }),
+*   pollIntervalMs: 60_000,
+*   async poll({ config, state, credentials }) {
+*     const session = await credentials.auth();
+*     const messages = await fetchMessages(session, config.folder, state.lastSeenId);
+*     return {
+*       items: messages.map(m => ({ json: m, dedupKey: m.id })),
+*       nextState: { lastSeenId: messages[0]?.id ?? state.lastSeenId },
+*     };
+*   },
+* });
+* ```
+*/
+function definePollingTrigger(options) {
+	const credentialRequirements = definedNodeCredentialRequirementFactory.create(options.credentials);
+	const DEFAULT_INTERVAL_MS = 6e4;
+	const DefinedPollingTriggerRuntime = class {
+		kind = "trigger";
+		outputPorts = ["main"];
+		async setup(ctx) {
+			const cfg = ctx.config.cfg;
+			const intervalMs = cfg.pollIntervalMs ?? options.pollIntervalMs ?? DEFAULT_INTERVAL_MS;
+			const persisted = ctx.previousState;
+			const seedWrapped = (isWrappedState(persisted) ? persisted : void 0) ?? {
+				userState: options.initialState ? options.initialState() : void 0,
+				seenKeys: []
+			};
+			return await ctx.polling.start({
+				intervalMs,
+				seedState: seedWrapped,
+				runCycle: async ({ previousState }) => {
+					const wrapped = previousState ?? seedWrapped;
+					const seenSet = new Set(wrapped.seenKeys);
+					const credentialAccessors = definedNodeCredentialAccessorFactory.create(options.credentials, ctx);
+					const pollResult = await options.poll({
+						config: cfg,
+						state: wrapped.userState,
+						credentials: credentialAccessors
+					});
+					const newItems = [];
+					const newKeys = [];
+					for (const item of pollResult.items) {
+						if (item.dedupKey !== void 0) {
+							if (seenSet.has(item.dedupKey)) continue;
+							newKeys.push(item.dedupKey);
+						}
+						newItems.push({ json: item.json });
+					}
+					const allKeys = [...wrapped.seenKeys, ...newKeys];
+					const cappedKeys = allKeys.length > 2e3 ? allKeys.slice(allKeys.length - 2e3) : allKeys;
+					return {
+						items: newItems,
+						nextState: {
+							userState: pollResult.nextState,
+							seenKeys: cappedKeys
+						}
+					};
+				}
+			});
+		}
+		async execute(items, ctx) {
+			if (options.execute) return await options.execute(items, ctx);
+			return { main: items };
+		}
+		async getTestItems(ctx) {
+			if (options.testItems) return await options.testItems(ctx);
+			return [];
+		}
+	};
+	node({ name: options.key })(DefinedPollingTriggerRuntime);
+	return {
+		kind: "defined-polling-trigger",
+		key: options.key,
+		title: options.title,
+		description: options.description,
+		create(cfg, name = options.title, id) {
+			return new DefinedPollingTriggerConfig(name, cfg, DefinedPollingTriggerRuntime, options.icon, credentialRequirements, id);
+		},
+		poll(pollCtx) {
+			return options.poll({
+				config: pollCtx.config,
+				state: pollCtx.state,
+				credentials: pollCtx.credentials ?? {}
+			});
+		},
+		register(context) {
+			context.registerNode(DefinedPollingTriggerRuntime);
+		}
+	};
+}
 
 //#endregion
 //#region src/ai/AgentToolFactory.ts
@@ -489,103 +699,6 @@ const AgentGuardrailDefaults = {
 	onTurnLimitReached: "error"
 };
 
-//#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/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/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/EventPublishingWorkflowExecutionRepository.ts
 var EventPublishingWorkflowExecutionRepository = class {
@@ -640,10 +753,10 @@ var EventPublishingWorkflowExecutionRepository = class {
 //#endregion
 //#region \0@oxc-project+runtime@0.95.0/helpers/decorate.js
 function __decorate(decorators, target, key, desc) {
-	var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+	var c$1 = arguments.length, r = c$1 < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
 	if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-	else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-	return c > 3 && r && Object.defineProperty(target, key, r), r;
+	else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c$1 < 3 ? d(r) : c$1 > 3 ? d(target, key, r) : d(target, key)) || r;
+	return c$1 > 3 && r && Object.defineProperty(target, key, r), r;
 }
 
 //#endregion
@@ -670,5 +783,25 @@ let ItemsInputNormalizer = class ItemsInputNormalizer$1 {
 ItemsInputNormalizer = __decorate([injectable()], ItemsInputNormalizer);
 
 //#endregion
-export { AgentConfigInspector, AgentConnectionNodeCollector, AgentGuardrailDefaults, AgentMessageConfigNormalizer, AgentToolFactory, AllWorkflowsActiveWorkflowActivationPolicy, CallableToolConfig, CallableToolFactory, CallableToolKindToken, ChainCursor, CodemationTelemetryAttributeNames, CodemationTelemetryMetricNames, ConnectionInvocationIdFactory, ConnectionNodeIdFactory, CoreTokens, CostTrackingTelemetryAttributeNames, CostTrackingTelemetryMetricNames, CredentialResolverFactory, CredentialUnboundError, DefaultAsyncSleeper, DefaultExecutionBinaryService, DefaultExecutionContextFactory, DefaultWorkflowGraphFactory, DefinedNodeRegistry, EngineExecutionLimitsPolicy, EventPublishingWorkflowExecutionRepository, ExpRetryPolicy, GenAiTelemetryAttributeNames, InMemoryBinaryStorage, InMemoryLiveWorkflowRepository, InMemoryRunDataFactory, InMemoryRunEventBus, InProcessRetryRunner, InjectableRuntimeDecoratorComposer, ItemExprResolver, ItemsInputNormalizer, NoOpCostTrackingTelemetry, NoOpCostTrackingTelemetryFactory, NoOpExecutionTelemetry, NoOpExecutionTelemetryFactory, NoOpNodeExecutionTelemetry, NoOpTelemetryArtifactReference, NoOpTelemetrySpanScope, NoRetryPolicy, NodeBackedToolConfig, NodeEventPublisher, NodeOutputNormalizer, PersistedRuntimeTypeMetadataStore, PersistedRuntimeTypeNameResolver, RetryPolicy, RunFinishedAtFactory, RunIntentService, RunnableOutputBehaviorResolver, StackTraceCallSitePathResolver, SystemClock, UnavailableBinaryStorage, WhenBuilder, WorkflowBuilder, WorkflowExecutableNodeClassifier, WorkflowExecutableNodeClassifierFactory, branchRef, callableTool, chatModel, container, defineBatchNode, defineCredential, defineNode, delay, emitPorts, getOriginIndexFromItem, getPersistedRuntimeTypeMetadata, inject, injectAll, injectable, instanceCachingFactory, instancePerContainerCachingFactory, isItemExpr, isPortsEmission, isUnbrandedPortsEmissionShape, itemExpr, node, nodeRef, predicateAwareClassFactory, registry, resolveItemExprsForExecution, resolveItemExprsInUnknown, singleton, tool };
+//#region src/contracts/assertionTypes.ts
+/**
+* Default {@link AssertionResult.passThreshold} when authors omit it. Boolean-style assertions
+* (assertEqual / contains / etc.) emit `score: 1` or `score: 0` so this default works for them;
+* AI-judge assertions are expected to set their own threshold.
+*/
+const DEFAULT_ASSERTION_PASS_THRESHOLD = .5;
+/**
+* Derive whether an assertion result is considered "passing" using the score-based contract:
+* `errored` always fails, otherwise `score >= (passThreshold ?? 0.5)`. This is the canonical
+* derivation — UI and rollup code should call it rather than inlining the comparison so future
+* tweaks (e.g. NaN handling) land in one place.
+*/
+function deriveAssertionPassed(result) {
+	if (result.errored === true) return false;
+	const threshold = result.passThreshold ?? DEFAULT_ASSERTION_PASS_THRESHOLD;
+	return result.score >= threshold;
+}
+
+//#endregion
+export { AgentConfigInspector, AgentConnectionNodeCollector, AgentGuardrailDefaults, AgentMessageConfigNormalizer, AgentToolFactory, AllWorkflowsActiveWorkflowActivationPolicy, CallableToolConfig, CallableToolFactory, CallableToolKindToken, ChainCursor, ChildExecutionScopeFactory, CodemationTelemetryAttributeNames, CodemationTelemetryMetricNames, ConnectionInvocationEventPublisher, ConnectionInvocationIdFactory, ConnectionNodeIdFactory, CoreTokens, CostTrackingTelemetryAttributeNames, CostTrackingTelemetryMetricNames, CredentialResolverFactory, CredentialUnboundError, DEFAULT_ASSERTION_PASS_THRESHOLD, DefaultAsyncSleeper, DefaultExecutionBinaryService, DefaultExecutionContextFactory, DefaultWorkflowGraphFactory, DefinedCollectionRegistry, DefinedNodeRegistry, DefinedPollingTriggerConfig, EngineExecutionLimitsPolicy, EventPublishingWorkflowExecutionRepository, ExpRetryPolicy, GenAiTelemetryAttributeNames, InMemoryBinaryStorage, InMemoryLiveWorkflowRepository, InMemoryRunDataFactory, InMemoryRunEventBus, InProcessRetryRunner, InjectableRuntimeDecoratorComposer, ItemExprResolver, ItemsInputNormalizer, NoOpCostTrackingTelemetry, NoOpCostTrackingTelemetryFactory, NoOpExecutionTelemetry, NoOpExecutionTelemetryFactory, NoOpNodeExecutionTelemetry, NoOpPollingTriggerLogger, NoOpTelemetryArtifactReference, NoOpTelemetrySpanScope, NoRetryPolicy, NodeBackedToolConfig, NodeEventPublisher, NodeIdSlugifier, NodeIterationIdFactory, NodeOutputNormalizer, PersistedRuntimeTypeMetadataStore, PersistedRuntimeTypeNameResolver, PollingTriggerDedupWindow, PollingTriggerRuntime, RetryPolicy, RunFinishedAtFactory, RunIntentService, RunnableOutputBehaviorResolver, StackTraceCallSitePathResolver, SystemClock, UnavailableBinaryStorage, WhenBuilder, WorkflowBuilder, WorkflowDefinitionError, WorkflowExecutableNodeClassifier, WorkflowExecutableNodeClassifierFactory, branchRef, c, callableTool, chatModel, container, defineBatchNode, defineCollection, defineCredential, defineNode, definePollingTrigger, delay, deriveAssertionPassed, emitPorts, getOriginIndexFromItem, getPersistedRuntimeTypeMetadata, inject, injectAll, injectable, instanceCachingFactory, instancePerContainerCachingFactory, isItemExpr, isPortsEmission, isUnbrandedPortsEmissionShape, itemExpr, node, nodeRef, predicateAwareClassFactory, registry, resolveItemExprsForExecution, resolveItemExprsInUnknown, singleton, tool };
 //# sourceMappingURL=index.js.map