@codemation/core-nodes 0.10.2 → 0.13.0

package/dist/index.cjs

@@ -25,14 +25,10 @@ let __codemation_core = require("@codemation/core");
 __codemation_core = __toESM(__codemation_core);
 let node_dns_promises = require("node:dns/promises");
 node_dns_promises = __toESM(node_dns_promises);
-let __ai_sdk_openai = require("@ai-sdk/openai");
-__ai_sdk_openai = __toESM(__ai_sdk_openai);
 let __codemation_core_bootstrap = require("@codemation/core/bootstrap");
 __codemation_core_bootstrap = __toESM(__codemation_core_bootstrap);
 let node_crypto = require("node:crypto");
 node_crypto = __toESM(node_crypto);
-let ai = require("ai");
-ai = __toESM(ai);
 let croner = require("croner");
 croner = __toESM(croner);
 
@@ -704,8 +700,9 @@ function __decorate(decorators, target, key, desc) {
 let OpenAIChatModelFactory = class OpenAIChatModelFactory$1 {
 	async create(args) {
 		const session = await args.ctx.getCredential(args.config.credentialSlotKey);
+		const { createOpenAI } = await import("@ai-sdk/openai");
 		return {
-			languageModel: (0, __ai_sdk_openai.createOpenAI)({
+			languageModel: createOpenAI({
 				apiKey: session.apiKey,
 				baseURL: session.baseUrl
 			}).chat(args.config.model),
@@ -4448,27 +4445,24 @@ function buildHmacAuthHeader(workspaceId, pairingSecret, method, url, body, over
 //#endregion
 //#region src/chatModels/CodemationChatModelFactory.ts
 let CodemationChatModelFactory = class CodemationChatModelFactory$1 {
-	create(args) {
+	async create(args) {
 		const gatewayUrl = process.env["LLM_GATEWAY_URL"];
 		if (!gatewayUrl) throw new Error("Codemation managed AI not available in this environment (LLM_GATEWAY_URL is not set).");
 		const workspaceId = process.env["WORKSPACE_ID"];
 		const pairingSecret = process.env["WORKSPACE_PAIRING_SECRET"];
 		if (!workspaceId || !pairingSecret) throw new Error("Codemation managed AI not available in this environment (workspace pairing is not configured).");
 		const hmacFetch = managedHmacFetchFactory(workspaceId, pairingSecret);
-		const languageModel = (0, __ai_sdk_openai.createOpenAI)({
-			baseURL: `${gatewayUrl}/v1`,
-			apiKey: "codemation-managed",
-			fetch: hmacFetch
-		}).chat(args.config.model);
-		return Promise.resolve({
-			languageModel,
-			modelName: args.config.model,
+		const { createAnthropic } = await import("@ai-sdk/anthropic");
+		return {
+			languageModel: createAnthropic({
+				baseURL: `${gatewayUrl}/v1`,
+				apiKey: "codemation-managed",
+				fetch: hmacFetch
+			})(args.config.complexity),
+			modelName: args.config.complexity,
 			provider: "codemation-managed",
-			defaultCallOptions: {
-				maxOutputTokens: args.config.options?.maxTokens,
-				temperature: args.config.options?.temperature
-			}
-		});
+			defaultCallOptions: { maxOutputTokens: args.config.options?.maxTokens }
+		};
 	}
 };
 CodemationChatModelFactory = __decorate([(0, __codemation_core.chatModel)({ packageName: "@codemation/core-nodes" })], CodemationChatModelFactory);
@@ -4480,11 +4474,11 @@ var CodemationChatModelConfig = class {
 	presentation;
 	provider = "codemation-managed";
 	modelName;
-	constructor(name, model, presentationIn, options) {
+	constructor(name, complexity, presentationIn, options) {
 		this.name = name;
-		this.model = model;
+		this.complexity = complexity;
 		this.options = options;
-		this.modelName = model;
+		this.modelName = complexity;
 		this.presentation = presentationIn ?? {
 			icon: "lucide:bot",
 			label: name
@@ -4493,24 +4487,151 @@ var CodemationChatModelConfig = class {
 };
 
 //#endregion
-//#region src/chatModels/ManagedModelFetcher.ts
+//#region src/nodes/AgentToolResultContentFactory.ts
 /**
-* Fetches the active platform-managed model allowlist from the CP.
-* Reads CONTROL_PLANE_URL from the workspace process env.
-* Returns an empty array if the env var is absent or the fetch fails.
-* Cache the result per session — the allowlist changes infrequently.
+* Cap on raw (pre-base64) bytes inlined from a single tool result. Base64 inflates ~33% and every
+* inlined byte eats model context, so oversize binaries are replaced with a text placeholder.
 */
-var ManagedModelFetcher = class {
-	async fetch() {
-		const cpUrl = process.env["CONTROL_PLANE_URL"];
-		if (!cpUrl) return [];
-		try {
-			const res = await globalThis.fetch(`${cpUrl}/api/llm/managed-models`);
-			if (!res.ok) return [];
-			return await res.json();
-		} catch {
-			return [];
+const MAX_INLINE_BYTES = 8 * 1024 * 1024;
+/** MCP content-block discriminators. At least one must appear for a result to be treated as MCP-shaped. */
+const KNOWN_MCP_BLOCK_TYPES = new Set([
+	"text",
+	"image",
+	"audio",
+	"resource",
+	"resource_link"
+]);
+/**
+* Maps a tool result that is **content-block-shaped** (an MCP `CallToolResult` with a `content`
+* array) into AI SDK `{ type: "content" }` tool-result output, so binaries reach the chat model as
+* native multimodal tool-result blocks instead of being flattened to inert JSON text.
+*
+* The `@ai-sdk/anthropic` provider maps a `content`-output part as follows:
+* `text` → text block, `image-data` → image block, `file-data` (only `application/pdf`) → document
+* block. Non-PDF `file-data` is dropped by the provider, so this factory emits `image-data` for
+* images, `file-data` only for PDFs, and a text marker for every other binary type.
+*
+* Returns `undefined` when the result is not content-block-shaped — callers keep the existing
+* `{ type: "json" }` path, so plain string/object tool results are unaffected.
+*/
+var AgentToolResultContentFactory = class AgentToolResultContentFactory {
+	static tryMapToContentOutput(result) {
+		const blocks = AgentToolResultContentFactory.contentBlocks(result);
+		if (blocks === void 0) return void 0;
+		const parts = [];
+		let inlinedBytes = 0;
+		for (const block of blocks) {
+			const mapped = AgentToolResultContentFactory.mapBlock(block, inlinedBytes);
+			parts.push(mapped.part);
+			inlinedBytes += mapped.bytes;
 		}
+		return parts;
+	}
+	/**
+	* Returns the `content` array iff `result` is an object whose `content` is an array of typed
+	* blocks AND at least one block carries a known MCP discriminator. A plain JSON result that merely
+	* has a `content` key of some other shape (e.g. Notion/Slack rich-text blocks) is rejected,
+	* preserving the `{ type: "json" }` path so its payload is never lost.
+	*/
+	static contentBlocks(result) {
+		if (result === null || typeof result !== "object") return void 0;
+		const content = result.content;
+		if (!Array.isArray(content) || content.length === 0) return void 0;
+		if (!content.every((block) => block !== null && typeof block === "object" && typeof block.type === "string")) return void 0;
+		return content.some((block) => KNOWN_MCP_BLOCK_TYPES.has(block.type)) ? content : void 0;
+	}
+	static mapBlock(block, inlinedBytesSoFar) {
+		const type = block.type;
+		if (type === "text" && typeof block.text === "string") return {
+			part: {
+				type: "text",
+				text: block.text
+			},
+			bytes: 0
+		};
+		if (type === "image" && typeof block.data === "string" && typeof block.mimeType === "string") return AgentToolResultContentFactory.mapBinary({
+			base64: block.data,
+			mediaType: block.mimeType,
+			inlinedBytesSoFar
+		});
+		if (type === "resource" && block.resource) return AgentToolResultContentFactory.mapEmbeddedResource(block.resource, inlinedBytesSoFar);
+		if (type === "resource_link" && typeof block.uri === "string") {
+			const mime = typeof block.mimeType === "string" ? ` (${block.mimeType})` : "";
+			return {
+				part: {
+					type: "text",
+					text: `[linked resource: ${block.uri}${mime}]`
+				},
+				bytes: 0
+			};
+		}
+		return {
+			part: {
+				type: "text",
+				text: `[unsupported tool content block: ${String(type)}]`
+			},
+			bytes: 0
+		};
+	}
+	static mapEmbeddedResource(resource, inlinedBytesSoFar) {
+		if (typeof resource.text === "string") return {
+			part: {
+				type: "text",
+				text: resource.text
+			},
+			bytes: 0
+		};
+		if (typeof resource.blob === "string" && typeof resource.mimeType === "string") return AgentToolResultContentFactory.mapBinary({
+			base64: resource.blob,
+			mediaType: resource.mimeType,
+			filename: typeof resource.name === "string" ? resource.name : void 0,
+			inlinedBytesSoFar
+		});
+		return {
+			part: {
+				type: "text",
+				text: `[embedded resource: ${typeof resource.uri === "string" ? resource.uri : "unknown"}]`
+			},
+			bytes: 0
+		};
+	}
+	static mapBinary(args) {
+		const rawBytes = Math.floor(args.base64.length * 3 / 4);
+		if (args.inlinedBytesSoFar + rawBytes > MAX_INLINE_BYTES) {
+			const name = args.filename ? ` "${args.filename}"` : "";
+			const kb = Math.round(rawBytes / 1024);
+			return {
+				part: {
+					type: "text",
+					text: `[binary${name} (${args.mediaType}, ~${kb} KB) omitted: exceeds the per-tool-result inline limit]`
+				},
+				bytes: 0
+			};
+		}
+		if (args.mediaType.startsWith("image/")) return {
+			part: {
+				type: "image-data",
+				data: args.base64,
+				mediaType: args.mediaType
+			},
+			bytes: rawBytes
+		};
+		if (args.mediaType === "application/pdf") return {
+			part: {
+				type: "file-data",
+				data: args.base64,
+				mediaType: args.mediaType,
+				...args.filename ? { filename: args.filename } : {}
+			},
+			bytes: rawBytes
+		};
+		return {
+			part: {
+				type: "text",
+				text: `[binary${args.filename ? ` "${args.filename}"` : ""} (${args.mediaType}) not inlined: unsupported by the model]`
+			},
+			bytes: 0
+		};
 	}
 };
 
@@ -4550,20 +4671,35 @@ var AgentMessageFactory = class AgentMessageFactory {
 	* Builds the `{ role: "tool", content: [{ type: "tool-result", ... }, ...] }` message returned
 	* to the model after each tool round.
 	*/
-	static createToolResultsMessage(executedToolCalls) {
+	static createToolResultsMessage(executedToolCalls, passToolBinariesToModel = true) {
 		return {
 			role: "tool",
 			content: executedToolCalls.map((executed) => ({
 				type: "tool-result",
 				toolCallId: executed.toolCallId,
 				toolName: executed.toolName,
-				output: {
-					type: "json",
-					value: AgentMessageFactory.toToolResultJson(executed.result)
-				}
+				output: AgentMessageFactory.toToolResultOutput(executed.result, passToolBinariesToModel)
 			}))
 		};
 	}
+	/**
+	* Routes a tool result to a native multimodal `{ type: "content" }` output when it is
+	* content-block-shaped (an MCP `CallToolResult`) and binary passdown is enabled; otherwise keeps
+	* the inert `{ type: "json" }` path.
+	*/
+	static toToolResultOutput(result, passToolBinariesToModel) {
+		if (passToolBinariesToModel) {
+			const content = AgentToolResultContentFactory.tryMapToContentOutput(result);
+			if (content !== void 0) return {
+				type: "content",
+				value: content
+			};
+		}
+		return {
+			type: "json",
+			value: AgentMessageFactory.toToolResultJson(result)
+		};
+	}
 	static toToolResultJson(value) {
 		if (value === void 0) return null;
 		try {
@@ -5882,6 +6018,63 @@ AgentToolExecutionCoordinator = __decorate([
 	__decorateMetadata("design:paramtypes", [typeof (_ref$2 = typeof AgentToolErrorClassifier !== "undefined" && AgentToolErrorClassifier) === "function" ? _ref$2 : Object, typeof (_ref2$2 = typeof AgentToolRepairPolicy !== "undefined" && AgentToolRepairPolicy) === "function" ? _ref2$2 : Object])
 ], AgentToolExecutionCoordinator);
 
+//#endregion
+//#region src/nodes/AgentBinaryContentFactory.ts
+/**
+* Turns resolved file binaries into native AI SDK multimodal content parts and merges them into the
+* agent prompt. Images (`image/*`) become {@link ImagePart}s; every other type (PDFs, office docs,
+* CSV, JSON, …) becomes a {@link FilePart}. The provider maps these to its wire-level `image` /
+* `document` blocks; an unsupported file type surfaces as a provider error at runtime.
+*
+* Parts are appended to the LAST user message so the binary travels alongside the author's prompt
+* text (preserving any untrusted-source preamble that already wrapped that text). When no user
+* message exists, a new user message carrying only the binaries is appended.
+*/
+var AgentBinaryContentFactory = class AgentBinaryContentFactory {
+	static toContentPart(binary) {
+		if (binary.mediaType.startsWith("image/")) return {
+			type: "image",
+			image: binary.base64,
+			mediaType: binary.mediaType
+		};
+		return {
+			type: "file",
+			data: binary.base64,
+			mediaType: binary.mediaType,
+			...binary.filename ? { filename: binary.filename } : {}
+		};
+	}
+	static withBinaries(messages, binaries) {
+		if (binaries.length === 0) return messages;
+		const parts = binaries.map((binary) => AgentBinaryContentFactory.toContentPart(binary));
+		const lastUserIndex = AgentBinaryContentFactory.lastUserMessageIndex(messages);
+		if (lastUserIndex === -1) {
+			const appended = {
+				role: "user",
+				content: parts
+			};
+			return [...messages, appended];
+		}
+		const next = [...messages];
+		next[lastUserIndex] = AgentBinaryContentFactory.appendPartsToUserMessage(messages[lastUserIndex], parts);
+		return next;
+	}
+	static lastUserMessageIndex(messages) {
+		for (let index = messages.length - 1; index >= 0; index--) if (messages[index]?.role === "user") return index;
+		return -1;
+	}
+	static appendPartsToUserMessage(message, parts) {
+		const existing = typeof message.content === "string" ? message.content.length > 0 ? [{
+			type: "text",
+			text: message.content
+		}] : [] : message.content;
+		return {
+			...message,
+			content: [...existing, ...parts]
+		};
+	}
+};
+
 //#endregion
 //#region src/nodes/NodeBackedToolRuntime.ts
 var _ref$1, _ref2$1, _ref3$1, _ref4$1;
@@ -6080,11 +6273,18 @@ var DeferredMetaToolStrategy = class {
 	mcpEntries = [];
 	toolsByServerId = /* @__PURE__ */ new Map();
 	foundToolIds = /* @__PURE__ */ new Set();
+	/**
+	* `jsonSchema` from the `ai` SDK, loaded lazily in {@link initialize} so the SDK
+	* (~28MB RSS) stays off the boot path. `initialize` always runs before the sync
+	* `getToolsForTurn` → `buildFindToolsDefinition` path, so this is set before use.
+	*/
+	jsonSchema;
 	constructor(bm25, warnFn) {
 		this.bm25 = bm25;
 		this.warnFn = warnFn;
 	}
 	async initialize(input) {
+		this.jsonSchema = (await import("ai")).jsonSchema;
 		this.nodeBackedTools = { ...input.nodeBackedTools };
 		const pinnedIds = input.pinnedMcpTools ?? [];
 		if (pinnedIds.length > PINNED_TOOLS_HARD_LIMIT) throw new Error(`Agent config error: pinnedMcpTools count (${pinnedIds.length}) exceeds hard limit of ${PINNED_TOOLS_HARD_LIMIT}.`);
@@ -6172,25 +6372,26 @@ var DeferredMetaToolStrategy = class {
 		return [...this.foundToolIds];
 	}
 	buildFindToolsDefinition() {
+		const inputSchemaRecord = {
+			type: "object",
+			properties: {
+				query: {
+					type: "string",
+					description: "Natural language description of what you want to do."
+				},
+				limit: {
+					type: "integer",
+					minimum: 1,
+					maximum: 10,
+					description: `Maximum number of tools to return (default ${FIND_TOOLS_DEFAULT_LIMIT}).`
+				}
+			},
+			required: ["query"],
+			additionalProperties: false
+		};
 		return {
 			description: "Search for tools available from connected MCP servers. After this call, the tools listed in the result will be callable on your very next turn. Use this when you need a capability not visible in your current tool list. Do not attempt to call a tool name you have not seen yet — use find_tools to discover it first.",
-			inputSchema: (0, ai.jsonSchema)({
-				type: "object",
-				properties: {
-					query: {
-						type: "string",
-						description: "Natural language description of what you want to do."
-					},
-					limit: {
-						type: "integer",
-						minimum: 1,
-						maximum: 10,
-						description: `Maximum number of tools to return (default ${FIND_TOOLS_DEFAULT_LIMIT}).`
-					}
-				},
-				required: ["query"],
-				additionalProperties: false
-			})
+			inputSchema: this.jsonSchema(inputSchemaRecord)
 		};
 	}
 };
@@ -6224,6 +6425,13 @@ let AIAgentNode = class AIAgentNode$1 {
 	inputSchema = unknown();
 	connectionCredentialExecutionContextFactory;
 	preparedByExecutionContext = /* @__PURE__ */ new WeakMap();
+	/**
+	* The `ai` SDK, loaded lazily in {@link execute} so the SDK (~28MB RSS) stays
+	* off the boot path — non-AI workflows never load it. Every path runs through
+	* `execute` → `ensureAiSdk` before any sync helper touches `this.aiSdk`.
+	*/
+	aiSdk;
+	aiSdkPromise = null;
 	constructor(nodeResolver, credentialSessions, nodeBackedToolRuntime, executionHelpers, structuredOutputRunner, toolExecutionCoordinator, toolLoadingStrategyFactory, agentMcpIntegration) {
 		this.nodeResolver = nodeResolver;
 		this.nodeBackedToolRuntime = nodeBackedToolRuntime;
@@ -6236,6 +6444,7 @@ let AIAgentNode = class AIAgentNode$1 {
 	}
 	async execute(args) {
 		const { ctx } = args;
+		await this.ensureAiSdk();
 		if (ctx.resumeContext) return this.executeResumed(args, ctx.resumeContext);
 		const prepared = await this.getOrPrepareExecution(ctx);
 		const itemWithMappedJson = {
@@ -6244,6 +6453,10 @@ let AIAgentNode = class AIAgentNode$1 {
 		};
 		return (await this.runAgentForItem(prepared, itemWithMappedJson, args.itemIndex, args.items)).json;
 	}
+	/** Load the `ai` SDK once per node instance (cached promise guards concurrent items). */
+	async ensureAiSdk() {
+		this.aiSdk = await (this.aiSdkPromise ??= import("ai"));
+	}
 	/**
 	* Resume path: re-enters the agent loop after a HITL suspension.
 	* Reconstructs the conversation from the checkpoint, injects the human decision
@@ -6275,7 +6488,7 @@ let AIAgentNode = class AIAgentNode$1 {
 			result: decision,
 			serialized: JSON.stringify(decision)
 		};
-		const conversation = [...checkpoint.conversation, AgentMessageFactory.createToolResultsMessage([toolResultEntry])];
+		const conversation = [...checkpoint.conversation, AgentMessageFactory.createToolResultsMessage([toolResultEntry], ctx.config.passToolBinariesToModel !== false)];
 		const loopResult = await this.runTurnLoopUntilFinalAnswer({
 			prepared,
 			itemInputsByPort,
@@ -6386,7 +6599,7 @@ let AIAgentNode = class AIAgentNode$1 {
 		const { ctx } = prepared;
 		const itemInputsByPort = AgentItemPortMap.fromItem(item);
 		const itemScopedTools = this.createItemScopedTools(prepared.resolvedTools, ctx, item, itemIndex, items);
-		const conversation = [...this.createPromptMessages(item, itemIndex, items, ctx)];
+		const conversation = [...await this.createPromptMessages(item, itemIndex, items, ctx)];
 		if (ctx.config.outputSchema && itemScopedTools.length === 0) {
 			const structuredOutput = await this.structuredOutputRunner.resolve({
 				model: prepared.model,
@@ -6495,7 +6708,7 @@ let AIAgentNode = class AIAgentNode$1 {
 				coordinatorExecutedCalls.push(...executed);
 			}
 			const allExecutedCalls = [...strategyExecutedCalls, ...coordinatorExecutedCalls];
-			this.appendAssistantAndToolMessages(conversation, result.assistantMessage, result.text, result.toolCalls, allExecutedCalls);
+			this.appendAssistantAndToolMessages(conversation, result.assistantMessage, result.text, result.toolCalls, allExecutedCalls, ctx.config.passToolBinariesToModel !== false);
 		}
 		return {
 			finalText,
@@ -6510,8 +6723,8 @@ let AIAgentNode = class AIAgentNode$1 {
 		if (guardrails.onTurnLimitReached === "respondWithLastMessage") return;
 		throw new Error(`AIAgent "${ctx.config.name ?? ctx.nodeId}" reached maxTurns=${guardrails.maxTurns} before producing a final response.`);
 	}
-	appendAssistantAndToolMessages(conversation, assistantMessage, text, toolCalls, executedToolCalls) {
-		conversation.push(assistantMessage ?? AgentMessageFactory.createAssistantWithToolCalls(text, toolCalls), AgentMessageFactory.createToolResultsMessage(executedToolCalls));
+	appendAssistantAndToolMessages(conversation, assistantMessage, text, toolCalls, executedToolCalls, passToolBinariesToModel) {
+		conversation.push(assistantMessage ?? AgentMessageFactory.createAssistantWithToolCalls(text, toolCalls), AgentMessageFactory.createToolResultsMessage(executedToolCalls, passToolBinariesToModel));
 	}
 	async resolveFinalOutputJson(prepared, itemInputsByPort, conversation, finalText, wasToolEnabledRun) {
 		if (!prepared.ctx.config.outputSchema) return AgentOutputFactory.fromAgentContent(finalText);
@@ -6630,7 +6843,7 @@ let AIAgentNode = class AIAgentNode$1 {
 			const description = this.resolveHumanApprovalBehavior(entry.config) !== void 0 ? `${baseDescription} ${HITL_SOLO_CONSTRAINT_SENTENCE}` : baseDescription;
 			toolSet[entry.config.name] = {
 				description,
-				inputSchema: (0, ai.jsonSchema)(schemaRecord)
+				inputSchema: this.aiSdk.jsonSchema(schemaRecord)
 			};
 		}
 		return toolSet;
@@ -6661,7 +6874,7 @@ let AIAgentNode = class AIAgentNode$1 {
 			const description = entry.humanApproval !== void 0 && baseDescription !== void 0 ? `${baseDescription} ${HITL_SOLO_CONSTRAINT_SENTENCE}` : entry.humanApproval !== void 0 ? HITL_SOLO_CONSTRAINT_SENTENCE : baseDescription;
 			toolSet[entry.config.name] = {
 				description,
-				inputSchema: (0, ai.jsonSchema)(schemaRecord)
+				inputSchema: this.aiSdk.jsonSchema(schemaRecord)
 			};
 		}
 		return toolSet;
@@ -6713,7 +6926,7 @@ let AIAgentNode = class AIAgentNode$1 {
 		});
 		try {
 			const callOptions = this.resolveCallOptions(model, guardrails.modelInvocationOptions);
-			const result = await (0, ai.generateText)({
+			const result = await this.aiSdk.generateText({
 				model: model.languageModel,
 				messages: [...messages],
 				tools,
@@ -6832,8 +7045,8 @@ let AIAgentNode = class AIAgentNode$1 {
 				schemaName: structuredOptions?.schemaName ?? "structured_output",
 				requireObjectRoot: true
 			}) : schema;
-			const outputSchema = ai.Output.object({ schema: (0, ai.jsonSchema)(schemaRecord) });
-			const result = await (0, ai.generateText)({
+			const outputSchema = this.aiSdk.Output.object({ schema: this.aiSdk.jsonSchema(schemaRecord) });
+			const result = await this.aiSdk.generateText({
 				model: model.languageModel,
 				messages: [...messages],
 				experimental_output: outputSchema,
@@ -7104,7 +7317,7 @@ let AIAgentNode = class AIAgentNode$1 {
 		const json = JSON.stringify(value);
 		return JSON.parse(json);
 	}
-	createPromptMessages(item, itemIndex, items, ctx) {
+	async createPromptMessages(item, itemIndex, items, ctx) {
 		const messages = __codemation_core.AgentMessageConfigNormalizer.resolveFromInputOrConfig(item.json, ctx.config, {
 			item,
 			itemIndex,
@@ -7112,7 +7325,47 @@ let AIAgentNode = class AIAgentNode$1 {
 			ctx
 		});
 		const wrapped = this.wrapUntrustedSourceMessages(messages, item, ctx.config);
-		return AgentMessageFactory.createPromptMessages(wrapped);
+		const promptMessages = AgentMessageFactory.createPromptMessages(wrapped);
+		if (ctx.config.passBinariesToModel === false) return promptMessages;
+		const attachments = this.selectBinaryAttachments(item, itemIndex, items, ctx);
+		const binaries = await this.resolveInlineBinaries(attachments, ctx);
+		return AgentBinaryContentFactory.withBinaries(promptMessages, binaries);
+	}
+	/**
+	* Picks which attachments feed the passdown. When the author supplies `config.binaries`
+	* (a static array or a per-item function — e.g. to forward binaries from an earlier node),
+	* those replace the current item's attachments; otherwise the current item's `item.binary`
+	* is used.
+	*/
+	selectBinaryAttachments(item, itemIndex, items, ctx) {
+		const manual = ctx.config.binaries;
+		if (manual !== void 0) return typeof manual === "function" ? manual({
+			item,
+			itemIndex,
+			items,
+			ctx
+		}) : manual;
+		return item.binary ? Object.values(item.binary) : [];
+	}
+	/**
+	* Reads every attachment through `ctx.binary` (storage-backed, by reference — never base64 on
+	* `item.json`) and resolves it to inline base64 so the agent can pass it to the chat model as a
+	* native multimodal block. Images become image blocks; every other type (PDF, office docs, CSV,
+	* JSON, …) becomes a file block — we don't filter by media type, so any binary can be fed to the
+	* model. If the provider rejects an unsupported type the error surfaces at runtime, and the
+	* workflow can filter the binary upstream.
+	*/
+	async resolveInlineBinaries(attachments, ctx) {
+		const resolved = [];
+		for (const attachment of attachments) {
+			const bytes = await ctx.binary.getBytes(attachment);
+			resolved.push({
+				mediaType: attachment.mimeType,
+				base64: Buffer.from(bytes).toString("base64"),
+				...attachment.filename ? { filename: attachment.filename } : {}
+			});
+		}
+		return resolved;
 	}
 	/**
 	* When `item.json.__source` matches an entry in `config.untrustedSources`
@@ -7226,6 +7479,7 @@ var AIAgent = class {
 	chatModel;
 	tools;
 	id;
+	description;
 	retryPolicy;
 	guardrails;
 	inputSchema;
@@ -7233,12 +7487,16 @@ var AIAgent = class {
 	mcpServers;
 	pinnedMcpTools;
 	untrustedSources;
+	passBinariesToModel;
+	passToolBinariesToModel;
+	binaries;
 	constructor(options) {
 		this.name = options.name;
 		this.messages = options.messages;
 		this.chatModel = options.chatModel;
 		this.tools = options.tools ?? [];
 		this.id = options.id;
+		this.description = options.description;
 		this.retryPolicy = options.retryPolicy ?? __codemation_core.RetryPolicy.defaultForAiAgent;
 		this.guardrails = options.guardrails;
 		this.inputSchema = options.inputSchema;
@@ -7246,6 +7504,9 @@ var AIAgent = class {
 		this.mcpServers = options.mcpServers;
 		this.pinnedMcpTools = options.pinnedMcpTools;
 		this.untrustedSources = options.untrustedSources;
+		this.passBinariesToModel = options.passBinariesToModel;
+		this.passToolBinariesToModel = options.passToolBinariesToModel;
+		this.binaries = options.binaries;
 	}
 	inspectorSummary() {
 		const rows = [];
@@ -7316,12 +7577,14 @@ var Assertion = class {
 	icon;
 	name;
 	id;
+	description;
 	emitsAssertions = true;
 	assertions;
 	constructor(options) {
 		this.name = options.name ?? "Assertion";
 		this.id = options.id;
 		this.icon = options.icon ?? "lucide:check-circle";
+		this.description = options.description;
 		this.assertions = options.assertions;
 	}
 	inspectorSummary() {
@@ -7373,6 +7636,7 @@ var Callback = class Callback {
 	icon = "lucide:braces";
 	emptyBatchExecution = "runOnce";
 	id;
+	description;
 	retryPolicy;
 	nodeErrorHandler;
 	declaredOutputPorts;
@@ -7384,6 +7648,7 @@ var Callback = class Callback {
 			id: idOrOptions
 		} : idOrOptions;
 		this.id = resolvedOptions?.id;
+		this.description = resolvedOptions?.description;
 		this.retryPolicy = resolvedOptions?.retryPolicy;
 		this.nodeErrorHandler = resolvedOptions?.nodeErrorHandler;
 		this.declaredOutputPorts = resolvedOptions?.declaredOutputPorts;
@@ -7585,10 +7850,12 @@ var HttpRequest = class {
 	type = HttpRequestNode;
 	execution = { hint: "local" };
 	icon = "lucide:globe";
+	description;
 	constructor(name, args = {}, retryPolicy = __codemation_core.RetryPolicy.defaultForHttp) {
 		this.name = name;
 		this.args = args;
 		this.retryPolicy = retryPolicy;
+		this.description = args.description;
 	}
 	get id() {
 		return this.args.id;
@@ -7683,10 +7950,14 @@ var Aggregate = class {
 	execution = { hint: "local" };
 	keepBinaries = true;
 	icon = "builtin:aggregate-rows";
-	constructor(name, aggregate, id) {
+	id;
+	description;
+	constructor(name, aggregate, idOrOptions) {
 		this.name = name;
 		this.aggregate = aggregate;
-		this.id = id;
+		const options = typeof idOrOptions === "string" ? { id: idOrOptions } : idOrOptions;
+		this.id = options?.id;
+		this.description = options?.description;
 	}
 	inspectorSummary() {
 		const fnName = this.aggregate.name;
@@ -7717,10 +7988,14 @@ var Filter = class {
 	type = FilterNode;
 	execution = { hint: "local" };
 	icon = "lucide:filter";
-	constructor(name, predicate, id) {
+	id;
+	description;
+	constructor(name, predicate, idOrOptions) {
 		this.name = name;
 		this.predicate = predicate;
-		this.id = id;
+		const options = typeof idOrOptions === "string" ? { id: idOrOptions } : idOrOptions;
+		this.id = options?.id;
+		this.description = options?.description;
 	}
 	inspectorSummary() {
 		const fnName = this.predicate.name;
@@ -7795,10 +8070,14 @@ var If = class {
 	execution = { hint: "local" };
 	icon = "lucide:split@rot=90";
 	declaredOutputPorts = ["true", "false"];
-	constructor(name, predicate, id) {
+	id;
+	description;
+	constructor(name, predicate, idOrOptions) {
 		this.name = name;
 		this.predicate = predicate;
-		this.id = id;
+		const options = typeof idOrOptions === "string" ? { id: idOrOptions } : idOrOptions;
+		this.id = options?.id;
+		this.description = options?.description;
 	}
 	inspectorSummary() {
 		const fnName = this.predicate.name;
@@ -7838,9 +8117,12 @@ var IsTestRun = class {
 	declaredOutputPorts = ["true", "false"];
 	name;
 	id;
-	constructor(name = "Is test run?", id) {
+	description;
+	constructor(name = "Is test run?", idOrOptions) {
 		this.name = name;
-		this.id = id;
+		const options = typeof idOrOptions === "string" ? { id: idOrOptions } : idOrOptions;
+		this.id = options?.id;
+		this.description = options?.description;
 	}
 };
 
@@ -7869,11 +8151,15 @@ var Switch = class {
 	execution = { hint: "local" };
 	icon = "lucide:git-branch-plus";
 	declaredOutputPorts;
-	constructor(name, cfg, id) {
+	id;
+	description;
+	constructor(name, cfg, idOrOptions) {
 		this.name = name;
 		this.cfg = cfg;
-		this.id = id;
 		this.declaredOutputPorts = [...new Set([...cfg.cases, cfg.defaultCase])].sort();
+		const options = typeof idOrOptions === "string" ? { id: idOrOptions } : idOrOptions;
+		this.id = options?.id;
+		this.description = options?.description;
 	}
 	inspectorSummary() {
 		const rows = [{
@@ -7912,10 +8198,14 @@ var Split = class {
 	*/
 	continueWhenEmptyOutput = true;
 	icon = "builtin:split-rows";
-	constructor(name, getElements, id) {
+	id;
+	description;
+	constructor(name, getElements, idOrOptions) {
 		this.name = name;
 		this.getElements = getElements;
-		this.id = id;
+		const options = typeof idOrOptions === "string" ? { id: idOrOptions } : idOrOptions;
+		this.id = options?.id;
+		this.description = options?.description;
 	}
 	inspectorSummary() {
 		const fnName = this.getElements.name;
@@ -7973,14 +8263,17 @@ var CronTrigger = class {
 	type = CronTriggerNode;
 	icon = "lucide:clock";
 	id;
-	constructor(name, args, id) {
+	description;
+	constructor(name, args, idOrOptions) {
 		this.name = name;
 		this.args = args;
 		new croner.Cron(args.schedule, {
 			paused: true,
 			timezone: args.timezone
 		});
-		this.id = id;
+		const options = typeof idOrOptions === "string" ? { id: idOrOptions } : idOrOptions;
+		this.id = options?.id;
+		this.description = options?.description;
 	}
 	get schedule() {
 		return this.args.schedule;
@@ -8034,20 +8327,21 @@ var ManualTrigger = class ManualTrigger {
 	icon = "lucide:play";
 	defaultItems;
 	id;
+	description;
 	/** Manual runs often emit an empty batch; still schedule downstream by default. */
 	continueWhenEmptyOutput = true;
-	constructor(name = "Manual trigger", defaultItemsOrId, id) {
+	constructor(name = "Manual trigger", defaultItemsOrId, idOrOptions) {
 		this.name = name;
 		this.defaultItems = ManualTrigger.resolveDefaultItems(defaultItemsOrId);
-		this.id = ManualTrigger.resolveId(defaultItemsOrId, id);
+		const trailing = idOrOptions ?? (typeof defaultItemsOrId === "string" ? defaultItemsOrId : void 0);
+		const options = typeof trailing === "string" ? { id: trailing } : trailing ?? {};
+		this.id = options.id;
+		this.description = options.description;
 	}
 	static resolveDefaultItems(value) {
 		if (typeof value === "string" || value === void 0) return;
 		return this.itemsInputNormalizer.normalize(value);
 	}
-	static resolveId(value, id) {
-		return typeof value === "string" ? value : id;
-	}
 	inspectorSummary() {
 		const rows = [{
 			label: "Trigger",
@@ -8093,11 +8387,13 @@ var MapData = class {
 	continueWhenEmptyOutput = true;
 	icon = "lucide:square-pen";
 	keepBinaries;
+	description;
 	constructor(name, map, options = {}) {
 		this.name = name;
 		this.map = map;
 		this.options = options;
 		this.keepBinaries = options.keepBinaries ?? true;
+		this.description = options.description;
 	}
 	get id() {
 		return this.options.id;
@@ -8170,10 +8466,14 @@ var Merge = class {
 	kind = "node";
 	type = MergeNode;
 	icon = "lucide:merge@rot=90";
-	constructor(name, cfg = { mode: "passThrough" }, id) {
+	id;
+	description;
+	constructor(name, cfg = { mode: "passThrough" }, idOrOptions) {
 		this.name = name;
 		this.cfg = cfg;
-		this.id = id;
+		const options = typeof idOrOptions === "string" ? { id: idOrOptions } : idOrOptions;
+		this.id = options?.id;
+		this.description = options?.description;
 	}
 	inspectorSummary() {
 		const rows = [{
@@ -8206,9 +8506,13 @@ var NoOp = class {
 	type = NoOpNode;
 	execution = { hint: "local" };
 	icon = "lucide:circle-dashed";
-	constructor(name = "NoOp", id) {
+	id;
+	description;
+	constructor(name = "NoOp", idOrOptions) {
 		this.name = name;
-		this.id = id;
+		const options = typeof idOrOptions === "string" ? { id: idOrOptions } : idOrOptions;
+		this.id = options?.id;
+		this.description = options?.description;
 	}
 };
 
@@ -8274,12 +8578,16 @@ var SubWorkflow = class {
 	kind = "node";
 	type = SubWorkflowNode;
 	icon = "lucide:workflow";
-	constructor(name, workflowId, upstreamRefs, startAt, id) {
+	id;
+	description;
+	constructor(name, workflowId, upstreamRefs, startAt, idOrOptions) {
 		this.name = name;
 		this.workflowId = workflowId;
 		this.upstreamRefs = upstreamRefs;
 		this.startAt = startAt;
-		this.id = id;
+		const options = typeof idOrOptions === "string" ? { id: idOrOptions } : idOrOptions;
+		this.id = options?.id;
+		this.description = options?.description;
 	}
 	inspectorSummary() {
 		const rows = [{
@@ -8389,10 +8697,14 @@ var Wait = class {
 	/** Pass-through empty batches should still advance to downstream nodes. */
 	continueWhenEmptyOutput = true;
 	icon = "lucide:hourglass";
-	constructor(name, milliseconds, id) {
+	id;
+	description;
+	constructor(name, milliseconds, idOrOptions) {
 		this.name = name;
 		this.milliseconds = milliseconds;
-		this.id = id;
+		const options = typeof idOrOptions === "string" ? { id: idOrOptions } : idOrOptions;
+		this.id = options?.id;
+		this.description = options?.description;
 	}
 	inspectorSummary() {
 		const seconds = this.milliseconds / 1e3;
@@ -8447,11 +8759,15 @@ var WebhookTrigger = class WebhookTrigger {
 	kind = "trigger";
 	type = WebhookTriggerNode;
 	icon = "lucide:globe";
-	constructor(name, args, handler = WebhookTrigger.defaultHandler, id) {
+	id;
+	description;
+	constructor(name, args, handler = WebhookTrigger.defaultHandler, idOrOptions) {
 		this.name = name;
 		this.args = args;
 		this.handler = handler;
-		this.id = id;
+		const options = typeof idOrOptions === "string" ? { id: idOrOptions } : idOrOptions;
+		this.id = options?.id;
+		this.description = options?.description;
 	}
 	get endpointKey() {
 		return this.args.endpointKey;
@@ -8508,11 +8824,21 @@ function createWorkflowBuilder(meta$2) {
 
 //#endregion
 //#region src/workflowAuthoring/WorkflowChatModelFactory.types.ts
+const VALID_COMPLEXITY = new Set([
+	"low",
+	"medium",
+	"high",
+	"xhigh"
+]);
 var WorkflowChatModelFactory = class {
 	static create(model) {
 		if (typeof model !== "string") return model;
 		const [provider, resolvedModel] = model.includes(":") ? model.split(":", 2) : ["openai", model];
-		if (provider === "codemation-managed") return new CodemationChatModelConfig("Codemation Managed", resolvedModel ?? "");
+		if (provider === "codemation-managed") {
+			const complexity = resolvedModel ?? "medium";
+			if (!VALID_COMPLEXITY.has(complexity)) throw new Error(`Invalid managed complexity "${complexity}". Must be one of: low, medium, high, xhigh.`);
+			return new CodemationChatModelConfig("Codemation Managed", complexity);
+		}
 		if (provider !== "openai") throw new Error(`Unsupported workflow().agent() model provider "${provider}".`);
 		return new OpenAIChatModelConfig("OpenAI", resolvedModel);
 	}
@@ -9280,7 +9606,6 @@ Object.defineProperty(exports, 'IsTestRunNode', {
     return IsTestRunNode;
   }
 });
-exports.ManagedModelFetcher = ManagedModelFetcher;
 exports.ManualTrigger = ManualTrigger;
 Object.defineProperty(exports, 'ManualTriggerNode', {
   enumerable: true,