@codemation/core 0.11.0 → 0.12.0

package/dist/di-tO6R7VJV.cjs

@@ -0,0 +1,524 @@
+//#region rolldown:runtime
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+require("reflect-metadata");
+let tsyringe = require("tsyringe");
+tsyringe = __toESM(tsyringe);
+
+//#region src/workflow/definition/ConnectionNodeIdFactory.ts
+/**
+* Deterministic ids for workflow connection-owned child nodes (LLM slot, tools, etc.).
+* These are stable across loads.
+*/
+var ConnectionNodeIdFactory = class {
+	static connectionSegment = "__conn__";
+	static languageModelConnectionNodeId(parentNodeId) {
+		return `${parentNodeId}${this.connectionSegment}llm`;
+	}
+	static toolConnectionNodeId(parentNodeId, toolName) {
+		const normalized = this.normalizeToolName(toolName);
+		return `${parentNodeId}${this.connectionSegment}tool${this.connectionSegment}${normalized}`;
+	}
+	static mcpConnectionNodeId(parentNodeId, serverId) {
+		return `${parentNodeId}${this.connectionSegment}mcp${this.connectionSegment}${serverId}`;
+	}
+	static isMcpConnectionNodeId(nodeId) {
+		return nodeId.includes(`${this.connectionSegment}mcp${this.connectionSegment}`);
+	}
+	static parseMcpConnectionNodeId(nodeId) {
+		if (!this.isMcpConnectionNodeId(nodeId)) return;
+		const marker = `${this.connectionSegment}mcp${this.connectionSegment}`;
+		const idx = nodeId.lastIndexOf(marker);
+		if (idx < 0) return;
+		const parentNodeId = nodeId.slice(0, idx);
+		const serverId = nodeId.slice(idx + marker.length);
+		if (!parentNodeId || !serverId) return;
+		return {
+			parentNodeId,
+			serverId
+		};
+	}
+	static isLanguageModelConnectionNodeId(nodeId) {
+		return nodeId.endsWith(`${this.connectionSegment}llm`);
+	}
+	static isToolConnectionNodeId(nodeId) {
+		return nodeId.includes(`${this.connectionSegment}tool${this.connectionSegment}`);
+	}
+	static parseLanguageModelConnectionNodeId(nodeId) {
+		if (!this.isLanguageModelConnectionNodeId(nodeId)) return;
+		const suffix = `${this.connectionSegment}llm`;
+		const parentNodeId = nodeId.slice(0, -suffix.length);
+		return parentNodeId ? { parentNodeId } : void 0;
+	}
+	static parseToolConnectionNodeId(nodeId) {
+		if (!this.isToolConnectionNodeId(nodeId)) return;
+		const marker = `${this.connectionSegment}tool${this.connectionSegment}`;
+		const idx = nodeId.lastIndexOf(marker);
+		if (idx < 0) return;
+		const parentNodeId = nodeId.slice(0, idx);
+		const normalizedToolName = nodeId.slice(idx + marker.length);
+		if (!parentNodeId || !normalizedToolName) return;
+		return {
+			parentNodeId,
+			normalizedToolName
+		};
+	}
+	/** True when `nodeId` is a connection-owned child of `parentNodeId` (LLM or tool slot). */
+	static isConnectionOwnedDescendantOf(parentNodeId, nodeId) {
+		return nodeId.startsWith(`${parentNodeId}${this.connectionSegment}`);
+	}
+	/** Normalizes a tool display name to a stable id segment. */
+	static normalizeToolName(toolName) {
+		return toolName.trim().toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "") || "tool";
+	}
+};
+
+//#endregion
+//#region src/contracts/itemExpr.ts
+const ITEM_EXPR_BRAND = Symbol.for("codemation.itemExpr");
+function itemExpr(fn) {
+	return {
+		[ITEM_EXPR_BRAND]: true,
+		fn
+	};
+}
+function isItemExpr(value) {
+	if (typeof value !== "object" || value === null) return false;
+	const v = value;
+	if (v[ITEM_EXPR_BRAND] === true) return true;
+	const keys = Object.keys(v);
+	if (keys.length === 1 && keys[0] === "fn" && typeof v.fn === "function") return true;
+	for (const sym of Object.getOwnPropertySymbols(v)) if (sym.description === "codemation.itemExpr" && v[sym] === true) return true;
+	return false;
+}
+function containsItemExprInUnknown(value, seen = /* @__PURE__ */ new WeakSet()) {
+	if (isItemExpr(value)) return true;
+	if (value === null || typeof value !== "object") return false;
+	if (seen.has(value)) return false;
+	seen.add(value);
+	if (Array.isArray(value)) return value.some((entry) => containsItemExprInUnknown(entry, seen));
+	for (const entry of Object.values(value)) if (containsItemExprInUnknown(entry, seen)) return true;
+	return false;
+}
+/**
+* Deep-resolves {@link itemExpr} leaves. Returns a new graph (does not mutate the original config object).
+*/
+async function resolveItemExprsInUnknown(value, args, seen = /* @__PURE__ */ new WeakSet()) {
+	if (isItemExpr(value)) return await Promise.resolve(value.fn(args));
+	if (value === null || typeof value !== "object") return value;
+	if (seen.has(value)) return value;
+	seen.add(value);
+	if (Array.isArray(value)) {
+		const out$1 = [];
+		for (let i = 0; i < value.length; i++) out$1.push(await resolveItemExprsInUnknown(value[i], args, seen));
+		return out$1;
+	}
+	const rec = value;
+	const entries = Object.entries(rec);
+	const proto = Object.getPrototypeOf(value);
+	if (proto !== Object.prototype && proto !== null && entries.length === 0) return value;
+	const out = Object.create(proto);
+	for (const [k, v] of entries) out[k] = await resolveItemExprsInUnknown(v, args, seen);
+	return out;
+}
+/**
+* Clones runnable config (best-effort) so per-item {@link itemExpr} resolution never mutates shared instances.
+*/
+async function resolveItemExprsForExecution(config, nodeCtx, item, itemIndex, items) {
+	const exprArgs = {
+		item,
+		itemIndex,
+		items,
+		ctx: {
+			runId: nodeCtx.runId,
+			workflowId: nodeCtx.workflowId,
+			nodeId: nodeCtx.nodeId,
+			activationId: nodeCtx.activationId,
+			data: nodeCtx.data
+		}
+	};
+	if (!containsItemExprInUnknown(config)) return;
+	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/ai/NodeBackedToolConfig.ts
+var NodeBackedToolConfig = class {
+	type;
+	toolKind = "nodeBacked";
+	description;
+	presentation;
+	inputSchemaValue;
+	outputSchemaValue;
+	mapInputValue;
+	mapOutputValue;
+	constructor(name, node, options) {
+		this.name = name;
+		this.node = node;
+		this.type = node.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/ai/AgentConnectionNodeCollector.ts
+const AgentConnectionNodeCollector = new class {
+	collect(parentNodeId, agentConfig, mcpServerResolver) {
+		const collected = [];
+		this.collectInto(parentNodeId, agentConfig, collected, mcpServerResolver);
+		return collected;
+	}
+	collectInto(parentNodeId, agentConfig, collected, mcpServerResolver) {
+		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 of agentConfig.tools ?? []) {
+			const toolNodeId = ConnectionNodeIdFactory.toolConnectionNodeId(parentNodeId, tool.name);
+			const isNestedAgent = this.isNodeBackedAgentTool(tool);
+			collected.push({
+				nodeId: toolNodeId,
+				parentNodeId,
+				connectionName: "tools",
+				role: isNestedAgent ? "nestedAgent" : "tool",
+				name: tool.presentation?.label ?? tool.name,
+				typeName: tool.name,
+				icon: tool.presentation?.icon,
+				credentialSource: tool
+			});
+			this.collectNestedAgentTools(toolNodeId, tool, collected, mcpServerResolver);
+		}
+		if (mcpServerResolver) {
+			const mcpServers = agentConfig.mcpServers;
+			for (const serverId of mcpServers ?? []) {
+				const decl = mcpServerResolver(serverId);
+				if (!decl) continue;
+				const acceptedTypes = decl.acceptedCredentialTypes ?? [];
+				collected.push({
+					nodeId: ConnectionNodeIdFactory.mcpConnectionNodeId(parentNodeId, serverId),
+					parentNodeId,
+					connectionName: "tools",
+					role: "tool",
+					name: decl.displayName,
+					typeName: "MCP server",
+					icon: "lucide:plug",
+					credentialSource: { getCredentialRequirements: () => [{
+						slotKey: "credential",
+						label: decl.displayName,
+						acceptedTypes
+					}] }
+				});
+			}
+		}
+	}
+	collectNestedAgentTools(toolNodeId, tool, collected, mcpServerResolver) {
+		if (!this.isNodeBackedAgentTool(tool)) return;
+		const innerAgent = tool instanceof NodeBackedToolConfig ? tool.node : tool.node;
+		this.collectInto(toolNodeId, innerAgent, collected, mcpServerResolver);
+	}
+	/**
+	* After JSON round-trip (persisted snapshots), tools are plain objects — `instanceof NodeBackedToolConfig` fails.
+	* Detect node-backed tools structurally via {@link NodeBackedToolConfig#toolKind}.
+	*/
+	isNodeBackedAgentTool(tool) {
+		if (tool instanceof NodeBackedToolConfig) return AgentConfigInspector.isAgentNodeConfig(tool.node);
+		if (!tool || typeof tool !== "object") return false;
+		const t = tool;
+		if (t.toolKind !== "nodeBacked") return false;
+		return AgentConfigInspector.isAgentNodeConfig(t.node);
+	}
+}();
+
+//#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.
+*
+* Uses Web Crypto's `randomUUID` (Node 19+ and all modern browsers) so this module is safe
+* to include in the browser entry. Importing `node:crypto` here previously leaked into the
+* canvas client bundle through `browser.ts` and OOM'd consumers' Turbopack builds.
+*/
+var NodeIterationIdFactory = class {
+	static create() {
+		return `iter_${globalThis.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/contracts/credentialTypes.ts
+var CredentialUnboundError = class CredentialUnboundError extends Error {
+	constructor(bindingKey, acceptedTypes = []) {
+		super(CredentialUnboundError.createMessage(bindingKey, acceptedTypes));
+		this.bindingKey = bindingKey;
+		this.acceptedTypes = acceptedTypes;
+		this.name = "CredentialUnboundError";
+	}
+	static createMessage(bindingKey, acceptedTypes) {
+		const acceptedTypesSuffix = acceptedTypes.length > 0 ? ` Accepted credential types: ${acceptedTypes.join(", ")}.` : "";
+		return `Credential slot "${bindingKey.slotKey}" is not bound for workflow ${bindingKey.workflowId} node ${bindingKey.nodeId}.${acceptedTypesSuffix}`;
+	}
+};
+
+//#endregion
+//#region src/contracts/runtimeTypes.ts
+/**
+* Thrown by a node's `execute()` to request durable suspension of the current item.
+* The engine catches this, persists the suspension entry, calls `deliver`, and
+* continues to the next item (per-item semantics).
+*
+* @example
+* ```ts
+* throw new SuspensionRequest({
+*   decisionSchema: z.object({ approved: z.boolean() }),
+*   timeout: "PT24H",
+*   onTimeout: "halt",
+*   subject: { title: "Approve invoice", summary: "Invoice #1234 needs approval" },
+*   deliver: async (handle) => {
+*     await notifySlack(handle);
+*     return { channel: "slack", ts: "..." };
+*   },
+* });
+* ```
+*/
+var SuspensionRequest = class extends Error {
+	constructor(request) {
+		super(`SuspensionRequest(${request.subject?.title ?? "untitled"})`);
+		this.request = request;
+		this.name = "SuspensionRequest";
+	}
+};
+
+//#endregion
+//#region src/contracts/runFinishedAtFactory.ts
+/** Derives workflow end time from persisted run root or node snapshots for run listings. */
+var RunFinishedAtFactory = class {
+	static resolveIso(state) {
+		if (state.finishedAt && state.status !== "running" && state.status !== "pending") return state.finishedAt;
+		if (state.status === "running" || state.status === "pending") return;
+		let max;
+		for (const snap of Object.values(state.nodeSnapshotsByNodeId)) if (snap?.finishedAt && (!max || snap.finishedAt > max)) max = snap.finishedAt;
+		return max;
+	}
+};
+
+//#endregion
+//#region src/contracts/workflowTypes.ts
+function nodeRef(nodeId) {
+	return nodeId;
+}
+const branchRef = (index) => `$${index}`;
+
+//#endregion
+//#region src/di/CoreTokens.ts
+const CoreTokens = {
+	PersistedWorkflowTokenRegistry: Symbol.for("codemation.core.PersistedWorkflowTokenRegistry"),
+	CredentialSessionService: Symbol.for("codemation.core.CredentialSessionService"),
+	CredentialTypeRegistry: Symbol.for("codemation.core.CredentialTypeRegistry"),
+	WorkflowRunnerService: Symbol.for("codemation.core.WorkflowRunnerService"),
+	LiveWorkflowRepository: Symbol.for("codemation.core.LiveWorkflowRepository"),
+	WorkflowRepository: Symbol.for("codemation.core.WorkflowRepository"),
+	NodeResolver: Symbol.for("codemation.core.NodeResolver"),
+	WorkflowNodeInstanceFactory: Symbol.for("codemation.core.WorkflowNodeInstanceFactory"),
+	RunIdFactory: Symbol.for("codemation.core.RunIdFactory"),
+	ActivationIdFactory: Symbol.for("codemation.core.ActivationIdFactory"),
+	WorkflowExecutionRepository: Symbol.for("codemation.core.WorkflowExecutionRepository"),
+	TriggerSetupStateRepository: Symbol.for("codemation.core.TriggerSetupStateRepository"),
+	NodeActivationScheduler: Symbol.for("codemation.core.NodeActivationScheduler"),
+	RunDataFactory: Symbol.for("codemation.core.RunDataFactory"),
+	ExecutionContextFactory: Symbol.for("codemation.core.ExecutionContextFactory"),
+	RunEventBus: Symbol.for("codemation.core.RunEventBus"),
+	BinaryStorage: Symbol.for("codemation.core.BinaryStorage"),
+	WebhookBasePath: Symbol.for("codemation.core.WebhookBasePath"),
+	EngineExecutionLimitsPolicy: Symbol.for("codemation.core.EngineExecutionLimitsPolicy"),
+	WorkflowActivationPolicy: Symbol.for("codemation.core.WorkflowActivationPolicy"),
+	AgentMcpIntegration: Symbol.for("codemation.core.AgentMcpIntegration")
+};
+
+//#endregion
+Object.defineProperty(exports, 'AgentConfigInspector', {
+  enumerable: true,
+  get: function () {
+    return AgentConfigInspector;
+  }
+});
+Object.defineProperty(exports, 'AgentConnectionNodeCollector', {
+  enumerable: true,
+  get: function () {
+    return AgentConnectionNodeCollector;
+  }
+});
+Object.defineProperty(exports, 'ConnectionNodeIdFactory', {
+  enumerable: true,
+  get: function () {
+    return ConnectionNodeIdFactory;
+  }
+});
+Object.defineProperty(exports, 'CoreTokens', {
+  enumerable: true,
+  get: function () {
+    return CoreTokens;
+  }
+});
+Object.defineProperty(exports, 'CredentialUnboundError', {
+  enumerable: true,
+  get: function () {
+    return CredentialUnboundError;
+  }
+});
+Object.defineProperty(exports, 'NodeBackedToolConfig', {
+  enumerable: true,
+  get: function () {
+    return NodeBackedToolConfig;
+  }
+});
+Object.defineProperty(exports, 'NodeIterationIdFactory', {
+  enumerable: true,
+  get: function () {
+    return NodeIterationIdFactory;
+  }
+});
+Object.defineProperty(exports, 'RunFinishedAtFactory', {
+  enumerable: true,
+  get: function () {
+    return RunFinishedAtFactory;
+  }
+});
+Object.defineProperty(exports, 'SuspensionRequest', {
+  enumerable: true,
+  get: function () {
+    return SuspensionRequest;
+  }
+});
+Object.defineProperty(exports, '__toESM', {
+  enumerable: true,
+  get: function () {
+    return __toESM;
+  }
+});
+Object.defineProperty(exports, 'branchRef', {
+  enumerable: true,
+  get: function () {
+    return branchRef;
+  }
+});
+Object.defineProperty(exports, 'isItemExpr', {
+  enumerable: true,
+  get: function () {
+    return isItemExpr;
+  }
+});
+Object.defineProperty(exports, 'itemExpr', {
+  enumerable: true,
+  get: function () {
+    return itemExpr;
+  }
+});
+Object.defineProperty(exports, 'nodeRef', {
+  enumerable: true,
+  get: function () {
+    return nodeRef;
+  }
+});
+Object.defineProperty(exports, 'resolveItemExprsForExecution', {
+  enumerable: true,
+  get: function () {
+    return resolveItemExprsForExecution;
+  }
+});
+Object.defineProperty(exports, 'resolveItemExprsInUnknown', {
+  enumerable: true,
+  get: function () {
+    return resolveItemExprsInUnknown;
+  }
+});
+//# sourceMappingURL=di-tO6R7VJV.cjs.map