@codemation/core 0.10.1 → 0.11.0

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

@@ -26,10 +26,10 @@ let tsyringe = require("tsyringe");
 tsyringe = __toESM(tsyringe);
 let zod = require("zod");
 zod = __toESM(zod);
-let node_crypto = require("node:crypto");
-node_crypto = __toESM(node_crypto);
 let node_stream_web = require("node:stream/web");
 node_stream_web = __toESM(node_stream_web);
+let node_crypto = require("node:crypto");
+node_crypto = __toESM(node_crypto);
 
 //#region src/di/CoreTokens.ts
 const CoreTokens = {
@@ -52,7 +52,8 @@ const CoreTokens = {
 	BinaryStorage: Symbol.for("codemation.core.BinaryStorage"),
 	WebhookBasePath: Symbol.for("codemation.core.WebhookBasePath"),
 	EngineExecutionLimitsPolicy: Symbol.for("codemation.core.EngineExecutionLimitsPolicy"),
-	WorkflowActivationPolicy: Symbol.for("codemation.core.WorkflowActivationPolicy")
+	WorkflowActivationPolicy: Symbol.for("codemation.core.WorkflowActivationPolicy"),
+	AgentMcpIntegration: Symbol.for("codemation.core.AgentMcpIntegration")
 };
 
 //#endregion
@@ -318,6 +319,25 @@ var ConnectionNodeIdFactory = class {
 		const normalized = this.normalizeToolName(toolName);
 		return `${parentNodeId}${this.connectionSegment}tool${this.connectionSegment}${normalized}`;
 	}
+	static mcpConnectionNodeId(parentNodeId, serverId) {
+		return `${parentNodeId}${this.connectionSegment}mcp${this.connectionSegment}${serverId}`;
+	}
+	static isMcpConnectionNodeId(nodeId) {
+		return nodeId.includes(`${this.connectionSegment}mcp${this.connectionSegment}`);
+	}
+	static parseMcpConnectionNodeId(nodeId) {
+		if (!this.isMcpConnectionNodeId(nodeId)) return;
+		const marker = `${this.connectionSegment}mcp${this.connectionSegment}`;
+		const idx = nodeId.lastIndexOf(marker);
+		if (idx < 0) return;
+		const parentNodeId = nodeId.slice(0, idx);
+		const serverId = nodeId.slice(idx + marker.length);
+		if (!parentNodeId || !serverId) return;
+		return {
+			parentNodeId,
+			serverId
+		};
+	}
 	static isLanguageModelConnectionNodeId(nodeId) {
 		return nodeId.endsWith(`${this.connectionSegment}llm`);
 	}
@@ -356,12 +376,12 @@ var ConnectionNodeIdFactory = class {
 //#endregion
 //#region src/ai/AgentConnectionNodeCollector.ts
 const AgentConnectionNodeCollector = new class {
-	collect(parentNodeId, agentConfig) {
+	collect(parentNodeId, agentConfig, mcpServerResolver) {
 		const collected = [];
-		this.collectInto(parentNodeId, agentConfig, collected);
+		this.collectInto(parentNodeId, agentConfig, collected, mcpServerResolver);
 		return collected;
 	}
-	collectInto(parentNodeId, agentConfig, collected) {
+	collectInto(parentNodeId, agentConfig, collected, mcpServerResolver) {
 		collected.push({
 			nodeId: ConnectionNodeIdFactory.languageModelConnectionNodeId(parentNodeId),
 			parentNodeId,
@@ -385,13 +405,35 @@ const AgentConnectionNodeCollector = new class {
 				icon: tool$1.presentation?.icon,
 				credentialSource: tool$1
 			});
-			this.collectNestedAgentTools(toolNodeId, tool$1, collected);
+			this.collectNestedAgentTools(toolNodeId, tool$1, collected, mcpServerResolver);
+		}
+		if (mcpServerResolver) {
+			const mcpServers = agentConfig.mcpServers;
+			for (const serverId of mcpServers ?? []) {
+				const decl = mcpServerResolver(serverId);
+				if (!decl) continue;
+				const acceptedTypes = decl.acceptedCredentialTypes ?? [];
+				collected.push({
+					nodeId: ConnectionNodeIdFactory.mcpConnectionNodeId(parentNodeId, serverId),
+					parentNodeId,
+					connectionName: "tools",
+					role: "tool",
+					name: decl.displayName,
+					typeName: serverId,
+					icon: "lucide:plug",
+					credentialSource: { getCredentialRequirements: () => [{
+						slotKey: "credential",
+						label: decl.displayName,
+						acceptedTypes
+					}] }
+				});
+			}
 		}
 	}
-	collectNestedAgentTools(toolNodeId, tool$1, collected) {
+	collectNestedAgentTools(toolNodeId, tool$1, collected, mcpServerResolver) {
 		if (!this.isNodeBackedAgentTool(tool$1)) return;
 		const innerAgent = tool$1 instanceof NodeBackedToolConfig ? tool$1.node : tool$1.node;
-		this.collectInto(toolNodeId, innerAgent, collected);
+		this.collectInto(toolNodeId, innerAgent, collected, mcpServerResolver);
 	}
 	/**
 	* After JSON round-trip (persisted snapshots), tools are plain objects — `instanceof NodeBackedToolConfig` fails.
@@ -682,10 +724,13 @@ var WorkflowBuilder = class {
 //#region src/workflow/definition/ConnectionInvocationIdFactory.ts
 /**
 * Unique ids for persisted connection invocation history rows (LLM/tool calls under an owning node).
+*
+* Uses Web Crypto's `randomUUID` so this module is safe in browser-bundle contexts —
+* paired with `NodeIterationIdFactory` which had the same `node:crypto` regression.
 */
 var ConnectionInvocationIdFactory = class {
 	static create() {
-		return `cinv_${(0, node_crypto.randomUUID)()}`;
+		return `cinv_${globalThis.crypto.randomUUID()}`;
 	}
 	/** Deterministic id for tests when a stable sequence is needed. */
 	static createForTest(runId, connectionNodeId, sequence) {
@@ -701,10 +746,14 @@ var ConnectionInvocationIdFactory = class {
 * Activations are per-batch (one scheduled execution of a node, possibly with N items).
 * Iterations refine that to one identifier per item-index inside the batch loop, so per-item
 * connection invocations and telemetry can be grouped without time-window heuristics.
+*
+* Uses Web Crypto's `randomUUID` (Node 19+ and all modern browsers) so this module is safe
+* to include in the browser entry. Importing `node:crypto` here previously leaked into the
+* canvas client bundle through `browser.ts` and OOM'd consumers' Turbopack builds.
 */
 var NodeIterationIdFactory = class {
 	static create() {
-		return `iter_${(0, node_crypto.randomUUID)()}`;
+		return `iter_${globalThis.crypto.randomUUID()}`;
 	}
 	/** Deterministic id for tests when a stable sequence is needed. */
 	static createForTest(seed, sequence) {
@@ -954,6 +1003,10 @@ var UnavailableBinaryStorage = class {
 		return { exists: false };
 	}
 	async delete() {}
+	async deleteMany() {}
+	async listByPrefix() {
+		return [];
+	}
 };
 
 //#endregion
@@ -1022,7 +1075,8 @@ var NodeExecutionSnapshotFactory = class {
 			inputsByPort: args.inputsByPort,
 			outputs: args.outputs,
 			usedPinnedOutput: fromPinnedOutput,
-			error: void 0
+			error: void 0,
+			...args.previous?.childRunId !== void 0 ? { childRunId: args.previous.childRunId } : {}
 		};
 	}
 	static skipped(args) {
@@ -1039,7 +1093,8 @@ var NodeExecutionSnapshotFactory = class {
 			updatedAt: args.finishedAt,
 			inputsByPort: args.inputsByPort,
 			outputs: args.outputs,
-			error: void 0
+			error: void 0,
+			...args.previous?.childRunId !== void 0 ? { childRunId: args.previous.childRunId } : {}
 		};
 	}
 	static failed(args) {
@@ -1061,7 +1116,8 @@ var NodeExecutionSnapshotFactory = class {
 				name: args.error.name,
 				stack: args.error.stack,
 				details: args.error.details
-			}
+			},
+			...args.previous?.childRunId !== void 0 ? { childRunId: args.previous.childRunId } : {}
 		};
 	}
 };
@@ -1390,6 +1446,20 @@ var DefaultAsyncSleeper = class {
 	}
 };
 
+//#endregion
+//#region src/contracts/NoOpAgentMcpIntegration.ts
+/**
+* No-op implementation of AgentMcpIntegration.
+* Registered by the core engine runtime as a fallback when the host does not
+* supply a real implementation (e.g. in unit tests or headless engine setups).
+* Always returns an empty tool map so the agent runs with node-backed tools only.
+*/
+var NoOpAgentMcpIntegration = class {
+	async prepareMcpTools() {
+		return /* @__PURE__ */ new Map();
+	}
+};
+
 //#endregion
 //#region src/contracts/emitPorts.ts
 const EMIT_PORTS_BRAND = Symbol.for("codemation.emitPorts");
@@ -1629,6 +1699,10 @@ var CodemationTelemetryAttributeNames = class {
 	static iterationIndex = "codemation.iteration.index";
 	/** Set when this span/metric was recorded under a sub-agent triggered by an outer LLM/tool call. */
 	static parentInvocationId = "codemation.parent.invocation_id";
+	/** MCP server id on spans created for callTool invocations. */
+	static mcpServerId = "mcp.server_id";
+	/** MCP tool name on spans created for callTool invocations. */
+	static mcpToolName = "mcp.tool_name";
 };
 
 //#endregion
@@ -1844,18 +1918,21 @@ var CatalogBackedCostTrackingTelemetryFactory = class {
 
 //#endregion
 //#region src/execution/InProcessRetryRunner.ts
+/** Maximum permitted retry attempts — workflow-declared values above this are clamped. */
+const HARD_MAX_RETRY_ATTEMPTS = 10;
 var InProcessRetryRunner = class InProcessRetryRunner {
 	constructor(sleeper) {
 		this.sleeper = sleeper;
 	}
-	async run(policy, work) {
-		const spec = InProcessRetryRunner.normalizePolicy(policy);
+	async run(policy, work, shouldRetry, warn) {
+		const spec = InProcessRetryRunner.normalizePolicy(policy, warn);
 		let lastError;
 		for (let attempt = 1; attempt <= spec.maxAttempts; attempt++) try {
 			return await work();
 		} catch (error) {
 			lastError = error;
 			if (attempt >= spec.maxAttempts) break;
+			if (shouldRetry !== void 0 && !shouldRetry(error)) break;
 			const delayMs = InProcessRetryRunner.delayAfterFailureMs(spec, attempt);
 			await this.sleeper.sleep(delayMs);
 		}
@@ -1870,7 +1947,7 @@ var InProcessRetryRunner = class InProcessRetryRunner {
 		if (spec.maxDelayMs !== void 0 && ms > spec.maxDelayMs) ms = spec.maxDelayMs;
 		return Math.max(0, Math.floor(ms));
 	}
-	static normalizePolicy(policy) {
+	static normalizePolicy(policy, warn) {
 		if (policy === void 0) return {
 			kind: "none",
 			maxAttempts: 1
@@ -1886,17 +1963,19 @@ var InProcessRetryRunner = class InProcessRetryRunner {
 		};
 		if (kind === "fixed") {
 			const p = policy;
+			const raw = InProcessRetryRunner.assertPositiveInt(p.maxAttempts, "fixed.maxAttempts");
 			return {
 				kind: "fixed",
-				maxAttempts: InProcessRetryRunner.assertPositiveInt(p.maxAttempts, "fixed.maxAttempts"),
+				maxAttempts: InProcessRetryRunner.clampMaxAttempts(raw, warn),
 				delayMs: InProcessRetryRunner.assertNonNegativeFinite(p.delayMs, "fixed.delayMs")
 			};
 		}
 		if (kind === "exponential") {
 			const p = policy;
+			const raw = InProcessRetryRunner.assertPositiveInt(p.maxAttempts, "exponential.maxAttempts");
 			return {
 				kind: "exponential",
-				maxAttempts: InProcessRetryRunner.assertPositiveInt(p.maxAttempts, "exponential.maxAttempts"),
+				maxAttempts: InProcessRetryRunner.clampMaxAttempts(raw, warn),
 				initialDelayMs: InProcessRetryRunner.assertNonNegativeFinite(p.initialDelayMs, "exponential.initialDelayMs"),
 				multiplier: InProcessRetryRunner.assertMultiplier(p.multiplier),
 				maxDelayMs: p.maxDelayMs === void 0 ? void 0 : InProcessRetryRunner.assertNonNegativeFinite(p.maxDelayMs, "exponential.maxDelayMs"),
@@ -1908,6 +1987,13 @@ var InProcessRetryRunner = class InProcessRetryRunner {
 			maxAttempts: 1
 		};
 	}
+	static clampMaxAttempts(requested, warn) {
+		if (requested > HARD_MAX_RETRY_ATTEMPTS) {
+			warn?.(`Retry policy maxAttempts (${requested}) exceeds hard ceiling (${HARD_MAX_RETRY_ATTEMPTS}); clamping to ${HARD_MAX_RETRY_ATTEMPTS}.`);
+			return HARD_MAX_RETRY_ATTEMPTS;
+		}
+		return requested;
+	}
 	static assertPositiveInt(value, label) {
 		if (typeof value !== "number" || !Number.isFinite(value) || value < 1 || !Number.isInteger(value)) throw new Error(`Retry policy ${label} must be a positive integer`);
 		return value;
@@ -2110,12 +2196,24 @@ var NodeExecutor = class {
 		this.outputBehaviorResolver = outputBehaviorResolver ?? new RunnableOutputBehaviorResolver();
 	}
 	async execute(request) {
+		await this.assertRequiredCredentialsBound(request);
 		const policy = request.ctx.config.retryPolicy;
 		return await this.retryRunner.run(policy, async () => {
 			const nodeInstance = this.nodeInstanceFactory.createByType(request.ctx.config.type);
 			if (request.kind === "multi") return await this.executeMultiInputActivation(request, nodeInstance);
 			return await this.executeSingleInputNode(request, nodeInstance);
-		});
+		}, (error) => !this.isCredentialError(error));
+	}
+	async assertRequiredCredentialsBound(request) {
+		if (!request.ctx.getCredential) return;
+		for (const req of request.ctx.config.getCredentialRequirements?.() ?? []) {
+			if (req.optional) continue;
+			await request.ctx.getCredential(req.slotKey);
+		}
+	}
+	isCredentialError(e) {
+		if (e instanceof CredentialUnboundError) return true;
+		return (e instanceof Error ? e.cause : void 0) instanceof CredentialUnboundError;
 	}
 	async executeMultiInputActivation(request, node$1) {
 		const multiInputNode = node$1;
@@ -2425,16 +2523,20 @@ var WorkflowSnapshotCodec = class {
 			name: workflow.name,
 			workflowErrorHandlerConfigured: workflow.workflowErrorHandler !== void 0,
 			...workflow.connections !== void 0 && workflow.connections.length > 0 ? { connections: workflow.connections } : {},
-			nodes: workflow.nodes.map((node$1) => ({
-				id: node$1.id,
-				kind: node$1.kind,
-				name: node$1.name,
-				nodeTokenId: this.resolveTokenId(node$1.type),
-				configTokenId: this.resolveTokenId(node$1.config.type),
-				tokenName: this.resolveTokenName(node$1.type),
-				configTokenName: this.resolveTokenName(node$1.config.type),
-				config: this.serializeConfig(node$1.config)
-			})),
+			nodes: workflow.nodes.map((node$1) => {
+				const inspectorSummaryRows = this.safeInspectorSummary(node$1.config);
+				return {
+					id: node$1.id,
+					kind: node$1.kind,
+					name: node$1.name,
+					nodeTokenId: this.resolveTokenId(node$1.type),
+					configTokenId: this.resolveTokenId(node$1.config.type),
+					tokenName: this.resolveTokenName(node$1.type),
+					configTokenName: this.resolveTokenName(node$1.config.type),
+					config: this.serializeConfig(node$1.config),
+					...inspectorSummaryRows !== void 0 ? { inspectorSummary: inspectorSummaryRows } : {}
+				};
+			}),
 			edges: workflow.edges.map((edge) => ({
 				from: {
 					nodeId: edge.from.nodeId,
@@ -2474,6 +2576,34 @@ var WorkflowSnapshotCodec = class {
 			return fallback;
 		}
 	}
+	/**
+	* Safely call `config.inspectorSummary()` and return a plain JSON-safe array, or undefined.
+	* Returns undefined if the method is absent, throws, or produces no valid rows.
+	*/
+	safeInspectorSummary(config) {
+		const fn = config.inspectorSummary;
+		if (typeof fn !== "function") return void 0;
+		let raw;
+		try {
+			raw = fn.call(config);
+		} catch {
+			return;
+		}
+		if (!Array.isArray(raw)) return void 0;
+		const rows = [];
+		for (const entry of raw) {
+			if (!entry || typeof entry !== "object") continue;
+			const { label, value } = entry;
+			if (typeof label !== "string" || typeof value !== "string") continue;
+			const trimmedLabel = label.trim();
+			if (trimmedLabel.length === 0) continue;
+			rows.push({
+				label: trimmedLabel,
+				value
+			});
+		}
+		return rows.length > 0 ? rows : void 0;
+	}
 	injectTokenIds(target, source) {
 		const type = this.asTypeToken(source.type);
 		if (type) target.tokenId = this.tokenRegistry.getTokenId(type) ?? this.resolveTokenName(type) ?? "unknown";
@@ -2718,6 +2848,18 @@ var NodeRunStateWriter = class {
 			await this.publishNodeEvent("nodeFailed", snapshot);
 		});
 	}
+	setChildRunId(args) {
+		return this.enqueue(async () => {
+			const state = await this.loadState();
+			const previous = state.nodeSnapshotsByNodeId?.[args.nodeId];
+			if (!previous) return;
+			const updated = {
+				...previous,
+				childRunId: args.childRunId
+			};
+			await this.saveSnapshot(state, updated);
+		});
+	}
 	appendConnectionInvocation(args) {
 		return this.enqueue(async () => {
 			const state = await this.loadState();
@@ -2732,6 +2874,8 @@ var NodeRunStateWriter = class {
 				status: args.status,
 				managedInput: args.managedInput,
 				managedOutput: args.managedOutput,
+				statusLabel: args.statusLabel,
+				subjectName: args.subjectName,
 				error: args.error,
 				queuedAt: args.queuedAt,
 				startedAt: args.startedAt,
@@ -3094,7 +3238,7 @@ var RunContinuationService = class {
 		});
 		const completedActivations = (state.engineCounters?.completedNodeActivations ?? 0) + 1;
 		const engineCounters = { completedNodeActivations: completedActivations };
-		const maxNodeActivations = state.executionOptions?.maxNodeActivations ?? Number.MAX_SAFE_INTEGER;
+		const maxNodeActivations = state.executionOptions?.maxNodeActivations ?? this.executionLimitsPolicy.createRootExecutionOptions().maxNodeActivations;
 		if (this.semantics.isStopConditionSatisfied(state.control?.stopCondition, args.nodeId)) {
 			const completedState = this.persistedRunStateTerminalBuilder.mergeTerminal({
 				state,
@@ -3418,7 +3562,7 @@ var RunContinuationService = class {
 		});
 		const completedActivations = (args.state.engineCounters?.completedNodeActivations ?? 0) + 1;
 		const engineCounters = { completedNodeActivations: completedActivations };
-		const maxNodeActivations = args.state.executionOptions?.maxNodeActivations ?? Number.MAX_SAFE_INTEGER;
+		const maxNodeActivations = args.state.executionOptions?.maxNodeActivations ?? this.executionLimitsPolicy.createRootExecutionOptions().maxNodeActivations;
 		if (this.semantics.isStopConditionSatisfied(args.state.control?.stopCondition, args.args.nodeId)) {
 			const completedState = this.persistedRunStateTerminalBuilder.mergeTerminal({
 				state: args.state,
@@ -4647,25 +4791,24 @@ var InlineDrivingScheduler = class {
 		this.scheduledRuns.delete(runId);
 		try {
 			const q = this.queuesByRunId.get(runId) ?? [];
-			while (q.length > 0) {
-				const { request } = q.shift();
-				const cont = this.continuation;
-				if (!cont) throw new Error("InlineDrivingScheduler is missing a continuation (setContinuation was not called)");
-				await cont.markNodeRunning({
-					runId: request.runId,
-					activationId: request.activationId,
-					nodeId: request.nodeId,
-					inputsByPort: request.kind === "multi" ? request.inputsByPort : { in: request.input }
-				});
-				let outputs;
-				try {
-					outputs = await this.nodeExecutor.execute(request);
-				} catch (e) {
-					await this.resumeAfterExecutionError(cont, request, this.asError(e));
-					continue;
-				}
-				await this.resumeAfterExecutionResult(cont, request, outputs ?? {});
+			if (q.length === 0) return;
+			const { request } = q.shift();
+			const cont = this.continuation;
+			if (!cont) throw new Error("InlineDrivingScheduler is missing a continuation (setContinuation was not called)");
+			await cont.markNodeRunning({
+				runId: request.runId,
+				activationId: request.activationId,
+				nodeId: request.nodeId,
+				inputsByPort: request.kind === "multi" ? request.inputsByPort : { in: request.input }
+			});
+			let outputs;
+			try {
+				outputs = await this.nodeExecutor.execute(request);
+			} catch (e) {
+				await this.resumeAfterExecutionError(cont, request, this.asError(e));
+				return;
 			}
+			await this.resumeAfterExecutionResult(cont, request, outputs ?? {});
 		} finally {
 			if ((this.queuesByRunId.get(runId)?.length ?? 0) === 0) this.queuesByRunId.delete(runId);
 			this.drainingRuns.delete(runId);
@@ -4675,10 +4818,10 @@ var InlineDrivingScheduler = class {
 	scheduleDrain(runId) {
 		if (this.drainingRuns.has(runId) || this.scheduledRuns.has(runId)) return;
 		this.scheduledRuns.add(runId);
-		setTimeout(() => {
+		setImmediate(() => {
 			this.scheduledRuns.delete(runId);
 			this.drainRun(runId);
-		}, 0);
+		});
 	}
 	async resumeAfterExecutionResult(continuation, request, outputs) {
 		try {
@@ -4928,6 +5071,12 @@ var InMemoryBinaryStorage = class {
 	async delete(storageKey) {
 		this.values.delete(storageKey);
 	}
+	async deleteMany(storageKeys) {
+		for (const key of storageKeys) this.values.delete(key);
+	}
+	async listByPrefix(prefix) {
+		return Array.from(this.values.keys()).filter((key) => key.startsWith(prefix));
+	}
 };
 
 //#endregion
@@ -6402,6 +6551,12 @@ Object.defineProperty(exports, 'MissingRuntimeTriggerToken', {
     return MissingRuntimeTriggerToken;
   }
 });
+Object.defineProperty(exports, 'NoOpAgentMcpIntegration', {
+  enumerable: true,
+  get: function () {
+    return NoOpAgentMcpIntegration;
+  }
+});
 Object.defineProperty(exports, 'NoOpCostTrackingTelemetry', {
   enumerable: true,
   get: function () {
@@ -6750,4 +6905,4 @@ Object.defineProperty(exports, 'tool', {
     return tool;
   }
 });
-//# sourceMappingURL=runtime-DKXJwTNv.cjs.map
+//# sourceMappingURL=runtime-vH0EeZzH.cjs.map