@codemation/core-nodes 0.4.3 → 0.7.0

package/dist/index.cjs

@@ -23,192 +23,576 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 //#endregion
 let __codemation_core = require("@codemation/core");
 __codemation_core = __toESM(__codemation_core);
-let __langchain_openai = require("@langchain/openai");
-__langchain_openai = __toESM(__langchain_openai);
-let __langchain_core_messages = require("@langchain/core/messages");
-__langchain_core_messages = __toESM(__langchain_core_messages);
-let __langchain_core_utils_types = require("@langchain/core/utils/types");
-__langchain_core_utils_types = __toESM(__langchain_core_utils_types);
-let __langchain_core_utils_json_schema = require("@langchain/core/utils/json_schema");
-__langchain_core_utils_json_schema = __toESM(__langchain_core_utils_json_schema);
-let __langchain_core_tools = require("@langchain/core/tools");
-__langchain_core_tools = __toESM(__langchain_core_tools);
+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 ai = require("ai");
+ai = __toESM(ai);
+let croner = require("croner");
+croner = __toESM(croner);
 
-//#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;
-	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;
-}
+//#region src/credentials/ApiKeyCredentialType.ts
+/**
+* API key credential that injects a key either as an HTTP header or a query parameter.
+*/
+const apiKeyCredentialType = (0, __codemation_core.defineCredential)({
+	key: "core-nodes.api-key",
+	label: "API Key",
+	description: "Authenticates requests by injecting an API key into a header or query parameter.",
+	public: {
+		placement: {
+			label: "Placement",
+			type: "string",
+			helpText: "Where to send the key: \"header\" (default) or \"query\".",
+			placeholder: "header"
+		},
+		name: {
+			label: "Parameter name",
+			type: "string",
+			helpText: "Header or query param name. Defaults to \"X-API-Key\" for headers, \"api_key\" for query.",
+			placeholder: "X-API-Key"
+		}
+	},
+	secret: { apiKey: {
+		label: "API Key",
+		type: "password",
+		required: true,
+		helpText: "The secret API key value."
+	} },
+	async createSession(args) {
+		const apiKey = String(args.material.apiKey ?? "");
+		if (!apiKey) throw new Error("API key credential material is incomplete: apiKey is required.");
+		const isQuery = String(args.publicConfig.placement ?? "header").toLowerCase() === "query";
+		const defaultName = isQuery ? "api_key" : "X-API-Key";
+		const paramName = String(args.publicConfig.name ?? "").trim() || defaultName;
+		return { applyToRequest: (_spec) => {
+			if (isQuery) return { query: { [paramName]: apiKey } };
+			return { headers: { [paramName]: apiKey } };
+		} };
+	},
+	async test(args) {
+		const apiKey = String(args.material.apiKey ?? "");
+		return {
+			status: apiKey.length > 0 ? "healthy" : "failing",
+			message: apiKey.length > 0 ? "API key is configured." : "API key is missing.",
+			testedAt: (/* @__PURE__ */ new Date()).toISOString()
+		};
+	}
+});
 
 //#endregion
-//#region src/chatModels/OpenAIChatModelFactory.ts
-let OpenAIChatModelFactory = class OpenAIChatModelFactory$1 {
+//#region src/credentials/BasicAuthCredentialType.ts
+/**
+* HTTP Basic authentication credential.
+* Session sets `Authorization: Basic <base64(username:password)>`.
+*/
+const basicAuthCredentialType = (0, __codemation_core.defineCredential)({
+	key: "core-nodes.basic-auth",
+	label: "Basic Auth",
+	description: "Authenticates requests using HTTP Basic Authentication (username + password).",
+	public: { username: {
+		label: "Username",
+		type: "string",
+		required: true,
+		helpText: "The username for HTTP Basic Authentication."
+	} },
+	secret: { password: {
+		label: "Password",
+		type: "password",
+		required: true,
+		helpText: "The password for HTTP Basic Authentication."
+	} },
+	async createSession(args) {
+		const username = String(args.publicConfig.username ?? "");
+		const password = String(args.material.password ?? "");
+		if (!username) throw new Error("Basic Auth credential is incomplete: username is required.");
+		const encoded = Buffer.from(`${username}:${password}`).toString("base64");
+		return { applyToRequest: (_spec) => ({ headers: { authorization: `Basic ${encoded}` } }) };
+	},
+	async test(args) {
+		const username = String(args.publicConfig.username ?? "");
+		const password = String(args.material.password ?? "");
+		const ok = username.length > 0 && password.length > 0;
+		return {
+			status: ok ? "healthy" : "failing",
+			message: ok ? "Basic Auth credentials are configured." : "Username or password is missing.",
+			testedAt: (/* @__PURE__ */ new Date()).toISOString()
+		};
+	}
+});
+
+//#endregion
+//#region src/credentials/BearerTokenCredentialType.ts
+/**
+* Simple Bearer token credential.
+* Session sets `Authorization: Bearer <token>` on every request.
+*/
+const bearerTokenCredentialType = (0, __codemation_core.defineCredential)({
+	key: "core-nodes.bearer-token",
+	label: "Bearer Token",
+	description: "Authenticates requests using a static Bearer token in the Authorization header.",
+	public: {},
+	secret: { token: {
+		label: "Token",
+		type: "password",
+		required: true,
+		helpText: "The Bearer token to include in the Authorization header."
+	} },
+	async createSession(args) {
+		const token = String(args.material.token ?? "");
+		if (!token) throw new Error("Bearer token credential material is incomplete: token is required.");
+		return { applyToRequest: (_spec) => ({ headers: { authorization: `Bearer ${token}` } }) };
+	},
+	async test(args) {
+		const token = String(args.material.token ?? "");
+		return {
+			status: token.length > 0 ? "healthy" : "failing",
+			message: token.length > 0 ? "Bearer token is configured." : "Token is missing.",
+			testedAt: (/* @__PURE__ */ new Date()).toISOString()
+		};
+	}
+});
+
+//#endregion
+//#region src/credentials/OAuth2TokenExchangeFactory.ts
+var OAuth2TokenExchangeFactory = class {
 	async create(args) {
-		const session = await args.ctx.getCredential(args.config.credentialSlotKey);
-		return new __langchain_openai.ChatOpenAI({
-			apiKey: session.apiKey,
-			model: args.config.model,
-			temperature: args.config.options?.temperature,
-			maxTokens: args.config.options?.maxTokens,
-			configuration: session.baseUrl ? { baseURL: session.baseUrl } : void 0
+		const body = new URLSearchParams({
+			grant_type: "client_credentials",
+			client_id: args.clientId
 		});
+		if (args.scopes) body.set("scope", args.scopes);
+		if (args.audience) body.set("audience", args.audience);
+		const encoded = Buffer.from(`${args.clientId}:${args.clientSecret}`).toString("base64");
+		const response = await globalThis.fetch(args.tokenUrl, {
+			method: "POST",
+			headers: {
+				"content-type": "application/x-www-form-urlencoded",
+				authorization: `Basic ${encoded}`
+			},
+			body: body.toString()
+		});
+		if (!response.ok) {
+			const text = await response.text().catch(() => "");
+			throw new Error(`Token exchange failed (${response.status} ${response.statusText}): ${text}`);
+		}
+		const json = await response.json();
+		const token = String(json["access_token"] ?? "");
+		if (!token) throw new Error("Token exchange response did not include an access_token.");
+		return token;
 	}
 };
-OpenAIChatModelFactory = __decorate([(0, __codemation_core.chatModel)({ packageName: "@codemation/core-nodes" })], OpenAIChatModelFactory);
 
 //#endregion
-//#region src/chatModels/OpenAIStructuredOutputMethodFactory.ts
-var _OpenAIStructuredOutputMethodFactory;
-let OpenAIStructuredOutputMethodFactory = class OpenAIStructuredOutputMethodFactory$1 {
-	static {
-		_OpenAIStructuredOutputMethodFactory = this;
+//#region src/credentials/OAuth2ClientCredentialsTypeFactory.ts
+/**
+* OAuth2 client-credentials flow credential.
+*
+* This is a machine-to-machine flow: no user redirect occurs. The session
+* POSTs to the configured `tokenUrl` with `client_credentials` grant, caches
+* the resulting access token for the duration of the session, and injects it
+* as `Authorization: Bearer <token>` on each request.
+*
+* Token caching is per-session only (one createSession call = one token fetch
+* at most). Cross-session caching would require host-level state and is out of
+* scope here. Because the engine creates a fresh session per execution, a new
+* token is fetched once per node activation.
+*
+* NOTE: `auth` is intentionally omitted from the definition. The OAuth2
+* `auth: { kind: "oauth2" }` shape signals an authorization-code / user-redirect
+* flow; using it here would cause the host UI to render an OAuth consent button
+* that goes nowhere. Client-credentials is a purely server-side flow.
+*/
+const oauth2ClientCredentialsType = (0, __codemation_core.defineCredential)({
+	key: "core-nodes.oauth2-client-credentials",
+	label: "OAuth2 Client Credentials",
+	description: "Machine-to-machine OAuth2 using the client_credentials grant. Exchanges client ID and secret for a bearer token before each workflow execution.",
+	public: {
+		tokenUrl: {
+			label: "Token URL",
+			type: "string",
+			required: true,
+			helpText: "The token endpoint URL, e.g. https://auth.example.com/oauth/token."
+		},
+		scopes: {
+			label: "Scopes",
+			type: "string",
+			helpText: "Space-separated list of OAuth2 scopes to request (optional)."
+		},
+		audience: {
+			label: "Audience",
+			type: "string",
+			helpText: "Optional audience parameter sent to the token endpoint.",
+			visibility: "advanced"
+		}
+	},
+	secret: {
+		clientId: {
+			label: "Client ID",
+			type: "string",
+			required: true
+		},
+		clientSecret: {
+			label: "Client Secret",
+			type: "password",
+			required: true
+		}
+	},
+	async createSession(args) {
+		const tokenUrl = String(args.publicConfig.tokenUrl ?? "");
+		const clientId = String(args.material.clientId ?? "");
+		const clientSecret = String(args.material.clientSecret ?? "");
+		if (!tokenUrl || !clientId || !clientSecret) throw new Error("OAuth2 client credentials are incomplete: tokenUrl, clientId, and clientSecret are required.");
+		const accessToken = await new OAuth2TokenExchangeFactory().create({
+			tokenUrl,
+			clientId,
+			clientSecret,
+			scopes: String(args.publicConfig.scopes ?? ""),
+			audience: String(args.publicConfig.audience ?? "")
+		});
+		return { applyToRequest: (_spec) => ({ headers: { authorization: `Bearer ${accessToken}` } }) };
+	},
+	async test(args) {
+		const tokenUrl = String(args.publicConfig.tokenUrl ?? "");
+		const clientId = String(args.material.clientId ?? "");
+		const clientSecret = String(args.material.clientSecret ?? "");
+		if (!tokenUrl || !clientId || !clientSecret) return {
+			status: "failing",
+			message: "tokenUrl, clientId, and clientSecret are all required.",
+			testedAt: (/* @__PURE__ */ new Date()).toISOString()
+		};
+		try {
+			await new OAuth2TokenExchangeFactory().create({
+				tokenUrl,
+				clientId,
+				clientSecret,
+				scopes: String(args.publicConfig.scopes ?? ""),
+				audience: String(args.publicConfig.audience ?? "")
+			});
+			return {
+				status: "healthy",
+				message: "Token exchange succeeded.",
+				testedAt: (/* @__PURE__ */ new Date()).toISOString()
+			};
+		} catch (error) {
+			return {
+				status: "failing",
+				message: error instanceof Error ? error.message : String(error),
+				testedAt: (/* @__PURE__ */ new Date()).toISOString()
+			};
+		}
 	}
-	static isoDatePattern = /^\d{4}-\d{2}-\d{2}$/;
-	create(chatModelConfig) {
-		if (chatModelConfig.type !== OpenAIChatModelFactory) return;
-		const model = this.readModelName(chatModelConfig);
-		if (!model) return {
-			method: "functionCalling",
-			strict: true
+});
+
+//#endregion
+//#region src/http/HttpRequestExecutor.ts
+/**
+* Executes a single HTTP request described by {@link HttpRequestSpec}.
+*
+* - Credential sessions provide header/query deltas via `applyToRequest`.
+* - Body encoding is delegated to {@link HttpBodyBuilder}.
+* - URL query merging is delegated to {@link HttpUrlBuilder}.
+* - Binary response bodies: when `download.mode` triggers binary attach, the
+*   `bodyBinaryName` field is set in the result but the body is NOT read here.
+*   Callers that need binary attachment should use `buildRequest` to get the
+*   resolved URL + init and make the fetch + binary attach themselves.
+*
+* Collaborators (`fetch`, body builder, url builder) are injected so callers
+* own construction at composition roots and tests can supply deterministic stubs.
+*/
+var HttpRequestExecutor = class {
+	constructor(fetchFn, bodyBuilder, urlBuilder) {
+		this.fetchFn = fetchFn;
+		this.bodyBuilder = bodyBuilder;
+		this.urlBuilder = urlBuilder;
+	}
+	/**
+	* Builds the fetch init (headers, query, body) from the spec + credential delta,
+	* returning both the resolved URL and the RequestInit so callers can make the
+	* actual fetch call themselves (useful for streaming / binary attach).
+	*/
+	async buildRequest(spec, item) {
+		const credentialDelta = spec.credential?.applyToRequest(spec) ?? {};
+		const mergedHeaders = {
+			...spec.headers ?? {},
+			...credentialDelta.headers ?? {}
+		};
+		const mergedQuery = {
+			...spec.query ?? {},
+			...credentialDelta.query ?? {}
 		};
+		const encodedBody = await this.bodyBuilder.build(spec.body, item, spec.ctx);
+		const hasExplicitContentType = Object.keys(mergedHeaders).some((k) => k.toLowerCase() === "content-type");
+		if (encodedBody && encodedBody.contentType && !hasExplicitContentType) mergedHeaders["content-type"] = encodedBody.contentType;
+		return {
+			url: this.urlBuilder.build(spec.url, mergedQuery),
+			init: {
+				method: spec.method,
+				headers: mergedHeaders,
+				...encodedBody ? { body: encodedBody.body } : {}
+			}
+		};
+	}
+	/**
+	* Executes an HTTP request and returns parsed result.
+	* For binary downloads (when `shouldAttachBody` is true), the body is NOT consumed
+	* and callers must call `ctx.binary.attach` directly using the resolved URL + init
+	* (available via `buildRequest`).
+	*/
+	async execute(spec, item) {
+		const { url: resolvedUrl, init } = await this.buildRequest(spec, item);
+		const response = await this.fetchFn(resolvedUrl, init);
+		const responseHeaders = this.readHeaders(response.headers);
+		const mimeType = this.resolveMimeType(responseHeaders);
+		const downloadMode = spec.download?.mode ?? "auto";
+		const binaryName = spec.download?.binaryName ?? "body";
+		const shouldDownload = this.shouldAttachBody(downloadMode, mimeType);
+		const isJson = this.isJsonMimeType(mimeType);
+		let json;
+		let text;
+		let bodyBinaryName;
+		if (shouldDownload) bodyBinaryName = binaryName;
+		else if (isJson) try {
+			json = await response.json();
+		} catch {
+			text = await response.text();
+		}
+		else text = await response.text();
 		return {
-			method: this.supportsJsonSchema(model) ? "jsonSchema" : "functionCalling",
-			strict: true
+			url: resolvedUrl,
+			method: spec.method.toUpperCase(),
+			status: response.status,
+			ok: response.ok,
+			statusText: response.statusText,
+			mimeType,
+			headers: responseHeaders,
+			...json !== void 0 ? { json } : {},
+			...text !== void 0 ? { text } : {},
+			...bodyBinaryName !== void 0 ? { bodyBinaryName } : {}
 		};
 	}
-	readModelName(chatModelConfig) {
-		const candidate = chatModelConfig;
-		return typeof candidate.model === "string" ? candidate.model : void 0;
+	readHeaders(headers) {
+		const values = {};
+		headers.forEach((value, key) => {
+			values[key] = value;
+		});
+		return values;
+	}
+	resolveMimeType(headers) {
+		const contentType = headers["content-type"];
+		if (!contentType) return "application/octet-stream";
+		return contentType.split(";")[0]?.trim() || "application/octet-stream";
 	}
-	supportsJsonSchema(model) {
-		if (model === "gpt-4o" || model === "gpt-4o-mini") return true;
-		return this.supportsSnapshotAtOrAfter(model, "gpt-4o-", "2024-08-06") || this.supportsSnapshotAtOrAfter(model, "gpt-4o-mini-", "2024-07-18");
+	isJsonMimeType(mimeType) {
+		return mimeType === "application/json" || mimeType.endsWith("+json");
 	}
-	supportsSnapshotAtOrAfter(model, prefix, minimumSnapshotDate) {
-		if (!model.startsWith(prefix)) return false;
-		const snapshotDate = model.slice(prefix.length);
-		return _OpenAIStructuredOutputMethodFactory.isoDatePattern.test(snapshotDate) && snapshotDate >= minimumSnapshotDate;
+	shouldAttachBody(mode, mimeType) {
+		if (mode === "always") return true;
+		if (mode === "never") return false;
+		return mimeType.startsWith("image/") || mimeType.startsWith("audio/") || mimeType.startsWith("video/") || mimeType === "application/pdf";
 	}
 };
-OpenAIStructuredOutputMethodFactory = _OpenAIStructuredOutputMethodFactory = __decorate([(0, __codemation_core.injectable)()], OpenAIStructuredOutputMethodFactory);
 
 //#endregion
-//#region src/chatModels/openAiChatModelConfig.ts
-var OpenAIChatModelConfig = class {
-	type = OpenAIChatModelFactory;
-	presentation;
-	provider = "openai";
-	modelName;
-	constructor(name, model, credentialSlotKey = "openai", presentationIn, options) {
-		this.name = name;
-		this.model = model;
-		this.credentialSlotKey = credentialSlotKey;
-		this.options = options;
-		this.modelName = model;
-		this.presentation = presentationIn ?? {
-			icon: "builtin:openai",
-			label: name
+//#region src/http/HttpBodyBuilder.ts
+/**
+* Builds a fetch-compatible `BodyInit` + Content-Type pair from an {@link HttpBodySpec}.
+* Multipart binaries are read from `item.binary` via `ctx.binary.openReadStream`.
+*/
+var HttpBodyBuilder = class {
+	async build(spec, item, ctx) {
+		if (!spec || spec.kind === "none") return;
+		if (spec.kind === "json") return {
+			body: JSON.stringify(spec.data),
+			contentType: "application/json"
 		};
+		if (spec.kind === "form") {
+			const params = new URLSearchParams();
+			for (const [key, value] of Object.entries(spec.data)) params.append(key, value);
+			return {
+				body: params.toString(),
+				contentType: "application/x-www-form-urlencoded"
+			};
+		}
+		if (spec.kind === "multipart") {
+			const formData = new FormData();
+			for (const [key, value] of Object.entries(spec.fields)) formData.append(key, value);
+			if (spec.binaries) for (const [fieldName, binaryRef] of Object.entries(spec.binaries)) {
+				const attachment = item.binary?.[binaryRef];
+				if (attachment) {
+					const readResult = await ctx.binary.openReadStream(attachment);
+					if (readResult) {
+						const merged = await this.readStreamToBuffer(readResult.body);
+						const blob = new Blob([merged], { type: attachment.mimeType });
+						formData.append(fieldName, blob, attachment.filename ?? binaryRef);
+					}
+				}
+			}
+			return {
+				body: formData,
+				contentType: ""
+			};
+		}
+		if (spec.kind === "binary") {
+			const attachment = item.binary?.[spec.slot];
+			if (!attachment) throw new Error(`HttpRequest bodyFormat "binary": no binary attachment found at slot "${spec.slot}". Ensure a previous node attached binary data at that slot.`);
+			const readResult = await ctx.binary.openReadStream(attachment);
+			if (!readResult) throw new Error(`HttpRequest bodyFormat "binary": could not open read stream for slot "${spec.slot}".`);
+			return {
+				body: readResult.body,
+				contentType: attachment.mimeType
+			};
+		}
 	}
-	getCredentialRequirements() {
-		return [{
-			slotKey: this.credentialSlotKey,
-			label: "OpenAI API key",
-			acceptedTypes: ["openai.apiKey"]
-		}];
+	async readStreamToBuffer(stream) {
+		const reader = stream.getReader();
+		const chunks = [];
+		let done = false;
+		while (!done) {
+			const result = await reader.read();
+			done = result.done;
+			if (result.value) chunks.push(result.value);
+		}
+		const totalLength = chunks.reduce((acc, chunk) => acc + chunk.length, 0);
+		const merged = new Uint8Array(new ArrayBuffer(totalLength));
+		let offset = 0;
+		for (const chunk of chunks) {
+			merged.set(chunk, offset);
+			offset += chunk.length;
+		}
+		return merged;
 	}
 };
 
 //#endregion
-//#region src/chatModels/OpenAiChatModelPresetsFactory.ts
+//#region src/http/HttpUrlBuilder.ts
 /**
-* Default OpenAI chat model configs for scaffolds and demos (icon + label match {@link OpenAIChatModelConfig} defaults).
-* Prefer importing {@link openAiChatModelPresets} from here or from the consumer template re-export
-* instead of repeating {@link OpenAIChatModelConfig} construction in app workflows.
+* Merges query parameters into a base URL.
+* Handles both scalar and array values, and preserves any existing params.
 */
-var OpenAiChatModelPresets = class {
-	demoGpt4oMini = new OpenAIChatModelConfig("OpenAI", "gpt-4o-mini");
-	demoGpt41 = new OpenAIChatModelConfig("OpenAI", "gpt-4.1");
+var HttpUrlBuilder = class {
+	build(baseUrl, query) {
+		if (!query || Object.keys(query).length === 0) return baseUrl;
+		const parsed = new URL(baseUrl);
+		for (const [key, value] of Object.entries(query)) if (Array.isArray(value)) for (const entry of value) parsed.searchParams.append(key, entry);
+		else parsed.searchParams.append(key, value);
+		return parsed.toString();
+	}
 };
-const openAiChatModelPresets = new OpenAiChatModelPresets();
 
 //#endregion
-//#region src/nodes/AgentMessageFactory.ts
-var AgentMessageFactory = class {
-	static createPromptMessages(messages) {
-		return messages.map((message) => this.createPromptMessage(message));
-	}
-	static createSystemPrompt(systemMessage) {
-		return new __langchain_core_messages.SystemMessage(systemMessage);
-	}
-	static createUserPrompt(prompt) {
-		return new __langchain_core_messages.HumanMessage(prompt);
-	}
-	static createAssistantPrompt(prompt) {
-		return new __langchain_core_messages.AIMessage(prompt);
-	}
-	static createToolMessage(toolCallId, content) {
-		return new __langchain_core_messages.ToolMessage({
-			tool_call_id: toolCallId,
-			content
-		});
-	}
-	static extractContent(message) {
-		if (typeof message === "string") return message;
-		if (!this.isRecord(message)) return String(message);
-		const content = message.content;
-		if (typeof content === "string") return content;
-		if (Array.isArray(content)) return content.map((part) => {
-			if (typeof part === "string") return part;
-			if (this.isRecord(part) && typeof part.text === "string") return part.text;
-			return JSON.stringify(part);
-		}).join("\n");
-		return JSON.stringify(content);
-	}
-	static extractToolCalls(message) {
-		if (!this.isRecord(message)) return [];
-		const toolCalls = message.tool_calls;
-		if (!Array.isArray(toolCalls)) return [];
-		return toolCalls.filter((toolCall) => this.isRecord(toolCall) && typeof toolCall.name === "string").map((toolCall) => ({
-			id: typeof toolCall.id === "string" ? toolCall.id : void 0,
-			name: toolCall.name,
-			input: this.isRecord(toolCall) && "args" in toolCall ? toolCall.args : void 0
-		}));
-	}
-	static isRecord(value) {
-		return typeof value === "object" && value !== null;
-	}
-	static createPromptMessage(message) {
-		if (message.role === "system") return this.createSystemPrompt(message.content);
-		if (message.role === "assistant") return this.createAssistantPrompt(message.content);
-		return this.createUserPrompt(message.content);
-	}
-};
+//#region src/authoring/defineRestNode.types.ts
+/**
+* Substitutes `{name}` placeholders in a path template using values from `params`.
+*/
+function substitutePath(template, params) {
+	return template.replace(/\{([^}]+)}/g, (_match, key) => {
+		const value = params[key];
+		return value !== void 0 ? String(value) : `{${key}}`;
+	});
+}
+/**
+* Declarative helper for creating thin API-wrapper nodes.
+*
+* Usage:
+* ```ts
+* export const postMessage = defineRestNode({
+*   key: "slack.post-message",
+*   title: "Send Slack message",
+*   icon: "si:slack",
+*   api: { baseUrl: "https://slack.com/api", path: "/chat.postMessage", method: "POST" },
+*   credentials: { auth: bearerTokenCredentialType },
+*   inputSchema: z.object({ channel: z.string(), text: z.string() }),
+*   request: ({ input }) => ({
+*     body: { kind: "json", data: { channel: input.channel, text: input.text } },
+*   }),
+*   response: ({ json }) => ({ messageTs: (json as any).ts }),
+* });
+* ```
+*
+* - `defineRestNode` is a thin wrapper over `defineNode`; it does not introduce a new runtime kind.
+* - Credential sessions are resolved via the `credentials` binding map (same as `defineNode`).
+* - Path `{placeholder}` substitution is applied from `input` keys before the request is made.
+* - Non-2xx responses throw an `Error` by default (`errorPolicy: "throw"`).
+*/
+function defineRestNode(options) {
+	const errorPolicy = options.errorPolicy ?? "throw";
+	return (0, __codemation_core.defineNode)({
+		key: options.key,
+		title: options.title,
+		description: options.description,
+		icon: options.icon,
+		credentials: options.credentials,
+		inputSchema: options.inputSchema,
+		async execute({ input, item, ctx }, { credentials }) {
+			const credentialSlot = options.credentials ? Object.keys(options.credentials)[0] : void 0;
+			const credential = credentialSlot ? await credentials[credentialSlot]?.() : void 0;
+			const inputRecord = input ?? {};
+			const requestShape = options.request ? await options.request({ input }) : {};
+			const pathParams = {
+				...inputRecord,
+				...requestShape.pathParams ?? {}
+			};
+			const resolvedPath = substitutePath(options.api.path, pathParams);
+			const resolvedUrl = `${options.api.baseUrl}${resolvedPath}`;
+			const result = await new HttpRequestExecutor(globalThis.fetch, new HttpBodyBuilder(), new HttpUrlBuilder()).execute({
+				url: resolvedUrl,
+				method: (options.api.method ?? "GET").toUpperCase(),
+				headers: requestShape.headers,
+				query: requestShape.query,
+				body: requestShape.body,
+				credential,
+				ctx
+			}, item);
+			if (errorPolicy === "throw" && !result.ok) throw new Error(`HTTP ${result.status} ${result.statusText} for ${result.method} ${result.url}`);
+			const responseCtx = {
+				status: result.status,
+				ok: result.ok,
+				statusText: result.statusText,
+				mimeType: result.mimeType,
+				headers: result.headers,
+				...result.json !== void 0 ? { json: result.json } : {},
+				...result.text !== void 0 ? { text: result.text } : {}
+			};
+			if (options.response) return await options.response({
+				...responseCtx,
+				input
+			});
+			return { json: responseCtx };
+		}
+	});
+}
 
 //#endregion
-//#region src/nodes/AgentOutputFactory.ts
-var AgentOutputFactory = class {
-	static fromUnknown(value) {
-		return { main: [{ json: value }] };
-	}
-	static replaceJson(item, value) {
+//#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;
+	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;
+}
+
+//#endregion
+//#region src/chatModels/OpenAIChatModelFactory.ts
+let OpenAIChatModelFactory = class OpenAIChatModelFactory$1 {
+	async create(args) {
+		const session = await args.ctx.getCredential(args.config.credentialSlotKey);
 		return {
-			...item,
-			json: value
+			languageModel: (0, __ai_sdk_openai.createOpenAI)({
+				apiKey: session.apiKey,
+				baseURL: session.baseUrl
+			}).chat(args.config.model),
+			modelName: args.config.model,
+			provider: "openai",
+			defaultCallOptions: {
+				maxOutputTokens: args.config.options?.maxTokens,
+				temperature: args.config.options?.temperature
+			}
 		};
 	}
-	static fromAgentContent(content) {
-		try {
-			return JSON.parse(content);
-		} catch {
-			return { output: content };
-		}
-	}
 };
+OpenAIChatModelFactory = __decorate([(0, __codemation_core.chatModel)({ packageName: "@codemation/core-nodes" })], OpenAIChatModelFactory);
 
 //#endregion
 //#region ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/core/core.js
@@ -299,10 +683,21 @@ function cleanRegex(source) {
 	const end = source.endsWith("$") ? source.length - 1 : source.length;
 	return source.slice(start, end);
 }
+function floatSafeRemainder(val, step) {
+	const valDecCount = (val.toString().split(".")[1] || "").length;
+	const stepString = step.toString();
+	let stepDecCount = (stepString.split(".")[1] || "").length;
+	if (stepDecCount === 0 && /\d?e-\d?/.test(stepString)) {
+		const match = stepString.match(/\d?e-(\d?)/);
+		if (match?.[1]) stepDecCount = Number.parseInt(match[1]);
+	}
+	const decCount = valDecCount > stepDecCount ? valDecCount : stepDecCount;
+	return Number.parseInt(val.toFixed(decCount).replace(".", "")) % Number.parseInt(step.toFixed(decCount).replace(".", "")) / 10 ** decCount;
+}
 const EVALUATING = Symbol("evaluating");
-function defineLazy(object, key, getter) {
+function defineLazy(object$1, key, getter) {
 	let value = void 0;
-	Object.defineProperty(object, key, {
+	Object.defineProperty(object$1, key, {
 		get() {
 			if (value === EVALUATING) return;
 			if (value === void 0) {
@@ -312,11 +707,19 @@ function defineLazy(object, key, getter) {
 			return value;
 		},
 		set(v) {
-			Object.defineProperty(object, key, { value: v });
+			Object.defineProperty(object$1, key, { value: v });
 		},
 		configurable: true
 	});
 }
+function assignProp(target, prop, value) {
+	Object.defineProperty(target, prop, {
+		value,
+		writable: true,
+		enumerable: true,
+		configurable: true
+	});
+}
 function mergeDefs(...defs) {
 	const mergedDescriptors = {};
 	for (const def of defs) {
@@ -325,6 +728,12 @@ function mergeDefs(...defs) {
 	}
 	return Object.defineProperties({}, mergedDescriptors);
 }
+function esc(str) {
+	return JSON.stringify(str);
+}
+function slugify(input) {
+	return input.toLowerCase().trim().replace(/[^\w\s-]/g, "").replace(/[\s_-]+/g, "-").replace(/^-+|-+$/g, "");
+}
 const captureStackTrace = "captureStackTrace" in Error ? Error.captureStackTrace : (..._args) => {};
 function isObject(data) {
 	return typeof data === "object" && data !== null && !Array.isArray(data);
@@ -353,6 +762,14 @@ function shallowClone(o) {
 	if (Array.isArray(o)) return [...o];
 	return o;
 }
+const propertyKeyTypes = new Set([
+	"string",
+	"number",
+	"symbol"
+]);
+function escapeRegex(str) {
+	return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
 function clone(inst, def, params) {
 	const cl = new inst._zod.constr(def ?? inst._zod.def);
 	if (!def || params?.parent) cl._zod.parent = inst;
@@ -373,6 +790,11 @@ function normalizeParams(_params) {
 	};
 	return params;
 }
+function optionalKeys(shape) {
+	return Object.keys(shape).filter((k) => {
+		return shape[k]._zod.optin === "optional" && shape[k]._zod.optout === "optional";
+	});
+}
 const NUMBER_FORMAT_RANGES = {
 	safeint: [Number.MIN_SAFE_INTEGER, Number.MAX_SAFE_INTEGER],
 	int32: [-2147483648, 2147483647],
@@ -380,6 +802,130 @@ const NUMBER_FORMAT_RANGES = {
 	float32: [-34028234663852886e22, 34028234663852886e22],
 	float64: [-Number.MAX_VALUE, Number.MAX_VALUE]
 };
+function pick(schema, mask) {
+	const currDef = schema._zod.def;
+	const checks = currDef.checks;
+	if (checks && checks.length > 0) throw new Error(".pick() cannot be used on object schemas containing refinements");
+	return clone(schema, mergeDefs(schema._zod.def, {
+		get shape() {
+			const newShape = {};
+			for (const key in mask) {
+				if (!(key in currDef.shape)) throw new Error(`Unrecognized key: "${key}"`);
+				if (!mask[key]) continue;
+				newShape[key] = currDef.shape[key];
+			}
+			assignProp(this, "shape", newShape);
+			return newShape;
+		},
+		checks: []
+	}));
+}
+function omit(schema, mask) {
+	const currDef = schema._zod.def;
+	const checks = currDef.checks;
+	if (checks && checks.length > 0) throw new Error(".omit() cannot be used on object schemas containing refinements");
+	return clone(schema, mergeDefs(schema._zod.def, {
+		get shape() {
+			const newShape = { ...schema._zod.def.shape };
+			for (const key in mask) {
+				if (!(key in currDef.shape)) throw new Error(`Unrecognized key: "${key}"`);
+				if (!mask[key]) continue;
+				delete newShape[key];
+			}
+			assignProp(this, "shape", newShape);
+			return newShape;
+		},
+		checks: []
+	}));
+}
+function extend(schema, shape) {
+	if (!isPlainObject(shape)) throw new Error("Invalid input to extend: expected a plain object");
+	const checks = schema._zod.def.checks;
+	if (checks && checks.length > 0) {
+		const existingShape = schema._zod.def.shape;
+		for (const key in shape) if (Object.getOwnPropertyDescriptor(existingShape, key) !== void 0) throw new Error("Cannot overwrite keys on object schemas containing refinements. Use `.safeExtend()` instead.");
+	}
+	return clone(schema, mergeDefs(schema._zod.def, { get shape() {
+		const _shape = {
+			...schema._zod.def.shape,
+			...shape
+		};
+		assignProp(this, "shape", _shape);
+		return _shape;
+	} }));
+}
+function safeExtend(schema, shape) {
+	if (!isPlainObject(shape)) throw new Error("Invalid input to safeExtend: expected a plain object");
+	return clone(schema, mergeDefs(schema._zod.def, { get shape() {
+		const _shape = {
+			...schema._zod.def.shape,
+			...shape
+		};
+		assignProp(this, "shape", _shape);
+		return _shape;
+	} }));
+}
+function merge(a, b) {
+	return clone(a, mergeDefs(a._zod.def, {
+		get shape() {
+			const _shape = {
+				...a._zod.def.shape,
+				...b._zod.def.shape
+			};
+			assignProp(this, "shape", _shape);
+			return _shape;
+		},
+		get catchall() {
+			return b._zod.def.catchall;
+		},
+		checks: []
+	}));
+}
+function partial(Class, schema, mask) {
+	const checks = schema._zod.def.checks;
+	if (checks && checks.length > 0) throw new Error(".partial() cannot be used on object schemas containing refinements");
+	return clone(schema, mergeDefs(schema._zod.def, {
+		get shape() {
+			const oldShape = schema._zod.def.shape;
+			const shape = { ...oldShape };
+			if (mask) for (const key in mask) {
+				if (!(key in oldShape)) throw new Error(`Unrecognized key: "${key}"`);
+				if (!mask[key]) continue;
+				shape[key] = Class ? new Class({
+					type: "optional",
+					innerType: oldShape[key]
+				}) : oldShape[key];
+			}
+			else for (const key in oldShape) shape[key] = Class ? new Class({
+				type: "optional",
+				innerType: oldShape[key]
+			}) : oldShape[key];
+			assignProp(this, "shape", shape);
+			return shape;
+		},
+		checks: []
+	}));
+}
+function required(Class, schema, mask) {
+	return clone(schema, mergeDefs(schema._zod.def, { get shape() {
+		const oldShape = schema._zod.def.shape;
+		const shape = { ...oldShape };
+		if (mask) for (const key in mask) {
+			if (!(key in shape)) throw new Error(`Unrecognized key: "${key}"`);
+			if (!mask[key]) continue;
+			shape[key] = new Class({
+				type: "nonoptional",
+				innerType: oldShape[key]
+			});
+		}
+		else for (const key in oldShape) shape[key] = new Class({
+			type: "nonoptional",
+			innerType: oldShape[key]
+		});
+		assignProp(this, "shape", shape);
+		return shape;
+	} }));
+}
 function aborted(x, startIndex = 0) {
 	if (x.aborted === true) return true;
 	for (let i = startIndex; i < x.issues.length; i++) if (x.issues[i]?.continue !== true) return true;
@@ -585,6 +1131,64 @@ const _safeDecodeAsync = (_Err) => async (schema, value, _ctx) => {
 };
 const safeDecodeAsync$1 = /* @__PURE__ */ _safeDecodeAsync($ZodRealError);
 
+//#endregion
+//#region ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/core/regexes.js
+const cuid = /^[cC][^\s-]{8,}$/;
+const cuid2 = /^[0-9a-z]+$/;
+const ulid = /^[0-9A-HJKMNP-TV-Za-hjkmnp-tv-z]{26}$/;
+const xid = /^[0-9a-vA-V]{20}$/;
+const ksuid = /^[A-Za-z0-9]{27}$/;
+const nanoid = /^[a-zA-Z0-9_-]{21}$/;
+/** ISO 8601-1 duration regex. Does not support the 8601-2 extensions like negative durations or fractional/negative components. */
+const duration$1 = /^P(?:(\d+W)|(?!.*W)(?=\d|T\d)(\d+Y)?(\d+M)?(\d+D)?(T(?=\d)(\d+H)?(\d+M)?(\d+([.,]\d+)?S)?)?)$/;
+/** A regex for any UUID-like identifier: 8-4-4-4-12 hex pattern */
+const guid = /^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12})$/;
+/** Returns a regex for validating an RFC 9562/4122 UUID.
+*
+* @param version Optionally specify a version 1-8. If no version is specified, all versions are supported. */
+const uuid = (version$1) => {
+	if (!version$1) return /^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-8][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$/;
+	return /* @__PURE__ */ new RegExp(`^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-${version$1}[0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12})$`);
+};
+/** Practical email validation */
+const email = /^(?!\.)(?!.*\.\.)([A-Za-z0-9_'+\-\.]*)[A-Za-z0-9_+-]@([A-Za-z0-9][A-Za-z0-9\-]*\.)+[A-Za-z]{2,}$/;
+const _emoji$1 = `^(\\p{Extended_Pictographic}|\\p{Emoji_Component})+$`;
+function emoji() {
+	return new RegExp(_emoji$1, "u");
+}
+const ipv4 = /^(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])$/;
+const ipv6 = /^(([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:))$/;
+const cidrv4 = /^((25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\/([0-9]|[1-2][0-9]|3[0-2])$/;
+const cidrv6 = /^(([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}|::|([0-9a-fA-F]{1,4})?::([0-9a-fA-F]{1,4}:?){0,6})\/(12[0-8]|1[01][0-9]|[1-9]?[0-9])$/;
+const base64 = /^$|^(?:[0-9a-zA-Z+/]{4})*(?:(?:[0-9a-zA-Z+/]{2}==)|(?:[0-9a-zA-Z+/]{3}=))?$/;
+const base64url = /^[A-Za-z0-9_-]*$/;
+const e164 = /^\+[1-9]\d{6,14}$/;
+const dateSource = `(?:(?:\\d\\d[2468][048]|\\d\\d[13579][26]|\\d\\d0[48]|[02468][048]00|[13579][26]00)-02-29|\\d{4}-(?:(?:0[13578]|1[02])-(?:0[1-9]|[12]\\d|3[01])|(?:0[469]|11)-(?:0[1-9]|[12]\\d|30)|(?:02)-(?:0[1-9]|1\\d|2[0-8])))`;
+const date$1 = /* @__PURE__ */ new RegExp(`^${dateSource}$`);
+function timeSource(args) {
+	const hhmm = `(?:[01]\\d|2[0-3]):[0-5]\\d`;
+	return typeof args.precision === "number" ? args.precision === -1 ? `${hhmm}` : args.precision === 0 ? `${hhmm}:[0-5]\\d` : `${hhmm}:[0-5]\\d\\.\\d{${args.precision}}` : `${hhmm}(?::[0-5]\\d(?:\\.\\d+)?)?`;
+}
+function time$1(args) {
+	return /* @__PURE__ */ new RegExp(`^${timeSource(args)}$`);
+}
+function datetime$1(args) {
+	const time$2 = timeSource({ precision: args.precision });
+	const opts = ["Z"];
+	if (args.local) opts.push("");
+	if (args.offset) opts.push(`([+-](?:[01]\\d|2[0-3]):[0-5]\\d)`);
+	const timeRegex = `${time$2}(?:${opts.join("|")})`;
+	return /* @__PURE__ */ new RegExp(`^${dateSource}T(?:${timeRegex})$`);
+}
+const string$1 = (params) => {
+	const regex = params ? `[\\s\\S]{${params?.minimum ?? 0},${params?.maximum ?? ""}}` : `[\\s\\S]*`;
+	return /* @__PURE__ */ new RegExp(`^${regex}$`);
+};
+const integer = /^-?\d+$/;
+const number$1 = /^-?\d+(?:\.\d+)?$/;
+const lowercase = /^[^A-Z]*$/;
+const uppercase = /^[^a-z]*$/;
+
 //#endregion
 //#region ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/core/checks.js
 const $ZodCheck = /* @__PURE__ */ $constructor("$ZodCheck", (inst, def) => {
@@ -593,25 +1197,164 @@ const $ZodCheck = /* @__PURE__ */ $constructor("$ZodCheck", (inst, def) => {
 	inst._zod.def = def;
 	(_a$1 = inst._zod).onattach ?? (_a$1.onattach = []);
 });
-const $ZodCheckMaxLength = /* @__PURE__ */ $constructor("$ZodCheckMaxLength", (inst, def) => {
-	var _a$1;
+const numericOriginMap = {
+	number: "number",
+	bigint: "bigint",
+	object: "date"
+};
+const $ZodCheckLessThan = /* @__PURE__ */ $constructor("$ZodCheckLessThan", (inst, def) => {
 	$ZodCheck.init(inst, def);
-	(_a$1 = inst._zod.def).when ?? (_a$1.when = (payload) => {
-		const val = payload.value;
-		return !nullish(val) && val.length !== void 0;
-	});
+	const origin = numericOriginMap[typeof def.value];
 	inst._zod.onattach.push((inst$1) => {
-		const curr = inst$1._zod.bag.maximum ?? Number.POSITIVE_INFINITY;
-		if (def.maximum < curr) inst$1._zod.bag.maximum = def.maximum;
+		const bag = inst$1._zod.bag;
+		const curr = (def.inclusive ? bag.maximum : bag.exclusiveMaximum) ?? Number.POSITIVE_INFINITY;
+		if (def.value < curr) if (def.inclusive) bag.maximum = def.value;
+		else bag.exclusiveMaximum = def.value;
 	});
 	inst._zod.check = (payload) => {
-		const input = payload.value;
-		if (input.length <= def.maximum) return;
-		const origin = getLengthableOrigin(input);
+		if (def.inclusive ? payload.value <= def.value : payload.value < def.value) return;
 		payload.issues.push({
 			origin,
 			code: "too_big",
-			maximum: def.maximum,
+			maximum: typeof def.value === "object" ? def.value.getTime() : def.value,
+			input: payload.value,
+			inclusive: def.inclusive,
+			inst,
+			continue: !def.abort
+		});
+	};
+});
+const $ZodCheckGreaterThan = /* @__PURE__ */ $constructor("$ZodCheckGreaterThan", (inst, def) => {
+	$ZodCheck.init(inst, def);
+	const origin = numericOriginMap[typeof def.value];
+	inst._zod.onattach.push((inst$1) => {
+		const bag = inst$1._zod.bag;
+		const curr = (def.inclusive ? bag.minimum : bag.exclusiveMinimum) ?? Number.NEGATIVE_INFINITY;
+		if (def.value > curr) if (def.inclusive) bag.minimum = def.value;
+		else bag.exclusiveMinimum = def.value;
+	});
+	inst._zod.check = (payload) => {
+		if (def.inclusive ? payload.value >= def.value : payload.value > def.value) return;
+		payload.issues.push({
+			origin,
+			code: "too_small",
+			minimum: typeof def.value === "object" ? def.value.getTime() : def.value,
+			input: payload.value,
+			inclusive: def.inclusive,
+			inst,
+			continue: !def.abort
+		});
+	};
+});
+const $ZodCheckMultipleOf = /* @__PURE__ */ $constructor("$ZodCheckMultipleOf", (inst, def) => {
+	$ZodCheck.init(inst, def);
+	inst._zod.onattach.push((inst$1) => {
+		var _a$1;
+		(_a$1 = inst$1._zod.bag).multipleOf ?? (_a$1.multipleOf = def.value);
+	});
+	inst._zod.check = (payload) => {
+		if (typeof payload.value !== typeof def.value) throw new Error("Cannot mix number and bigint in multiple_of check.");
+		if (typeof payload.value === "bigint" ? payload.value % def.value === BigInt(0) : floatSafeRemainder(payload.value, def.value) === 0) return;
+		payload.issues.push({
+			origin: typeof payload.value,
+			code: "not_multiple_of",
+			divisor: def.value,
+			input: payload.value,
+			inst,
+			continue: !def.abort
+		});
+	};
+});
+const $ZodCheckNumberFormat = /* @__PURE__ */ $constructor("$ZodCheckNumberFormat", (inst, def) => {
+	$ZodCheck.init(inst, def);
+	def.format = def.format || "float64";
+	const isInt = def.format?.includes("int");
+	const origin = isInt ? "int" : "number";
+	const [minimum, maximum] = NUMBER_FORMAT_RANGES[def.format];
+	inst._zod.onattach.push((inst$1) => {
+		const bag = inst$1._zod.bag;
+		bag.format = def.format;
+		bag.minimum = minimum;
+		bag.maximum = maximum;
+		if (isInt) bag.pattern = integer;
+	});
+	inst._zod.check = (payload) => {
+		const input = payload.value;
+		if (isInt) {
+			if (!Number.isInteger(input)) {
+				payload.issues.push({
+					expected: origin,
+					format: def.format,
+					code: "invalid_type",
+					continue: false,
+					input,
+					inst
+				});
+				return;
+			}
+			if (!Number.isSafeInteger(input)) {
+				if (input > 0) payload.issues.push({
+					input,
+					code: "too_big",
+					maximum: Number.MAX_SAFE_INTEGER,
+					note: "Integers must be within the safe integer range.",
+					inst,
+					origin,
+					inclusive: true,
+					continue: !def.abort
+				});
+				else payload.issues.push({
+					input,
+					code: "too_small",
+					minimum: Number.MIN_SAFE_INTEGER,
+					note: "Integers must be within the safe integer range.",
+					inst,
+					origin,
+					inclusive: true,
+					continue: !def.abort
+				});
+				return;
+			}
+		}
+		if (input < minimum) payload.issues.push({
+			origin: "number",
+			input,
+			code: "too_small",
+			minimum,
+			inclusive: true,
+			inst,
+			continue: !def.abort
+		});
+		if (input > maximum) payload.issues.push({
+			origin: "number",
+			input,
+			code: "too_big",
+			maximum,
+			inclusive: true,
+			inst,
+			continue: !def.abort
+		});
+	};
+});
+const $ZodCheckMaxLength = /* @__PURE__ */ $constructor("$ZodCheckMaxLength", (inst, def) => {
+	var _a$1;
+	$ZodCheck.init(inst, def);
+	(_a$1 = inst._zod.def).when ?? (_a$1.when = (payload) => {
+		const val = payload.value;
+		return !nullish(val) && val.length !== void 0;
+	});
+	inst._zod.onattach.push((inst$1) => {
+		const curr = inst$1._zod.bag.maximum ?? Number.POSITIVE_INFINITY;
+		if (def.maximum < curr) inst$1._zod.bag.maximum = def.maximum;
+	});
+	inst._zod.check = (payload) => {
+		const input = payload.value;
+		if (input.length <= def.maximum) return;
+		const origin = getLengthableOrigin(input);
+		payload.issues.push({
+			origin,
+			code: "too_big",
+			maximum: def.maximum,
 			inclusive: true,
 			input,
 			inst,
@@ -681,6 +1424,123 @@ const $ZodCheckLengthEquals = /* @__PURE__ */ $constructor("$ZodCheckLengthEqual
 		});
 	};
 });
+const $ZodCheckStringFormat = /* @__PURE__ */ $constructor("$ZodCheckStringFormat", (inst, def) => {
+	var _a$1, _b;
+	$ZodCheck.init(inst, def);
+	inst._zod.onattach.push((inst$1) => {
+		const bag = inst$1._zod.bag;
+		bag.format = def.format;
+		if (def.pattern) {
+			bag.patterns ?? (bag.patterns = /* @__PURE__ */ new Set());
+			bag.patterns.add(def.pattern);
+		}
+	});
+	if (def.pattern) (_a$1 = inst._zod).check ?? (_a$1.check = (payload) => {
+		def.pattern.lastIndex = 0;
+		if (def.pattern.test(payload.value)) return;
+		payload.issues.push({
+			origin: "string",
+			code: "invalid_format",
+			format: def.format,
+			input: payload.value,
+			...def.pattern ? { pattern: def.pattern.toString() } : {},
+			inst,
+			continue: !def.abort
+		});
+	});
+	else (_b = inst._zod).check ?? (_b.check = () => {});
+});
+const $ZodCheckRegex = /* @__PURE__ */ $constructor("$ZodCheckRegex", (inst, def) => {
+	$ZodCheckStringFormat.init(inst, def);
+	inst._zod.check = (payload) => {
+		def.pattern.lastIndex = 0;
+		if (def.pattern.test(payload.value)) return;
+		payload.issues.push({
+			origin: "string",
+			code: "invalid_format",
+			format: "regex",
+			input: payload.value,
+			pattern: def.pattern.toString(),
+			inst,
+			continue: !def.abort
+		});
+	};
+});
+const $ZodCheckLowerCase = /* @__PURE__ */ $constructor("$ZodCheckLowerCase", (inst, def) => {
+	def.pattern ?? (def.pattern = lowercase);
+	$ZodCheckStringFormat.init(inst, def);
+});
+const $ZodCheckUpperCase = /* @__PURE__ */ $constructor("$ZodCheckUpperCase", (inst, def) => {
+	def.pattern ?? (def.pattern = uppercase);
+	$ZodCheckStringFormat.init(inst, def);
+});
+const $ZodCheckIncludes = /* @__PURE__ */ $constructor("$ZodCheckIncludes", (inst, def) => {
+	$ZodCheck.init(inst, def);
+	const escapedRegex = escapeRegex(def.includes);
+	const pattern = new RegExp(typeof def.position === "number" ? `^.{${def.position}}${escapedRegex}` : escapedRegex);
+	def.pattern = pattern;
+	inst._zod.onattach.push((inst$1) => {
+		const bag = inst$1._zod.bag;
+		bag.patterns ?? (bag.patterns = /* @__PURE__ */ new Set());
+		bag.patterns.add(pattern);
+	});
+	inst._zod.check = (payload) => {
+		if (payload.value.includes(def.includes, def.position)) return;
+		payload.issues.push({
+			origin: "string",
+			code: "invalid_format",
+			format: "includes",
+			includes: def.includes,
+			input: payload.value,
+			inst,
+			continue: !def.abort
+		});
+	};
+});
+const $ZodCheckStartsWith = /* @__PURE__ */ $constructor("$ZodCheckStartsWith", (inst, def) => {
+	$ZodCheck.init(inst, def);
+	const pattern = /* @__PURE__ */ new RegExp(`^${escapeRegex(def.prefix)}.*`);
+	def.pattern ?? (def.pattern = pattern);
+	inst._zod.onattach.push((inst$1) => {
+		const bag = inst$1._zod.bag;
+		bag.patterns ?? (bag.patterns = /* @__PURE__ */ new Set());
+		bag.patterns.add(pattern);
+	});
+	inst._zod.check = (payload) => {
+		if (payload.value.startsWith(def.prefix)) return;
+		payload.issues.push({
+			origin: "string",
+			code: "invalid_format",
+			format: "starts_with",
+			prefix: def.prefix,
+			input: payload.value,
+			inst,
+			continue: !def.abort
+		});
+	};
+});
+const $ZodCheckEndsWith = /* @__PURE__ */ $constructor("$ZodCheckEndsWith", (inst, def) => {
+	$ZodCheck.init(inst, def);
+	const pattern = /* @__PURE__ */ new RegExp(`.*${escapeRegex(def.suffix)}$`);
+	def.pattern ?? (def.pattern = pattern);
+	inst._zod.onattach.push((inst$1) => {
+		const bag = inst$1._zod.bag;
+		bag.patterns ?? (bag.patterns = /* @__PURE__ */ new Set());
+		bag.patterns.add(pattern);
+	});
+	inst._zod.check = (payload) => {
+		if (payload.value.endsWith(def.suffix)) return;
+		payload.issues.push({
+			origin: "string",
+			code: "invalid_format",
+			format: "ends_with",
+			suffix: def.suffix,
+			input: payload.value,
+			inst,
+			continue: !def.abort
+		});
+	};
+});
 const $ZodCheckOverwrite = /* @__PURE__ */ $constructor("$ZodCheckOverwrite", (inst, def) => {
 	$ZodCheck.init(inst, def);
 	inst._zod.check = (payload) => {
@@ -688,6 +1548,38 @@ const $ZodCheckOverwrite = /* @__PURE__ */ $constructor("$ZodCheckOverwrite", (i
 	};
 });
 
+//#endregion
+//#region ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/core/doc.js
+var Doc = class {
+	constructor(args = []) {
+		this.content = [];
+		this.indent = 0;
+		if (this) this.args = args;
+	}
+	indented(fn) {
+		this.indent += 1;
+		fn(this);
+		this.indent -= 1;
+	}
+	write(arg) {
+		if (typeof arg === "function") {
+			arg(this, { execution: "sync" });
+			arg(this, { execution: "async" });
+			return;
+		}
+		const lines = arg.split("\n").filter((x) => x);
+		const minIndent = Math.min(...lines.map((x) => x.length - x.trimStart().length));
+		const dedented = lines.map((x) => x.slice(minIndent)).map((x) => " ".repeat(this.indent * 2) + x);
+		for (const line of dedented) this.content.push(line);
+	}
+	compile() {
+		const F = Function;
+		const args = this?.args;
+		const lines = [...(this?.content ?? [``]).map((x) => `  ${x}`)];
+		return new F(...args, lines.join("\n"));
+	}
+};
+
 //#endregion
 //#region ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/core/versions.js
 const version = {
@@ -786,10 +1678,308 @@ const $ZodType = /* @__PURE__ */ $constructor("$ZodType", (inst, def) => {
 		version: 1
 	}));
 });
+const $ZodString = /* @__PURE__ */ $constructor("$ZodString", (inst, def) => {
+	$ZodType.init(inst, def);
+	inst._zod.pattern = [...inst?._zod.bag?.patterns ?? []].pop() ?? string$1(inst._zod.bag);
+	inst._zod.parse = (payload, _) => {
+		if (def.coerce) try {
+			payload.value = String(payload.value);
+		} catch (_$1) {}
+		if (typeof payload.value === "string") return payload;
+		payload.issues.push({
+			expected: "string",
+			code: "invalid_type",
+			input: payload.value,
+			inst
+		});
+		return payload;
+	};
+});
+const $ZodStringFormat = /* @__PURE__ */ $constructor("$ZodStringFormat", (inst, def) => {
+	$ZodCheckStringFormat.init(inst, def);
+	$ZodString.init(inst, def);
+});
+const $ZodGUID = /* @__PURE__ */ $constructor("$ZodGUID", (inst, def) => {
+	def.pattern ?? (def.pattern = guid);
+	$ZodStringFormat.init(inst, def);
+});
+const $ZodUUID = /* @__PURE__ */ $constructor("$ZodUUID", (inst, def) => {
+	if (def.version) {
+		const v = {
+			v1: 1,
+			v2: 2,
+			v3: 3,
+			v4: 4,
+			v5: 5,
+			v6: 6,
+			v7: 7,
+			v8: 8
+		}[def.version];
+		if (v === void 0) throw new Error(`Invalid UUID version: "${def.version}"`);
+		def.pattern ?? (def.pattern = uuid(v));
+	} else def.pattern ?? (def.pattern = uuid());
+	$ZodStringFormat.init(inst, def);
+});
+const $ZodEmail = /* @__PURE__ */ $constructor("$ZodEmail", (inst, def) => {
+	def.pattern ?? (def.pattern = email);
+	$ZodStringFormat.init(inst, def);
+});
+const $ZodURL = /* @__PURE__ */ $constructor("$ZodURL", (inst, def) => {
+	$ZodStringFormat.init(inst, def);
+	inst._zod.check = (payload) => {
+		try {
+			const trimmed = payload.value.trim();
+			const url = new URL(trimmed);
+			if (def.hostname) {
+				def.hostname.lastIndex = 0;
+				if (!def.hostname.test(url.hostname)) payload.issues.push({
+					code: "invalid_format",
+					format: "url",
+					note: "Invalid hostname",
+					pattern: def.hostname.source,
+					input: payload.value,
+					inst,
+					continue: !def.abort
+				});
+			}
+			if (def.protocol) {
+				def.protocol.lastIndex = 0;
+				if (!def.protocol.test(url.protocol.endsWith(":") ? url.protocol.slice(0, -1) : url.protocol)) payload.issues.push({
+					code: "invalid_format",
+					format: "url",
+					note: "Invalid protocol",
+					pattern: def.protocol.source,
+					input: payload.value,
+					inst,
+					continue: !def.abort
+				});
+			}
+			if (def.normalize) payload.value = url.href;
+			else payload.value = trimmed;
+			return;
+		} catch (_) {
+			payload.issues.push({
+				code: "invalid_format",
+				format: "url",
+				input: payload.value,
+				inst,
+				continue: !def.abort
+			});
+		}
+	};
+});
+const $ZodEmoji = /* @__PURE__ */ $constructor("$ZodEmoji", (inst, def) => {
+	def.pattern ?? (def.pattern = emoji());
+	$ZodStringFormat.init(inst, def);
+});
+const $ZodNanoID = /* @__PURE__ */ $constructor("$ZodNanoID", (inst, def) => {
+	def.pattern ?? (def.pattern = nanoid);
+	$ZodStringFormat.init(inst, def);
+});
+const $ZodCUID = /* @__PURE__ */ $constructor("$ZodCUID", (inst, def) => {
+	def.pattern ?? (def.pattern = cuid);
+	$ZodStringFormat.init(inst, def);
+});
+const $ZodCUID2 = /* @__PURE__ */ $constructor("$ZodCUID2", (inst, def) => {
+	def.pattern ?? (def.pattern = cuid2);
+	$ZodStringFormat.init(inst, def);
+});
+const $ZodULID = /* @__PURE__ */ $constructor("$ZodULID", (inst, def) => {
+	def.pattern ?? (def.pattern = ulid);
+	$ZodStringFormat.init(inst, def);
+});
+const $ZodXID = /* @__PURE__ */ $constructor("$ZodXID", (inst, def) => {
+	def.pattern ?? (def.pattern = xid);
+	$ZodStringFormat.init(inst, def);
+});
+const $ZodKSUID = /* @__PURE__ */ $constructor("$ZodKSUID", (inst, def) => {
+	def.pattern ?? (def.pattern = ksuid);
+	$ZodStringFormat.init(inst, def);
+});
+const $ZodISODateTime = /* @__PURE__ */ $constructor("$ZodISODateTime", (inst, def) => {
+	def.pattern ?? (def.pattern = datetime$1(def));
+	$ZodStringFormat.init(inst, def);
+});
+const $ZodISODate = /* @__PURE__ */ $constructor("$ZodISODate", (inst, def) => {
+	def.pattern ?? (def.pattern = date$1);
+	$ZodStringFormat.init(inst, def);
+});
+const $ZodISOTime = /* @__PURE__ */ $constructor("$ZodISOTime", (inst, def) => {
+	def.pattern ?? (def.pattern = time$1(def));
+	$ZodStringFormat.init(inst, def);
+});
+const $ZodISODuration = /* @__PURE__ */ $constructor("$ZodISODuration", (inst, def) => {
+	def.pattern ?? (def.pattern = duration$1);
+	$ZodStringFormat.init(inst, def);
+});
+const $ZodIPv4 = /* @__PURE__ */ $constructor("$ZodIPv4", (inst, def) => {
+	def.pattern ?? (def.pattern = ipv4);
+	$ZodStringFormat.init(inst, def);
+	inst._zod.bag.format = `ipv4`;
+});
+const $ZodIPv6 = /* @__PURE__ */ $constructor("$ZodIPv6", (inst, def) => {
+	def.pattern ?? (def.pattern = ipv6);
+	$ZodStringFormat.init(inst, def);
+	inst._zod.bag.format = `ipv6`;
+	inst._zod.check = (payload) => {
+		try {
+			new URL(`http://[${payload.value}]`);
+		} catch {
+			payload.issues.push({
+				code: "invalid_format",
+				format: "ipv6",
+				input: payload.value,
+				inst,
+				continue: !def.abort
+			});
+		}
+	};
+});
+const $ZodCIDRv4 = /* @__PURE__ */ $constructor("$ZodCIDRv4", (inst, def) => {
+	def.pattern ?? (def.pattern = cidrv4);
+	$ZodStringFormat.init(inst, def);
+});
+const $ZodCIDRv6 = /* @__PURE__ */ $constructor("$ZodCIDRv6", (inst, def) => {
+	def.pattern ?? (def.pattern = cidrv6);
+	$ZodStringFormat.init(inst, def);
+	inst._zod.check = (payload) => {
+		const parts = payload.value.split("/");
+		try {
+			if (parts.length !== 2) throw new Error();
+			const [address, prefix] = parts;
+			if (!prefix) throw new Error();
+			const prefixNum = Number(prefix);
+			if (`${prefixNum}` !== prefix) throw new Error();
+			if (prefixNum < 0 || prefixNum > 128) throw new Error();
+			new URL(`http://[${address}]`);
+		} catch {
+			payload.issues.push({
+				code: "invalid_format",
+				format: "cidrv6",
+				input: payload.value,
+				inst,
+				continue: !def.abort
+			});
+		}
+	};
+});
+function isValidBase64(data) {
+	if (data === "") return true;
+	if (data.length % 4 !== 0) return false;
+	try {
+		atob(data);
+		return true;
+	} catch {
+		return false;
+	}
+}
+const $ZodBase64 = /* @__PURE__ */ $constructor("$ZodBase64", (inst, def) => {
+	def.pattern ?? (def.pattern = base64);
+	$ZodStringFormat.init(inst, def);
+	inst._zod.bag.contentEncoding = "base64";
+	inst._zod.check = (payload) => {
+		if (isValidBase64(payload.value)) return;
+		payload.issues.push({
+			code: "invalid_format",
+			format: "base64",
+			input: payload.value,
+			inst,
+			continue: !def.abort
+		});
+	};
+});
+function isValidBase64URL(data) {
+	if (!base64url.test(data)) return false;
+	const base64$1 = data.replace(/[-_]/g, (c) => c === "-" ? "+" : "/");
+	return isValidBase64(base64$1.padEnd(Math.ceil(base64$1.length / 4) * 4, "="));
+}
+const $ZodBase64URL = /* @__PURE__ */ $constructor("$ZodBase64URL", (inst, def) => {
+	def.pattern ?? (def.pattern = base64url);
+	$ZodStringFormat.init(inst, def);
+	inst._zod.bag.contentEncoding = "base64url";
+	inst._zod.check = (payload) => {
+		if (isValidBase64URL(payload.value)) return;
+		payload.issues.push({
+			code: "invalid_format",
+			format: "base64url",
+			input: payload.value,
+			inst,
+			continue: !def.abort
+		});
+	};
+});
+const $ZodE164 = /* @__PURE__ */ $constructor("$ZodE164", (inst, def) => {
+	def.pattern ?? (def.pattern = e164);
+	$ZodStringFormat.init(inst, def);
+});
+function isValidJWT(token, algorithm = null) {
+	try {
+		const tokensParts = token.split(".");
+		if (tokensParts.length !== 3) return false;
+		const [header] = tokensParts;
+		if (!header) return false;
+		const parsedHeader = JSON.parse(atob(header));
+		if ("typ" in parsedHeader && parsedHeader?.typ !== "JWT") return false;
+		if (!parsedHeader.alg) return false;
+		if (algorithm && (!("alg" in parsedHeader) || parsedHeader.alg !== algorithm)) return false;
+		return true;
+	} catch {
+		return false;
+	}
+}
+const $ZodJWT = /* @__PURE__ */ $constructor("$ZodJWT", (inst, def) => {
+	$ZodStringFormat.init(inst, def);
+	inst._zod.check = (payload) => {
+		if (isValidJWT(payload.value, def.alg)) return;
+		payload.issues.push({
+			code: "invalid_format",
+			format: "jwt",
+			input: payload.value,
+			inst,
+			continue: !def.abort
+		});
+	};
+});
+const $ZodNumber = /* @__PURE__ */ $constructor("$ZodNumber", (inst, def) => {
+	$ZodType.init(inst, def);
+	inst._zod.pattern = inst._zod.bag.pattern ?? number$1;
+	inst._zod.parse = (payload, _ctx) => {
+		if (def.coerce) try {
+			payload.value = Number(payload.value);
+		} catch (_) {}
+		const input = payload.value;
+		if (typeof input === "number" && !Number.isNaN(input) && Number.isFinite(input)) return payload;
+		const received = typeof input === "number" ? Number.isNaN(input) ? "NaN" : !Number.isFinite(input) ? "Infinity" : void 0 : void 0;
+		payload.issues.push({
+			expected: "number",
+			code: "invalid_type",
+			input,
+			inst,
+			...received ? { received } : {}
+		});
+		return payload;
+	};
+});
+const $ZodNumberFormat = /* @__PURE__ */ $constructor("$ZodNumberFormat", (inst, def) => {
+	$ZodCheckNumberFormat.init(inst, def);
+	$ZodNumber.init(inst, def);
+});
 const $ZodUnknown = /* @__PURE__ */ $constructor("$ZodUnknown", (inst, def) => {
 	$ZodType.init(inst, def);
 	inst._zod.parse = (payload) => payload;
 });
+const $ZodNever = /* @__PURE__ */ $constructor("$ZodNever", (inst, def) => {
+	$ZodType.init(inst, def);
+	inst._zod.parse = (payload, _ctx) => {
+		payload.issues.push({
+			expected: "never",
+			code: "invalid_type",
+			input: payload.value,
+			inst
+		});
+		return payload;
+	};
+});
 function handleArrayResult(result, final, index) {
 	if (result.issues.length) final.issues.push(...prefixIssues(index, result.issues));
 	final.value[index] = result.value;
@@ -798,28 +1988,229 @@ const $ZodArray = /* @__PURE__ */ $constructor("$ZodArray", (inst, def) => {
 	$ZodType.init(inst, def);
 	inst._zod.parse = (payload, ctx) => {
 		const input = payload.value;
-		if (!Array.isArray(input)) {
+		if (!Array.isArray(input)) {
+			payload.issues.push({
+				expected: "array",
+				code: "invalid_type",
+				input,
+				inst
+			});
+			return payload;
+		}
+		payload.value = Array(input.length);
+		const proms = [];
+		for (let i = 0; i < input.length; i++) {
+			const item = input[i];
+			const result = def.element._zod.run({
+				value: item,
+				issues: []
+			}, ctx);
+			if (result instanceof Promise) proms.push(result.then((result$1) => handleArrayResult(result$1, payload, i)));
+			else handleArrayResult(result, payload, i);
+		}
+		if (proms.length) return Promise.all(proms).then(() => payload);
+		return payload;
+	};
+});
+function handlePropertyResult(result, final, key, input, isOptionalOut) {
+	if (result.issues.length) {
+		if (isOptionalOut && !(key in input)) return;
+		final.issues.push(...prefixIssues(key, result.issues));
+	}
+	if (result.value === void 0) {
+		if (key in input) final.value[key] = void 0;
+	} else final.value[key] = result.value;
+}
+function normalizeDef(def) {
+	const keys = Object.keys(def.shape);
+	for (const k of keys) if (!def.shape?.[k]?._zod?.traits?.has("$ZodType")) throw new Error(`Invalid element at key "${k}": expected a Zod schema`);
+	const okeys = optionalKeys(def.shape);
+	return {
+		...def,
+		keys,
+		keySet: new Set(keys),
+		numKeys: keys.length,
+		optionalKeys: new Set(okeys)
+	};
+}
+function handleCatchall(proms, input, payload, ctx, def, inst) {
+	const unrecognized = [];
+	const keySet = def.keySet;
+	const _catchall = def.catchall._zod;
+	const t = _catchall.def.type;
+	const isOptionalOut = _catchall.optout === "optional";
+	for (const key in input) {
+		if (keySet.has(key)) continue;
+		if (t === "never") {
+			unrecognized.push(key);
+			continue;
+		}
+		const r = _catchall.run({
+			value: input[key],
+			issues: []
+		}, ctx);
+		if (r instanceof Promise) proms.push(r.then((r$1) => handlePropertyResult(r$1, payload, key, input, isOptionalOut)));
+		else handlePropertyResult(r, payload, key, input, isOptionalOut);
+	}
+	if (unrecognized.length) payload.issues.push({
+		code: "unrecognized_keys",
+		keys: unrecognized,
+		input,
+		inst
+	});
+	if (!proms.length) return payload;
+	return Promise.all(proms).then(() => {
+		return payload;
+	});
+}
+const $ZodObject = /* @__PURE__ */ $constructor("$ZodObject", (inst, def) => {
+	$ZodType.init(inst, def);
+	if (!Object.getOwnPropertyDescriptor(def, "shape")?.get) {
+		const sh = def.shape;
+		Object.defineProperty(def, "shape", { get: () => {
+			const newSh = { ...sh };
+			Object.defineProperty(def, "shape", { value: newSh });
+			return newSh;
+		} });
+	}
+	const _normalized = cached(() => normalizeDef(def));
+	defineLazy(inst._zod, "propValues", () => {
+		const shape = def.shape;
+		const propValues = {};
+		for (const key in shape) {
+			const field = shape[key]._zod;
+			if (field.values) {
+				propValues[key] ?? (propValues[key] = /* @__PURE__ */ new Set());
+				for (const v of field.values) propValues[key].add(v);
+			}
+		}
+		return propValues;
+	});
+	const isObject$1 = isObject;
+	const catchall = def.catchall;
+	let value;
+	inst._zod.parse = (payload, ctx) => {
+		value ?? (value = _normalized.value);
+		const input = payload.value;
+		if (!isObject$1(input)) {
+			payload.issues.push({
+				expected: "object",
+				code: "invalid_type",
+				input,
+				inst
+			});
+			return payload;
+		}
+		payload.value = {};
+		const proms = [];
+		const shape = value.shape;
+		for (const key of value.keys) {
+			const el = shape[key];
+			const isOptionalOut = el._zod.optout === "optional";
+			const r = el._zod.run({
+				value: input[key],
+				issues: []
+			}, ctx);
+			if (r instanceof Promise) proms.push(r.then((r$1) => handlePropertyResult(r$1, payload, key, input, isOptionalOut)));
+			else handlePropertyResult(r, payload, key, input, isOptionalOut);
+		}
+		if (!catchall) return proms.length ? Promise.all(proms).then(() => payload) : payload;
+		return handleCatchall(proms, input, payload, ctx, _normalized.value, inst);
+	};
+});
+const $ZodObjectJIT = /* @__PURE__ */ $constructor("$ZodObjectJIT", (inst, def) => {
+	$ZodObject.init(inst, def);
+	const superParse = inst._zod.parse;
+	const _normalized = cached(() => normalizeDef(def));
+	const generateFastpass = (shape) => {
+		const doc = new Doc([
+			"shape",
+			"payload",
+			"ctx"
+		]);
+		const normalized = _normalized.value;
+		const parseStr = (key) => {
+			const k = esc(key);
+			return `shape[${k}]._zod.run({ value: input[${k}], issues: [] }, ctx)`;
+		};
+		doc.write(`const input = payload.value;`);
+		const ids = Object.create(null);
+		let counter = 0;
+		for (const key of normalized.keys) ids[key] = `key_${counter++}`;
+		doc.write(`const newResult = {};`);
+		for (const key of normalized.keys) {
+			const id = ids[key];
+			const k = esc(key);
+			const isOptionalOut = shape[key]?._zod?.optout === "optional";
+			doc.write(`const ${id} = ${parseStr(key)};`);
+			if (isOptionalOut) doc.write(`
+        if (${id}.issues.length) {
+          if (${k} in input) {
+            payload.issues = payload.issues.concat(${id}.issues.map(iss => ({
+              ...iss,
+              path: iss.path ? [${k}, ...iss.path] : [${k}]
+            })));
+          }
+        }
+        
+        if (${id}.value === undefined) {
+          if (${k} in input) {
+            newResult[${k}] = undefined;
+          }
+        } else {
+          newResult[${k}] = ${id}.value;
+        }
+        
+      `);
+			else doc.write(`
+        if (${id}.issues.length) {
+          payload.issues = payload.issues.concat(${id}.issues.map(iss => ({
+            ...iss,
+            path: iss.path ? [${k}, ...iss.path] : [${k}]
+          })));
+        }
+        
+        if (${id}.value === undefined) {
+          if (${k} in input) {
+            newResult[${k}] = undefined;
+          }
+        } else {
+          newResult[${k}] = ${id}.value;
+        }
+        
+      `);
+		}
+		doc.write(`payload.value = newResult;`);
+		doc.write(`return payload;`);
+		const fn = doc.compile();
+		return (payload, ctx) => fn(shape, payload, ctx);
+	};
+	let fastpass;
+	const isObject$1 = isObject;
+	const jit = !globalConfig.jitless;
+	const allowsEval$1 = allowsEval;
+	const fastEnabled = jit && allowsEval$1.value;
+	const catchall = def.catchall;
+	let value;
+	inst._zod.parse = (payload, ctx) => {
+		value ?? (value = _normalized.value);
+		const input = payload.value;
+		if (!isObject$1(input)) {
 			payload.issues.push({
-				expected: "array",
+				expected: "object",
 				code: "invalid_type",
 				input,
 				inst
 			});
 			return payload;
 		}
-		payload.value = Array(input.length);
-		const proms = [];
-		for (let i = 0; i < input.length; i++) {
-			const item = input[i];
-			const result = def.element._zod.run({
-				value: item,
-				issues: []
-			}, ctx);
-			if (result instanceof Promise) proms.push(result.then((result$1) => handleArrayResult(result$1, payload, i)));
-			else handleArrayResult(result, payload, i);
+		if (jit && fastEnabled && ctx?.async === false && ctx.jitless !== true) {
+			if (!fastpass) fastpass = generateFastpass(def.shape);
+			payload = fastpass(payload, ctx);
+			if (!catchall) return payload;
+			return handleCatchall([], input, payload, ctx, value, inst);
 		}
-		if (proms.length) return Promise.all(proms).then(() => payload);
-		return payload;
+		return superParse(payload, ctx);
 	};
 });
 function handleUnionResults(results, final, inst, ctx) {
@@ -977,6 +2368,115 @@ function handleIntersectionResults(result, left, right) {
 	result.value = merged.data;
 	return result;
 }
+const $ZodRecord = /* @__PURE__ */ $constructor("$ZodRecord", (inst, def) => {
+	$ZodType.init(inst, def);
+	inst._zod.parse = (payload, ctx) => {
+		const input = payload.value;
+		if (!isPlainObject(input)) {
+			payload.issues.push({
+				expected: "record",
+				code: "invalid_type",
+				input,
+				inst
+			});
+			return payload;
+		}
+		const proms = [];
+		const values = def.keyType._zod.values;
+		if (values) {
+			payload.value = {};
+			const recordKeys = /* @__PURE__ */ new Set();
+			for (const key of values) if (typeof key === "string" || typeof key === "number" || typeof key === "symbol") {
+				recordKeys.add(typeof key === "number" ? key.toString() : key);
+				const result = def.valueType._zod.run({
+					value: input[key],
+					issues: []
+				}, ctx);
+				if (result instanceof Promise) proms.push(result.then((result$1) => {
+					if (result$1.issues.length) payload.issues.push(...prefixIssues(key, result$1.issues));
+					payload.value[key] = result$1.value;
+				}));
+				else {
+					if (result.issues.length) payload.issues.push(...prefixIssues(key, result.issues));
+					payload.value[key] = result.value;
+				}
+			}
+			let unrecognized;
+			for (const key in input) if (!recordKeys.has(key)) {
+				unrecognized = unrecognized ?? [];
+				unrecognized.push(key);
+			}
+			if (unrecognized && unrecognized.length > 0) payload.issues.push({
+				code: "unrecognized_keys",
+				input,
+				inst,
+				keys: unrecognized
+			});
+		} else {
+			payload.value = {};
+			for (const key of Reflect.ownKeys(input)) {
+				if (key === "__proto__") continue;
+				let keyResult = def.keyType._zod.run({
+					value: key,
+					issues: []
+				}, ctx);
+				if (keyResult instanceof Promise) throw new Error("Async schemas not supported in object keys currently");
+				if (typeof key === "string" && number$1.test(key) && keyResult.issues.length) {
+					const retryResult = def.keyType._zod.run({
+						value: Number(key),
+						issues: []
+					}, ctx);
+					if (retryResult instanceof Promise) throw new Error("Async schemas not supported in object keys currently");
+					if (retryResult.issues.length === 0) keyResult = retryResult;
+				}
+				if (keyResult.issues.length) {
+					if (def.mode === "loose") payload.value[key] = input[key];
+					else payload.issues.push({
+						code: "invalid_key",
+						origin: "record",
+						issues: keyResult.issues.map((iss) => finalizeIssue(iss, ctx, config())),
+						input: key,
+						path: [key],
+						inst
+					});
+					continue;
+				}
+				const result = def.valueType._zod.run({
+					value: input[key],
+					issues: []
+				}, ctx);
+				if (result instanceof Promise) proms.push(result.then((result$1) => {
+					if (result$1.issues.length) payload.issues.push(...prefixIssues(key, result$1.issues));
+					payload.value[keyResult.value] = result$1.value;
+				}));
+				else {
+					if (result.issues.length) payload.issues.push(...prefixIssues(key, result.issues));
+					payload.value[keyResult.value] = result.value;
+				}
+			}
+		}
+		if (proms.length) return Promise.all(proms).then(() => payload);
+		return payload;
+	};
+});
+const $ZodEnum = /* @__PURE__ */ $constructor("$ZodEnum", (inst, def) => {
+	$ZodType.init(inst, def);
+	const values = getEnumValues(def.entries);
+	const valuesSet = new Set(values);
+	inst._zod.values = valuesSet;
+	inst._zod.pattern = /* @__PURE__ */ new RegExp(`^(${values.filter((k) => propertyKeyTypes.has(typeof k)).map((o) => typeof o === "string" ? escapeRegex(o) : o.toString()).join("|")})$`);
+	inst._zod.parse = (payload, _ctx) => {
+		const input = payload.value;
+		if (valuesSet.has(input)) return payload;
+		payload.issues.push({
+			code: "invalid_value",
+			values,
+			input,
+			inst
+		});
+		return payload;
+	};
+});
 const $ZodTransform = /* @__PURE__ */ $constructor("$ZodTransform", (inst, def) => {
 	$ZodType.init(inst, def);
 	inst._zod.parse = (payload, ctx) => {
@@ -1252,10 +2752,349 @@ const globalRegistry = globalThis.__zod_globalRegistry;
 //#endregion
 //#region ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/core/api.js
 /* @__NO_SIDE_EFFECTS__ */
+function _string(Class, params) {
+	return new Class({
+		type: "string",
+		...normalizeParams(params)
+	});
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _email(Class, params) {
+	return new Class({
+		type: "string",
+		format: "email",
+		check: "string_format",
+		abort: false,
+		...normalizeParams(params)
+	});
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _guid(Class, params) {
+	return new Class({
+		type: "string",
+		format: "guid",
+		check: "string_format",
+		abort: false,
+		...normalizeParams(params)
+	});
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _uuid(Class, params) {
+	return new Class({
+		type: "string",
+		format: "uuid",
+		check: "string_format",
+		abort: false,
+		...normalizeParams(params)
+	});
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _uuidv4(Class, params) {
+	return new Class({
+		type: "string",
+		format: "uuid",
+		check: "string_format",
+		abort: false,
+		version: "v4",
+		...normalizeParams(params)
+	});
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _uuidv6(Class, params) {
+	return new Class({
+		type: "string",
+		format: "uuid",
+		check: "string_format",
+		abort: false,
+		version: "v6",
+		...normalizeParams(params)
+	});
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _uuidv7(Class, params) {
+	return new Class({
+		type: "string",
+		format: "uuid",
+		check: "string_format",
+		abort: false,
+		version: "v7",
+		...normalizeParams(params)
+	});
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _url(Class, params) {
+	return new Class({
+		type: "string",
+		format: "url",
+		check: "string_format",
+		abort: false,
+		...normalizeParams(params)
+	});
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _emoji(Class, params) {
+	return new Class({
+		type: "string",
+		format: "emoji",
+		check: "string_format",
+		abort: false,
+		...normalizeParams(params)
+	});
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _nanoid(Class, params) {
+	return new Class({
+		type: "string",
+		format: "nanoid",
+		check: "string_format",
+		abort: false,
+		...normalizeParams(params)
+	});
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _cuid(Class, params) {
+	return new Class({
+		type: "string",
+		format: "cuid",
+		check: "string_format",
+		abort: false,
+		...normalizeParams(params)
+	});
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _cuid2(Class, params) {
+	return new Class({
+		type: "string",
+		format: "cuid2",
+		check: "string_format",
+		abort: false,
+		...normalizeParams(params)
+	});
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _ulid(Class, params) {
+	return new Class({
+		type: "string",
+		format: "ulid",
+		check: "string_format",
+		abort: false,
+		...normalizeParams(params)
+	});
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _xid(Class, params) {
+	return new Class({
+		type: "string",
+		format: "xid",
+		check: "string_format",
+		abort: false,
+		...normalizeParams(params)
+	});
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _ksuid(Class, params) {
+	return new Class({
+		type: "string",
+		format: "ksuid",
+		check: "string_format",
+		abort: false,
+		...normalizeParams(params)
+	});
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _ipv4(Class, params) {
+	return new Class({
+		type: "string",
+		format: "ipv4",
+		check: "string_format",
+		abort: false,
+		...normalizeParams(params)
+	});
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _ipv6(Class, params) {
+	return new Class({
+		type: "string",
+		format: "ipv6",
+		check: "string_format",
+		abort: false,
+		...normalizeParams(params)
+	});
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _cidrv4(Class, params) {
+	return new Class({
+		type: "string",
+		format: "cidrv4",
+		check: "string_format",
+		abort: false,
+		...normalizeParams(params)
+	});
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _cidrv6(Class, params) {
+	return new Class({
+		type: "string",
+		format: "cidrv6",
+		check: "string_format",
+		abort: false,
+		...normalizeParams(params)
+	});
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _base64(Class, params) {
+	return new Class({
+		type: "string",
+		format: "base64",
+		check: "string_format",
+		abort: false,
+		...normalizeParams(params)
+	});
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _base64url(Class, params) {
+	return new Class({
+		type: "string",
+		format: "base64url",
+		check: "string_format",
+		abort: false,
+		...normalizeParams(params)
+	});
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _e164(Class, params) {
+	return new Class({
+		type: "string",
+		format: "e164",
+		check: "string_format",
+		abort: false,
+		...normalizeParams(params)
+	});
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _jwt(Class, params) {
+	return new Class({
+		type: "string",
+		format: "jwt",
+		check: "string_format",
+		abort: false,
+		...normalizeParams(params)
+	});
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _isoDateTime(Class, params) {
+	return new Class({
+		type: "string",
+		format: "datetime",
+		check: "string_format",
+		offset: false,
+		local: false,
+		precision: null,
+		...normalizeParams(params)
+	});
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _isoDate(Class, params) {
+	return new Class({
+		type: "string",
+		format: "date",
+		check: "string_format",
+		...normalizeParams(params)
+	});
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _isoTime(Class, params) {
+	return new Class({
+		type: "string",
+		format: "time",
+		check: "string_format",
+		precision: null,
+		...normalizeParams(params)
+	});
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _isoDuration(Class, params) {
+	return new Class({
+		type: "string",
+		format: "duration",
+		check: "string_format",
+		...normalizeParams(params)
+	});
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _number(Class, params) {
+	return new Class({
+		type: "number",
+		checks: [],
+		...normalizeParams(params)
+	});
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _int(Class, params) {
+	return new Class({
+		type: "number",
+		check: "number_format",
+		abort: false,
+		format: "safeint",
+		...normalizeParams(params)
+	});
+}
+/* @__NO_SIDE_EFFECTS__ */
 function _unknown(Class) {
 	return new Class({ type: "unknown" });
 }
 /* @__NO_SIDE_EFFECTS__ */
+function _never(Class, params) {
+	return new Class({
+		type: "never",
+		...normalizeParams(params)
+	});
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _lt(value, params) {
+	return new $ZodCheckLessThan({
+		check: "less_than",
+		...normalizeParams(params),
+		value,
+		inclusive: false
+	});
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _lte(value, params) {
+	return new $ZodCheckLessThan({
+		check: "less_than",
+		...normalizeParams(params),
+		value,
+		inclusive: true
+	});
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _gt(value, params) {
+	return new $ZodCheckGreaterThan({
+		check: "greater_than",
+		...normalizeParams(params),
+		value,
+		inclusive: false
+	});
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _gte(value, params) {
+	return new $ZodCheckGreaterThan({
+		check: "greater_than",
+		...normalizeParams(params),
+		value,
+		inclusive: true
+	});
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _multipleOf(value, params) {
+	return new $ZodCheckMultipleOf({
+		check: "multiple_of",
+		...normalizeParams(params),
+		value
+	});
+}
+/* @__NO_SIDE_EFFECTS__ */
 function _maxLength(maximum, params) {
 	return new $ZodCheckMaxLength({
 		check: "max_length",
@@ -1280,6 +3119,58 @@ function _length(length, params) {
 	});
 }
 /* @__NO_SIDE_EFFECTS__ */
+function _regex(pattern, params) {
+	return new $ZodCheckRegex({
+		check: "string_format",
+		format: "regex",
+		...normalizeParams(params),
+		pattern
+	});
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _lowercase(params) {
+	return new $ZodCheckLowerCase({
+		check: "string_format",
+		format: "lowercase",
+		...normalizeParams(params)
+	});
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _uppercase(params) {
+	return new $ZodCheckUpperCase({
+		check: "string_format",
+		format: "uppercase",
+		...normalizeParams(params)
+	});
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _includes(includes, params) {
+	return new $ZodCheckIncludes({
+		check: "string_format",
+		format: "includes",
+		...normalizeParams(params),
+		includes
+	});
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _startsWith(prefix, params) {
+	return new $ZodCheckStartsWith({
+		check: "string_format",
+		format: "starts_with",
+		...normalizeParams(params),
+		prefix
+	});
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _endsWith(suffix, params) {
+	return new $ZodCheckEndsWith({
+		check: "string_format",
+		format: "ends_with",
+		...normalizeParams(params),
+		suffix
+	});
+}
+/* @__NO_SIDE_EFFECTS__ */
 function _overwrite(tx) {
 	return new $ZodCheckOverwrite({
 		check: "overwrite",
@@ -1287,6 +3178,26 @@ function _overwrite(tx) {
 	});
 }
 /* @__NO_SIDE_EFFECTS__ */
+function _normalize(form) {
+	return /* @__PURE__ */ _overwrite((input) => input.normalize(form));
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _trim() {
+	return /* @__PURE__ */ _overwrite((input) => input.trim());
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _toLowerCase() {
+	return /* @__PURE__ */ _overwrite((input) => input.toLowerCase());
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _toUpperCase() {
+	return /* @__PURE__ */ _overwrite((input) => input.toUpperCase());
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _slugify() {
+	return /* @__PURE__ */ _overwrite((input) => slugify(input));
+}
+/* @__NO_SIDE_EFFECTS__ */
 function _array(Class, element, params) {
 	return new Class({
 		type: "array",
@@ -2130,58 +4041,40 @@ let AIAgentExecutionHelpersFactory = class AIAgentExecutionHelpersFactory$1 {
 	createConnectionCredentialExecutionContextFactory(credentialSessions) {
 		return new ConnectionCredentialExecutionContextFactory(credentialSessions);
 	}
-	createDynamicStructuredTool(entry, toolCredentialContext, item, itemIndex, items) {
-		if (entry.runtime.inputSchema == null) throw new Error(`Cannot create LangChain tool "${entry.config.name}": missing inputSchema (broken tool runtime resolution).`);
-		const schemaForOpenAi = this.createJsonSchemaRecord(entry.runtime.inputSchema, {
-			schemaName: entry.config.name,
-			requireObjectRoot: true
-		});
-		return new __langchain_core_tools.DynamicStructuredTool({
-			name: entry.config.name,
-			description: entry.config.description ?? entry.runtime.defaultDescription,
-			schema: schemaForOpenAi,
-			func: async (input) => {
-				const result = await entry.runtime.execute({
-					config: entry.config,
-					input,
-					ctx: toolCredentialContext,
-					item,
-					itemIndex,
-					items
-				});
-				return JSON.stringify(result);
-			}
-		});
-	}
 	/**
-	* Produces a plain JSON Schema object for OpenAI tool parameters and LangChain tool invocation:
-	* - **Zod** → `toJSONSchema(..., { target: "draft-07" })` so shapes match what `@cfworker/json-schema`
-	*   expects (`required` must be an array; draft 2020-12 output can break validation).
-	* - Otherwise LangChain `toJsonSchema` (Standard Schema + JSON passthrough); if the result is still Zod
-	*   (duplicate `zod` copies), fall back to Zod `toJSONSchema` with draft-07.
-	* - Strip root `$schema` for OpenAI; normalize invalid `required` keywords for cfworker; ensure `properties`.
+	* Produces a plain JSON Schema object (`draft-07`) from a Zod schema, as needed by
+	* OpenAI tool-parameter schemas and the structured-output repair prompt.
+	* - Prefers the schema's **instance** `toJSONSchema(...)` method so we stay inside the Zod
+	*   instance that created the schema (works across consumer/framework tsx namespaces — see
+	*   {@link ZodInstanceToJsonSchema}). Falls back to the framework-imported module function.
+	* - Strips root `$schema` (OpenAI ignores it).
+	* - Sanitizes `required` for cfworker json-schema compatibility (must be a string array or absent).
 	*/
 	createJsonSchemaRecord(inputSchema, options) {
-		const draft07Params = { target: "draft-07" };
-		let converted;
-		if ((0, __langchain_core_utils_types.isInteropZodSchema)(inputSchema)) converted = toJSONSchema(inputSchema, draft07Params);
-		else {
-			converted = (0, __langchain_core_utils_json_schema.toJsonSchema)(inputSchema);
-			if ((0, __langchain_core_utils_types.isInteropZodSchema)(converted)) converted = toJSONSchema(inputSchema, draft07Params);
-		}
-		const { $schema: _draftSchemaOmitted,...rest } = converted;
-		if (options.requireObjectRoot && rest.type !== "object") throw new Error(`Cannot create LangChain tool "${options.schemaName}": tool input schema must be a JSON Schema object type (got type=${String(rest.type)}).`);
-		if (options.requireObjectRoot && rest.properties !== void 0 && (typeof rest.properties !== "object" || Array.isArray(rest.properties))) throw new Error(`Cannot create LangChain tool "${options.schemaName}": tool input schema "properties" must be an object (got ${JSON.stringify(rest.properties)}).`);
+		const { $schema: _draftSchemaOmitted,...rest } = this.convertZodSchemaToJsonSchema(inputSchema, { target: "draft-07" });
+		if (options.requireObjectRoot && rest.type !== "object") throw new Error(`Cannot create tool "${options.schemaName}": tool input schema must be a JSON Schema object type (got type=${String(rest.type)}).`);
+		if (options.requireObjectRoot && rest.properties !== void 0 && (typeof rest.properties !== "object" || Array.isArray(rest.properties))) throw new Error(`Cannot create tool "${options.schemaName}": tool input schema "properties" must be an object (got ${JSON.stringify(rest.properties)}).`);
 		if (options.requireObjectRoot && rest.properties === void 0) rest.properties = {};
 		this.sanitizeJsonSchemaRequiredKeywordsForCfworker(rest);
 		return rest;
 	}
 	/**
+	* Runs Zod's `toJSONSchema` via the schema's own instance method when available, so consumer
+	* schemas loaded under a different tsx namespace still convert correctly. If the caller handed us
+	* a payload that lacks that method (e.g. a plain JSON Schema record or a Zod instance whose
+	* prototype was stripped), we fall back to the framework-bundled module function.
+	*/
+	convertZodSchemaToJsonSchema(inputSchema, params) {
+		const candidate = inputSchema.toJSONSchema;
+		if (typeof candidate === "function") return candidate.call(inputSchema, params);
+		return toJSONSchema(inputSchema, params);
+	}
+	/**
 	* `@cfworker/json-schema` iterates `schema.required` with `for...of`; it must be a string array or absent.
 	*/
-	sanitizeJsonSchemaRequiredKeywordsForCfworker(node$16) {
-		if (!node$16 || typeof node$16 !== "object" || Array.isArray(node$16)) return;
-		const o = node$16;
+	sanitizeJsonSchemaRequiredKeywordsForCfworker(node$20) {
+		if (!node$20 || typeof node$20 !== "object" || Array.isArray(node$20)) return;
+		const o = node$20;
 		const req = o.required;
 		if (req !== void 0 && !Array.isArray(req)) delete o.required;
 		else if (Array.isArray(req)) {
@@ -2223,6 +4116,214 @@ function __decorateParam(paramIndex, decorator) {
 	};
 }
 
+//#endregion
+//#region src/chatModels/OpenAiStrictJsonSchemaFactory.ts
+var _ref$5;
+let OpenAiStrictJsonSchemaFactory = class OpenAiStrictJsonSchemaFactory$1 {
+	constructor(executionHelpers) {
+		this.executionHelpers = executionHelpers;
+	}
+	createStructuredOutputRecord(schema, options) {
+		const record$1 = this.executionHelpers.createJsonSchemaRecord(schema, {
+			schemaName: options.schemaName,
+			requireObjectRoot: false
+		});
+		this.strictifyRecursive(record$1);
+		if (options.title !== void 0) record$1.title = options.title;
+		return record$1;
+	}
+	strictifyRecursive(node$20) {
+		if (!node$20 || typeof node$20 !== "object" || Array.isArray(node$20)) return;
+		const o = node$20;
+		this.stripOpenAiRejectedKeywords(o);
+		if (this.isObjectNode(o)) {
+			const props = this.readPropertiesObject(o);
+			o.properties = props;
+			o.additionalProperties = false;
+			o.required = Object.keys(props);
+			for (const value of Object.values(props)) this.strictifyRecursive(value);
+		}
+		this.recurseIntoComposites(o);
+	}
+	stripOpenAiRejectedKeywords(o) {
+		delete o["$schema"];
+		delete o["unevaluatedProperties"];
+		delete o["default"];
+	}
+	isObjectNode(o) {
+		const typeIsObject = o.type === "object" || Array.isArray(o.type) && o.type.includes("object");
+		const hasObjectProperties = o.properties !== void 0 && typeof o.properties === "object" && !Array.isArray(o.properties);
+		return typeIsObject || hasObjectProperties;
+	}
+	readPropertiesObject(o) {
+		if (o.properties && typeof o.properties === "object" && !Array.isArray(o.properties)) return o.properties;
+		return {};
+	}
+	recurseIntoComposites(o) {
+		for (const key of [
+			"allOf",
+			"anyOf",
+			"oneOf",
+			"prefixItems"
+		]) {
+			const branch = o[key];
+			if (Array.isArray(branch)) for (const sub of branch) this.strictifyRecursive(sub);
+		}
+		if (o.not) this.strictifyRecursive(o.not);
+		if (o.items) if (Array.isArray(o.items)) for (const sub of o.items) this.strictifyRecursive(sub);
+		else this.strictifyRecursive(o.items);
+		for (const key of [
+			"if",
+			"then",
+			"else"
+		]) if (o[key]) this.strictifyRecursive(o[key]);
+		for (const key of ["$defs", "definitions"]) {
+			const defs = o[key];
+			if (defs && typeof defs === "object" && !Array.isArray(defs)) for (const sub of Object.values(defs)) this.strictifyRecursive(sub);
+		}
+	}
+};
+OpenAiStrictJsonSchemaFactory = __decorate([
+	(0, __codemation_core.injectable)(),
+	__decorateParam(0, (0, __codemation_core.inject)(AIAgentExecutionHelpersFactory)),
+	__decorateMetadata("design:paramtypes", [typeof (_ref$5 = typeof AIAgentExecutionHelpersFactory !== "undefined" && AIAgentExecutionHelpersFactory) === "function" ? _ref$5 : Object])
+], OpenAiStrictJsonSchemaFactory);
+
+//#endregion
+//#region src/chatModels/openAiChatModelConfig.ts
+var OpenAIChatModelConfig = class {
+	type = OpenAIChatModelFactory;
+	presentation;
+	provider = "openai";
+	modelName;
+	constructor(name, model, credentialSlotKey = "openai", presentationIn, options) {
+		this.name = name;
+		this.model = model;
+		this.credentialSlotKey = credentialSlotKey;
+		this.options = options;
+		this.modelName = model;
+		this.presentation = presentationIn ?? {
+			icon: "builtin:openai",
+			label: name
+		};
+	}
+	getCredentialRequirements() {
+		return [{
+			slotKey: this.credentialSlotKey,
+			label: "OpenAI API key",
+			acceptedTypes: ["openai.apiKey"]
+		}];
+	}
+};
+
+//#endregion
+//#region src/chatModels/OpenAiChatModelPresetsFactory.ts
+/**
+* Default OpenAI chat model configs for scaffolds and demos (icon + label match {@link OpenAIChatModelConfig} defaults).
+* Prefer importing {@link openAiChatModelPresets} from here or from the consumer template re-export
+* instead of repeating {@link OpenAIChatModelConfig} construction in app workflows.
+*/
+var OpenAiChatModelPresets = class {
+	demoGpt4oMini = new OpenAIChatModelConfig("OpenAI", "gpt-4o-mini");
+	demoGpt41 = new OpenAIChatModelConfig("OpenAI", "gpt-4.1");
+};
+const openAiChatModelPresets = new OpenAiChatModelPresets();
+
+//#endregion
+//#region src/nodes/AgentMessageFactory.ts
+/**
+* AI-SDK-shaped message construction for the AIAgent stack. Emits plain `ModelMessage[]`
+* ( `{ role: 'system' | 'user' | 'assistant' | 'tool', content: ... }` ) as consumed by
+* `generateText({ messages })` from the `ai` package.
+*/
+var AgentMessageFactory = class AgentMessageFactory {
+	static createPromptMessages(messages) {
+		return messages.map((message) => this.createPromptMessage(message));
+	}
+	/**
+	* Builds the assistant message that contains optional text plus one or more tool-call parts,
+	* matching the shape AI SDK emits between steps.
+	*/
+	static createAssistantWithToolCalls(text, toolCalls) {
+		const content = [];
+		if (text && text.length > 0) content.push({
+			type: "text",
+			text
+		});
+		for (const toolCall of toolCalls) content.push({
+			type: "tool-call",
+			toolCallId: toolCall.id ?? toolCall.name,
+			toolName: toolCall.name,
+			input: toolCall.input ?? {}
+		});
+		return {
+			role: "assistant",
+			content
+		};
+	}
+	/**
+	* Builds the `{ role: "tool", content: [{ type: "tool-result", ... }, ...] }` message returned
+	* to the model after each tool round.
+	*/
+	static createToolResultsMessage(executedToolCalls) {
+		return {
+			role: "tool",
+			content: executedToolCalls.map((executed) => ({
+				type: "tool-result",
+				toolCallId: executed.toolCallId,
+				toolName: executed.toolName,
+				output: {
+					type: "json",
+					value: AgentMessageFactory.toToolResultJson(executed.result)
+				}
+			}))
+		};
+	}
+	static toToolResultJson(value) {
+		if (value === void 0) return null;
+		try {
+			return JSON.parse(JSON.stringify(value));
+		} catch {
+			return String(value);
+		}
+	}
+	static createPromptMessage(message) {
+		if (message.role === "system") return {
+			role: "system",
+			content: message.content
+		};
+		if (message.role === "assistant") return {
+			role: "assistant",
+			content: message.content
+		};
+		return {
+			role: "user",
+			content: message.content
+		};
+	}
+};
+
+//#endregion
+//#region src/nodes/AgentOutputFactory.ts
+var AgentOutputFactory = class {
+	static fromUnknown(value) {
+		return { main: [{ json: value }] };
+	}
+	static replaceJson(item, value) {
+		return {
+			...item,
+			json: value
+		};
+	}
+	static fromAgentContent(content) {
+		try {
+			return JSON.parse(content);
+		} catch {
+			return { output: content };
+		}
+	}
+};
+
 //#endregion
 //#region src/nodes/AgentStructuredOutputRepairPromptFactory.ts
 var _ref$4, _AgentStructuredOutputRepairPromptFactory;
@@ -2263,6 +4364,37 @@ AgentStructuredOutputRepairPromptFactory = _AgentStructuredOutputRepairPromptFac
 	__decorateMetadata("design:paramtypes", [typeof (_ref$4 = typeof AIAgentExecutionHelpersFactory !== "undefined" && AIAgentExecutionHelpersFactory) === "function" ? _ref$4 : Object])
 ], AgentStructuredOutputRepairPromptFactory);
 
+//#endregion
+//#region ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/classic/iso.js
+const ZodISODateTime = /* @__PURE__ */ $constructor("ZodISODateTime", (inst, def) => {
+	$ZodISODateTime.init(inst, def);
+	ZodStringFormat.init(inst, def);
+});
+function datetime(params) {
+	return _isoDateTime(ZodISODateTime, params);
+}
+const ZodISODate = /* @__PURE__ */ $constructor("ZodISODate", (inst, def) => {
+	$ZodISODate.init(inst, def);
+	ZodStringFormat.init(inst, def);
+});
+function date(params) {
+	return _isoDate(ZodISODate, params);
+}
+const ZodISOTime = /* @__PURE__ */ $constructor("ZodISOTime", (inst, def) => {
+	$ZodISOTime.init(inst, def);
+	ZodStringFormat.init(inst, def);
+});
+function time(params) {
+	return _isoTime(ZodISOTime, params);
+}
+const ZodISODuration = /* @__PURE__ */ $constructor("ZodISODuration", (inst, def) => {
+	$ZodISODuration.init(inst, def);
+	ZodStringFormat.init(inst, def);
+});
+function duration(params) {
+	return _isoDuration(ZodISODuration, params);
+}
+
 //#endregion
 //#region ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/classic/errors.js
 const initializer = (inst, issues) => {
@@ -2380,6 +4512,181 @@ const ZodType = /* @__PURE__ */ $constructor("ZodType", (inst, def) => {
 	inst.apply = (fn) => fn(inst);
 	return inst;
 });
+/** @internal */
+const _ZodString = /* @__PURE__ */ $constructor("_ZodString", (inst, def) => {
+	$ZodString.init(inst, def);
+	ZodType.init(inst, def);
+	inst._zod.processJSONSchema = (ctx, json, params) => stringProcessor(inst, ctx, json, params);
+	const bag = inst._zod.bag;
+	inst.format = bag.format ?? null;
+	inst.minLength = bag.minimum ?? null;
+	inst.maxLength = bag.maximum ?? null;
+	inst.regex = (...args) => inst.check(_regex(...args));
+	inst.includes = (...args) => inst.check(_includes(...args));
+	inst.startsWith = (...args) => inst.check(_startsWith(...args));
+	inst.endsWith = (...args) => inst.check(_endsWith(...args));
+	inst.min = (...args) => inst.check(_minLength(...args));
+	inst.max = (...args) => inst.check(_maxLength(...args));
+	inst.length = (...args) => inst.check(_length(...args));
+	inst.nonempty = (...args) => inst.check(_minLength(1, ...args));
+	inst.lowercase = (params) => inst.check(_lowercase(params));
+	inst.uppercase = (params) => inst.check(_uppercase(params));
+	inst.trim = () => inst.check(_trim());
+	inst.normalize = (...args) => inst.check(_normalize(...args));
+	inst.toLowerCase = () => inst.check(_toLowerCase());
+	inst.toUpperCase = () => inst.check(_toUpperCase());
+	inst.slugify = () => inst.check(_slugify());
+});
+const ZodString = /* @__PURE__ */ $constructor("ZodString", (inst, def) => {
+	$ZodString.init(inst, def);
+	_ZodString.init(inst, def);
+	inst.email = (params) => inst.check(_email(ZodEmail, params));
+	inst.url = (params) => inst.check(_url(ZodURL, params));
+	inst.jwt = (params) => inst.check(_jwt(ZodJWT, params));
+	inst.emoji = (params) => inst.check(_emoji(ZodEmoji, params));
+	inst.guid = (params) => inst.check(_guid(ZodGUID, params));
+	inst.uuid = (params) => inst.check(_uuid(ZodUUID, params));
+	inst.uuidv4 = (params) => inst.check(_uuidv4(ZodUUID, params));
+	inst.uuidv6 = (params) => inst.check(_uuidv6(ZodUUID, params));
+	inst.uuidv7 = (params) => inst.check(_uuidv7(ZodUUID, params));
+	inst.nanoid = (params) => inst.check(_nanoid(ZodNanoID, params));
+	inst.guid = (params) => inst.check(_guid(ZodGUID, params));
+	inst.cuid = (params) => inst.check(_cuid(ZodCUID, params));
+	inst.cuid2 = (params) => inst.check(_cuid2(ZodCUID2, params));
+	inst.ulid = (params) => inst.check(_ulid(ZodULID, params));
+	inst.base64 = (params) => inst.check(_base64(ZodBase64, params));
+	inst.base64url = (params) => inst.check(_base64url(ZodBase64URL, params));
+	inst.xid = (params) => inst.check(_xid(ZodXID, params));
+	inst.ksuid = (params) => inst.check(_ksuid(ZodKSUID, params));
+	inst.ipv4 = (params) => inst.check(_ipv4(ZodIPv4, params));
+	inst.ipv6 = (params) => inst.check(_ipv6(ZodIPv6, params));
+	inst.cidrv4 = (params) => inst.check(_cidrv4(ZodCIDRv4, params));
+	inst.cidrv6 = (params) => inst.check(_cidrv6(ZodCIDRv6, params));
+	inst.e164 = (params) => inst.check(_e164(ZodE164, params));
+	inst.datetime = (params) => inst.check(datetime(params));
+	inst.date = (params) => inst.check(date(params));
+	inst.time = (params) => inst.check(time(params));
+	inst.duration = (params) => inst.check(duration(params));
+});
+function string(params) {
+	return _string(ZodString, params);
+}
+const ZodStringFormat = /* @__PURE__ */ $constructor("ZodStringFormat", (inst, def) => {
+	$ZodStringFormat.init(inst, def);
+	_ZodString.init(inst, def);
+});
+const ZodEmail = /* @__PURE__ */ $constructor("ZodEmail", (inst, def) => {
+	$ZodEmail.init(inst, def);
+	ZodStringFormat.init(inst, def);
+});
+const ZodGUID = /* @__PURE__ */ $constructor("ZodGUID", (inst, def) => {
+	$ZodGUID.init(inst, def);
+	ZodStringFormat.init(inst, def);
+});
+const ZodUUID = /* @__PURE__ */ $constructor("ZodUUID", (inst, def) => {
+	$ZodUUID.init(inst, def);
+	ZodStringFormat.init(inst, def);
+});
+const ZodURL = /* @__PURE__ */ $constructor("ZodURL", (inst, def) => {
+	$ZodURL.init(inst, def);
+	ZodStringFormat.init(inst, def);
+});
+const ZodEmoji = /* @__PURE__ */ $constructor("ZodEmoji", (inst, def) => {
+	$ZodEmoji.init(inst, def);
+	ZodStringFormat.init(inst, def);
+});
+const ZodNanoID = /* @__PURE__ */ $constructor("ZodNanoID", (inst, def) => {
+	$ZodNanoID.init(inst, def);
+	ZodStringFormat.init(inst, def);
+});
+const ZodCUID = /* @__PURE__ */ $constructor("ZodCUID", (inst, def) => {
+	$ZodCUID.init(inst, def);
+	ZodStringFormat.init(inst, def);
+});
+const ZodCUID2 = /* @__PURE__ */ $constructor("ZodCUID2", (inst, def) => {
+	$ZodCUID2.init(inst, def);
+	ZodStringFormat.init(inst, def);
+});
+const ZodULID = /* @__PURE__ */ $constructor("ZodULID", (inst, def) => {
+	$ZodULID.init(inst, def);
+	ZodStringFormat.init(inst, def);
+});
+const ZodXID = /* @__PURE__ */ $constructor("ZodXID", (inst, def) => {
+	$ZodXID.init(inst, def);
+	ZodStringFormat.init(inst, def);
+});
+const ZodKSUID = /* @__PURE__ */ $constructor("ZodKSUID", (inst, def) => {
+	$ZodKSUID.init(inst, def);
+	ZodStringFormat.init(inst, def);
+});
+const ZodIPv4 = /* @__PURE__ */ $constructor("ZodIPv4", (inst, def) => {
+	$ZodIPv4.init(inst, def);
+	ZodStringFormat.init(inst, def);
+});
+const ZodIPv6 = /* @__PURE__ */ $constructor("ZodIPv6", (inst, def) => {
+	$ZodIPv6.init(inst, def);
+	ZodStringFormat.init(inst, def);
+});
+const ZodCIDRv4 = /* @__PURE__ */ $constructor("ZodCIDRv4", (inst, def) => {
+	$ZodCIDRv4.init(inst, def);
+	ZodStringFormat.init(inst, def);
+});
+const ZodCIDRv6 = /* @__PURE__ */ $constructor("ZodCIDRv6", (inst, def) => {
+	$ZodCIDRv6.init(inst, def);
+	ZodStringFormat.init(inst, def);
+});
+const ZodBase64 = /* @__PURE__ */ $constructor("ZodBase64", (inst, def) => {
+	$ZodBase64.init(inst, def);
+	ZodStringFormat.init(inst, def);
+});
+const ZodBase64URL = /* @__PURE__ */ $constructor("ZodBase64URL", (inst, def) => {
+	$ZodBase64URL.init(inst, def);
+	ZodStringFormat.init(inst, def);
+});
+const ZodE164 = /* @__PURE__ */ $constructor("ZodE164", (inst, def) => {
+	$ZodE164.init(inst, def);
+	ZodStringFormat.init(inst, def);
+});
+const ZodJWT = /* @__PURE__ */ $constructor("ZodJWT", (inst, def) => {
+	$ZodJWT.init(inst, def);
+	ZodStringFormat.init(inst, def);
+});
+const ZodNumber = /* @__PURE__ */ $constructor("ZodNumber", (inst, def) => {
+	$ZodNumber.init(inst, def);
+	ZodType.init(inst, def);
+	inst._zod.processJSONSchema = (ctx, json, params) => numberProcessor(inst, ctx, json, params);
+	inst.gt = (value, params) => inst.check(_gt(value, params));
+	inst.gte = (value, params) => inst.check(_gte(value, params));
+	inst.min = (value, params) => inst.check(_gte(value, params));
+	inst.lt = (value, params) => inst.check(_lt(value, params));
+	inst.lte = (value, params) => inst.check(_lte(value, params));
+	inst.max = (value, params) => inst.check(_lte(value, params));
+	inst.int = (params) => inst.check(int(params));
+	inst.safe = (params) => inst.check(int(params));
+	inst.positive = (params) => inst.check(_gt(0, params));
+	inst.nonnegative = (params) => inst.check(_gte(0, params));
+	inst.negative = (params) => inst.check(_lt(0, params));
+	inst.nonpositive = (params) => inst.check(_lte(0, params));
+	inst.multipleOf = (value, params) => inst.check(_multipleOf(value, params));
+	inst.step = (value, params) => inst.check(_multipleOf(value, params));
+	inst.finite = () => inst;
+	const bag = inst._zod.bag;
+	inst.minValue = Math.max(bag.minimum ?? Number.NEGATIVE_INFINITY, bag.exclusiveMinimum ?? Number.NEGATIVE_INFINITY) ?? null;
+	inst.maxValue = Math.min(bag.maximum ?? Number.POSITIVE_INFINITY, bag.exclusiveMaximum ?? Number.POSITIVE_INFINITY) ?? null;
+	inst.isInt = (bag.format ?? "").includes("int") || Number.isSafeInteger(bag.multipleOf ?? .5);
+	inst.isFinite = true;
+	inst.format = bag.format ?? null;
+});
+function number(params) {
+	return _number(ZodNumber, params);
+}
+const ZodNumberFormat = /* @__PURE__ */ $constructor("ZodNumberFormat", (inst, def) => {
+	$ZodNumberFormat.init(inst, def);
+	ZodNumber.init(inst, def);
+});
+function int(params) {
+	return _int(ZodNumberFormat, params);
+}
 const ZodUnknown = /* @__PURE__ */ $constructor("ZodUnknown", (inst, def) => {
 	$ZodUnknown.init(inst, def);
 	ZodType.init(inst, def);
@@ -2388,6 +4695,14 @@ const ZodUnknown = /* @__PURE__ */ $constructor("ZodUnknown", (inst, def) => {
 function unknown() {
 	return _unknown(ZodUnknown);
 }
+const ZodNever = /* @__PURE__ */ $constructor("ZodNever", (inst, def) => {
+	$ZodNever.init(inst, def);
+	ZodType.init(inst, def);
+	inst._zod.processJSONSchema = (ctx, json, params) => neverProcessor(inst, ctx, json, params);
+});
+function never(params) {
+	return _never(ZodNever, params);
+}
 const ZodArray = /* @__PURE__ */ $constructor("ZodArray", (inst, def) => {
 	$ZodArray.init(inst, def);
 	ZodType.init(inst, def);
@@ -2402,6 +4717,53 @@ const ZodArray = /* @__PURE__ */ $constructor("ZodArray", (inst, def) => {
 function array(element, params) {
 	return _array(ZodArray, element, params);
 }
+const ZodObject = /* @__PURE__ */ $constructor("ZodObject", (inst, def) => {
+	$ZodObjectJIT.init(inst, def);
+	ZodType.init(inst, def);
+	inst._zod.processJSONSchema = (ctx, json, params) => objectProcessor(inst, ctx, json, params);
+	defineLazy(inst, "shape", () => {
+		return def.shape;
+	});
+	inst.keyof = () => _enum(Object.keys(inst._zod.def.shape));
+	inst.catchall = (catchall) => inst.clone({
+		...inst._zod.def,
+		catchall
+	});
+	inst.passthrough = () => inst.clone({
+		...inst._zod.def,
+		catchall: unknown()
+	});
+	inst.loose = () => inst.clone({
+		...inst._zod.def,
+		catchall: unknown()
+	});
+	inst.strict = () => inst.clone({
+		...inst._zod.def,
+		catchall: never()
+	});
+	inst.strip = () => inst.clone({
+		...inst._zod.def,
+		catchall: void 0
+	});
+	inst.extend = (incoming) => {
+		return extend(inst, incoming);
+	};
+	inst.safeExtend = (incoming) => {
+		return safeExtend(inst, incoming);
+	};
+	inst.merge = (other) => merge(inst, other);
+	inst.pick = (mask) => pick(inst, mask);
+	inst.omit = (mask) => omit(inst, mask);
+	inst.partial = (...args) => partial(ZodOptional, inst, args[0]);
+	inst.required = (...args) => required(ZodNonOptional, inst, args[0]);
+});
+function object(shape, params) {
+	return new ZodObject({
+		type: "object",
+		shape: shape ?? {},
+		...normalizeParams(params)
+	});
+}
 const ZodUnion = /* @__PURE__ */ $constructor("ZodUnion", (inst, def) => {
 	$ZodUnion.init(inst, def);
 	ZodType.init(inst, def);
@@ -2427,6 +4789,58 @@ function intersection(left, right) {
 		right
 	});
 }
+const ZodRecord = /* @__PURE__ */ $constructor("ZodRecord", (inst, def) => {
+	$ZodRecord.init(inst, def);
+	ZodType.init(inst, def);
+	inst._zod.processJSONSchema = (ctx, json, params) => recordProcessor(inst, ctx, json, params);
+	inst.keyType = def.keyType;
+	inst.valueType = def.valueType;
+});
+function record(keyType, valueType, params) {
+	return new ZodRecord({
+		type: "record",
+		keyType,
+		valueType,
+		...normalizeParams(params)
+	});
+}
+const ZodEnum = /* @__PURE__ */ $constructor("ZodEnum", (inst, def) => {
+	$ZodEnum.init(inst, def);
+	ZodType.init(inst, def);
+	inst._zod.processJSONSchema = (ctx, json, params) => enumProcessor(inst, ctx, json, params);
+	inst.enum = def.entries;
+	inst.options = Object.values(def.entries);
+	const keys = new Set(Object.keys(def.entries));
+	inst.extract = (values, params) => {
+		const newEntries = {};
+		for (const value of values) if (keys.has(value)) newEntries[value] = def.entries[value];
+		else throw new Error(`Key ${value} not found in enum`);
+		return new ZodEnum({
+			...def,
+			checks: [],
+			...normalizeParams(params),
+			entries: newEntries
+		});
+	};
+	inst.exclude = (values, params) => {
+		const newEntries = { ...def.entries };
+		for (const value of values) if (keys.has(value)) delete newEntries[value];
+		else throw new Error(`Key ${value} not found in enum`);
+		return new ZodEnum({
+			...def,
+			checks: [],
+			...normalizeParams(params),
+			entries: newEntries
+		});
+	};
+});
+function _enum(values, params) {
+	return new ZodEnum({
+		type: "enum",
+		entries: Array.isArray(values) ? Object.fromEntries(values.map((v) => [v, v])) : values,
+		...normalizeParams(params)
+	});
+}
 const ZodTransform = /* @__PURE__ */ $constructor("ZodTransform", (inst, def) => {
 	$ZodTransform.init(inst, def);
 	ZodType.init(inst, def);
@@ -2601,31 +5015,26 @@ let AgentStructuredOutputRunner = class AgentStructuredOutputRunner$1 {
 		_AgentStructuredOutputRunner = this;
 	}
 	static repairAttemptCount = 2;
-	constructor(repairPromptFactory, openAiStructuredOutputMethodFactory) {
+	static structuredOutputSchemaName = "agent_output";
+	constructor(repairPromptFactory, openAiStrictJsonSchemaFactory) {
 		this.repairPromptFactory = repairPromptFactory;
-		this.openAiStructuredOutputMethodFactory = openAiStructuredOutputMethodFactory;
+		this.openAiStrictJsonSchemaFactory = openAiStrictJsonSchemaFactory;
 	}
 	async resolve(args) {
 		let lastFailure;
-		if (args.rawFinalResponse) {
-			const directResult = this.tryParseAndValidate(AgentMessageFactory.extractContent(args.rawFinalResponse), args.schema);
-			if (directResult.ok) return directResult.value;
-			lastFailure = directResult;
-		} else if (!this.supportsNativeStructuredOutput(args.model)) {
-			const rawResponse = await args.invokeTextModel(args.conversation);
-			const directResult = this.tryParseAndValidate(AgentMessageFactory.extractContent(rawResponse), args.schema);
+		if (args.rawFinalText !== void 0) {
+			const directResult = this.tryParseAndValidate(args.rawFinalText, args.schema);
 			if (directResult.ok) return directResult.value;
 			lastFailure = directResult;
 		}
 		try {
-			const nativeStructuredModel = this.createStructuredOutputModel(args.model, args.chatModelConfig, args.schema);
-			if (nativeStructuredModel) {
-				const nativeResult = this.tryValidateStructuredValue(await args.invokeStructuredModel(nativeStructuredModel, args.conversation), args.schema);
-				if (nativeResult.ok) return nativeResult.value;
-				lastFailure = nativeResult;
-			}
+			const structuredOptions = this.resolveStructuredOutputOptions(args.chatModelConfig);
+			const schemaForModel = this.resolveOutputSchemaForModel(args.schema, structuredOptions);
+			const nativeResult = this.tryValidateStructuredValue(await args.invokeStructuredModel(schemaForModel, args.conversation, structuredOptions), args.schema);
+			if (nativeResult.ok) return nativeResult.value;
+			lastFailure = nativeResult;
 		} catch (error) {
-			lastFailure = {
+			lastFailure = lastFailure ?? {
 				ok: false,
 				invalidContent: "",
 				validationError: `Native structured output failed: ${this.summarizeError(error)}`
@@ -2649,22 +5058,26 @@ let AgentStructuredOutputRunner = class AgentStructuredOutputRunner$1 {
 				validationError: failure.validationError
 			}))];
 			const repairResponse = await args.invokeTextModel(repairMessages);
-			const repairResult = this.tryParseAndValidate(AgentMessageFactory.extractContent(repairResponse), args.schema);
+			const repairResult = this.tryParseAndValidate(repairResponse.text, args.schema);
 			if (repairResult.ok) return repairResult.value;
 			failure = repairResult;
 		}
 		throw new Error(`Structured output required for AIAgent "${args.agentName}" (${args.nodeId}) but validation still failed after ${_AgentStructuredOutputRunner.repairAttemptCount} repair attempts: ${failure.validationError}`);
 	}
-	createStructuredOutputModel(model, chatModelConfig, schema) {
-		if (!this.supportsNativeStructuredOutput(model)) return;
-		const options = this.getStructuredOutputOptions(chatModelConfig);
-		return model.withStructuredOutput(schema, options);
-	}
-	getStructuredOutputOptions(chatModelConfig) {
-		return this.openAiStructuredOutputMethodFactory.create(chatModelConfig) ?? { strict: true };
+	/**
+	* Chooses strict mode for OpenAI chat-model configs, off otherwise.  Extendable in future for
+	* other providers that adopt the same "supply a JSON Schema record directly" contract.
+	*/
+	resolveStructuredOutputOptions(chatModelConfig) {
+		if (chatModelConfig.type !== OpenAIChatModelFactory) return;
+		return {
+			strict: true,
+			schemaName: _AgentStructuredOutputRunner.structuredOutputSchemaName
+		};
 	}
-	supportsNativeStructuredOutput(model) {
-		return typeof model.withStructuredOutput === "function";
+	resolveOutputSchemaForModel(schema, options) {
+		if (!options?.strict) return schema;
+		return this.openAiStrictJsonSchemaFactory.createStructuredOutputRecord(schema, { schemaName: options.schemaName ?? _AgentStructuredOutputRunner.structuredOutputSchemaName });
 	}
 	tryParseAndValidate(content, schema) {
 		try {
@@ -2698,7 +5111,7 @@ let AgentStructuredOutputRunner = class AgentStructuredOutputRunner$1 {
 	}
 	toJson(value) {
 		try {
-			return JSON.stringify(value);
+			return JSON.stringify(value) ?? String(value);
 		} catch (error) {
 			return `<<unserializable: ${this.summarizeError(error)}>>`;
 		}
@@ -2707,8 +5120,8 @@ let AgentStructuredOutputRunner = class AgentStructuredOutputRunner$1 {
 AgentStructuredOutputRunner = _AgentStructuredOutputRunner = __decorate([
 	(0, __codemation_core.injectable)(),
 	__decorateParam(0, (0, __codemation_core.inject)(AgentStructuredOutputRepairPromptFactory)),
-	__decorateParam(1, (0, __codemation_core.inject)(OpenAIStructuredOutputMethodFactory)),
-	__decorateMetadata("design:paramtypes", [typeof (_ref$3 = typeof AgentStructuredOutputRepairPromptFactory !== "undefined" && AgentStructuredOutputRepairPromptFactory) === "function" ? _ref$3 : Object, typeof (_ref2$3 = typeof OpenAIStructuredOutputMethodFactory !== "undefined" && OpenAIStructuredOutputMethodFactory) === "function" ? _ref2$3 : Object])
+	__decorateParam(1, (0, __codemation_core.inject)(OpenAiStrictJsonSchemaFactory)),
+	__decorateMetadata("design:paramtypes", [typeof (_ref$3 = typeof AgentStructuredOutputRepairPromptFactory !== "undefined" && AgentStructuredOutputRepairPromptFactory) === "function" ? _ref$3 : Object, typeof (_ref2$3 = typeof OpenAiStrictJsonSchemaFactory !== "undefined" && OpenAiStrictJsonSchemaFactory) === "function" ? _ref2$3 : Object])
 ], AgentStructuredOutputRunner);
 
 //#endregion
@@ -2845,7 +5258,7 @@ let AgentToolExecutionCoordinator = class AgentToolExecutionCoordinator$1 {
 	async executePlannedToolCall(args) {
 		const { plannedToolCall, ctx } = args;
 		const toolCallInputsByPort = AgentToolCallPortMap.fromInput(plannedToolCall.toolCall.input ?? {});
-		const invocationId = __codemation_core.ConnectionInvocationIdFactory.create();
+		const invocationId = plannedToolCall.invocationId;
 		const startedAt = /* @__PURE__ */ new Date();
 		const span = ctx.telemetry.startChildSpan({
 			name: "agent.tool.call",
@@ -2853,7 +5266,10 @@ let AgentToolExecutionCoordinator = class AgentToolExecutionCoordinator$1 {
 			startedAt,
 			attributes: {
 				[__codemation_core.CodemationTelemetryAttributeNames.connectionInvocationId]: invocationId,
-				[__codemation_core.CodemationTelemetryAttributeNames.toolName]: plannedToolCall.binding.config.name
+				[__codemation_core.CodemationTelemetryAttributeNames.toolName]: plannedToolCall.binding.config.name,
+				...ctx.iterationId ? { [__codemation_core.CodemationTelemetryAttributeNames.iterationId]: ctx.iterationId } : {},
+				...typeof ctx.itemIndex === "number" ? { [__codemation_core.CodemationTelemetryAttributeNames.iterationIndex]: ctx.itemIndex } : {},
+				...ctx.parentInvocationId ? { [__codemation_core.CodemationTelemetryAttributeNames.parentInvocationId]: ctx.parentInvocationId } : {}
 			}
 		});
 		await ctx.nodeState?.markRunning({
@@ -2861,9 +5277,24 @@ let AgentToolExecutionCoordinator = class AgentToolExecutionCoordinator$1 {
 			activationId: ctx.activationId,
 			inputsByPort: toolCallInputsByPort
 		});
+		await ctx.nodeState?.appendConnectionInvocation({
+			invocationId,
+			connectionNodeId: plannedToolCall.nodeId,
+			parentAgentNodeId: ctx.nodeId,
+			parentAgentActivationId: ctx.activationId,
+			status: "running",
+			managedInput: this.toJsonValue(plannedToolCall.toolCall.input),
+			queuedAt: startedAt.toISOString(),
+			startedAt: startedAt.toISOString(),
+			iterationId: ctx.iterationId,
+			parentInvocationId: ctx.parentInvocationId
+		});
 		try {
-			const serialized = await plannedToolCall.binding.langChainTool.invoke(plannedToolCall.toolCall.input ?? {});
-			const result = this.parseToolOutput(serialized);
+			const result = await plannedToolCall.binding.execute(plannedToolCall.toolCall.input ?? {}, {
+				parentSpan: span,
+				parentInvocationId: invocationId
+			});
+			const serialized = typeof result === "string" ? result : JSON.stringify(result);
 			const finishedAt = /* @__PURE__ */ new Date();
 			await ctx.nodeState?.markCompleted({
 				nodeId: plannedToolCall.nodeId,
@@ -2895,7 +5326,9 @@ let AgentToolExecutionCoordinator = class AgentToolExecutionCoordinator$1 {
 				managedOutput: this.toJsonValue(result),
 				queuedAt: startedAt.toISOString(),
 				startedAt: startedAt.toISOString(),
-				finishedAt: finishedAt.toISOString()
+				finishedAt: finishedAt.toISOString(),
+				iterationId: ctx.iterationId,
+				parentInvocationId: ctx.parentInvocationId
 			});
 			return {
 				toolName: plannedToolCall.binding.config.name,
@@ -2907,7 +5340,7 @@ let AgentToolExecutionCoordinator = class AgentToolExecutionCoordinator$1 {
 			const classification = this.errorClassifier.classify({
 				error,
 				toolName: plannedToolCall.binding.config.name,
-				schema: plannedToolCall.binding.langChainTool.schema
+				schema: plannedToolCall.binding.inputSchema
 			});
 			if (classification.kind !== "repairable_validation_error") {
 				const effectiveError = classification.effectiveError;
@@ -3036,7 +5469,9 @@ let AgentToolExecutionCoordinator = class AgentToolExecutionCoordinator$1 {
 			},
 			queuedAt: args.startedAt.toISOString(),
 			startedAt: args.startedAt.toISOString(),
-			finishedAt: finishedAt.toISOString()
+			finishedAt: finishedAt.toISOString(),
+			iterationId: args.ctx.iterationId,
+			parentInvocationId: args.ctx.parentInvocationId
 		});
 	}
 	createRepairPayload(args) {
@@ -3070,14 +5505,6 @@ let AgentToolExecutionCoordinator = class AgentToolExecutionCoordinator$1 {
 		if (!firstIssue) return `Your previous tool call for "${toolName}" was invalid and did not match the expected schema.`;
 		return `Your previous tool call for "${toolName}" was invalid because field "${firstIssue.path.length > 0 ? firstIssue.path.join(".") : "<root>"}" failed validation: ${firstIssue.message}`;
 	}
-	parseToolOutput(serialized) {
-		if (typeof serialized !== "string") return serialized;
-		try {
-			return JSON.parse(serialized);
-		} catch {
-			return serialized;
-		}
-	}
 	toJsonValue(value) {
 		if (value === void 0) return;
 		return JSON.parse(JSON.stringify(value));
@@ -3105,13 +5532,14 @@ AgentToolExecutionCoordinator = __decorate([
 
 //#endregion
 //#region src/nodes/NodeBackedToolRuntime.ts
-var _ref$1, _ref2$1, _ref3$1;
+var _ref$1, _ref2$1, _ref3$1, _ref4$1;
 let NodeBackedToolRuntime = class NodeBackedToolRuntime$1 {
-	constructor(nodeResolver, itemExprResolver, outputNormalizer, outputBehaviorResolver) {
+	constructor(nodeResolver, itemExprResolver, outputNormalizer, outputBehaviorResolver, childExecutionScopeFactory) {
 		this.nodeResolver = nodeResolver;
 		this.itemExprResolver = itemExprResolver;
 		this.outputNormalizer = outputNormalizer;
 		this.outputBehaviorResolver = outputBehaviorResolver;
+		this.childExecutionScopeFactory = childExecutionScopeFactory;
 	}
 	async execute(config$1, args) {
 		const nodeInput = config$1.toNodeItem({
@@ -3122,10 +5550,7 @@ let NodeBackedToolRuntime = class NodeBackedToolRuntime$1 {
 			ctx: args.ctx,
 			node: config$1.node
 		});
-		const nodeCtx = {
-			...args.ctx,
-			config: config$1.node
-		};
+		const nodeCtx = this.resolveNodeCtx(config$1, args);
 		const resolvedNode = this.nodeResolver.resolve(config$1.node.type);
 		const outputs = await this.executeResolvedNode(resolvedNode, nodeInput, nodeCtx);
 		return config$1.toToolOutput({
@@ -3138,6 +5563,35 @@ let NodeBackedToolRuntime = class NodeBackedToolRuntime$1 {
 			outputs
 		});
 	}
+	/**
+	* Returns a re-rooted child ctx for nested-agent tools (so their LLM/tool connection ids derive
+	* from the tool connection node, telemetry parents under the tool-call span, and connection
+	* invocations carry `parentInvocationId`). Plain runnable tools (non-agent) keep the orchestrator
+	* ctx with only `config` swapped — no nesting concern.
+	*
+	* The caller (`AIAgentNode.createItemScopedTools`) already wraps the orchestrator ctx via
+	* `ConnectionCredentialExecutionContextFactory.forConnectionNode`, so `args.ctx.nodeId` is the
+	* tool's own connection node id (e.g. `AIAgentNode:2__conn__tool__searchInMail`). We pass that
+	* through as the sub-agent's `nodeId`; deriving another `toolConnectionNodeId(args.ctx.nodeId,
+	* config.name)` here would prepend a duplicate `__conn__tool__<name>` segment and exponentially
+	* deepen ids on each invocation, which also breaks credential resolution because user-provided
+	* bindings sit on the single-level connection node id.
+	*/
+	resolveNodeCtx(config$1, args) {
+		const isNestedAgent = __codemation_core.AgentConfigInspector.isAgentNodeConfig(config$1.node);
+		const hooks = args.hooks;
+		if (!isNestedAgent || !hooks?.parentSpan || !hooks.parentInvocationId) return {
+			...args.ctx,
+			config: config$1.node
+		};
+		return this.childExecutionScopeFactory.forSubAgent({
+			parentCtx: args.ctx,
+			childNodeId: args.ctx.nodeId,
+			childConfig: config$1.node,
+			parentInvocationId: hooks.parentInvocationId,
+			parentSpan: hooks.parentSpan
+		});
+	}
 	async executeResolvedNode(resolvedNode, nodeInput, ctx) {
 		if (this.isMultiInputNode(resolvedNode)) return await resolvedNode.executeMulti({ in: [nodeInput] }, ctx);
 		if (this.isRunnableNode(resolvedNode)) {
@@ -3175,11 +5629,13 @@ NodeBackedToolRuntime = __decorate([
 	__decorateParam(1, (0, __codemation_core.inject)(__codemation_core.ItemExprResolver)),
 	__decorateParam(2, (0, __codemation_core.inject)(__codemation_core.NodeOutputNormalizer)),
 	__decorateParam(3, (0, __codemation_core.inject)(__codemation_core.RunnableOutputBehaviorResolver)),
+	__decorateParam(4, (0, __codemation_core.inject)(__codemation_core.ChildExecutionScopeFactory)),
 	__decorateMetadata("design:paramtypes", [
 		Object,
 		typeof (_ref$1 = typeof __codemation_core.ItemExprResolver !== "undefined" && __codemation_core.ItemExprResolver) === "function" ? _ref$1 : Object,
 		typeof (_ref2$1 = typeof __codemation_core.NodeOutputNormalizer !== "undefined" && __codemation_core.NodeOutputNormalizer) === "function" ? _ref2$1 : Object,
-		typeof (_ref3$1 = typeof __codemation_core.RunnableOutputBehaviorResolver !== "undefined" && __codemation_core.RunnableOutputBehaviorResolver) === "function" ? _ref3$1 : Object
+		typeof (_ref3$1 = typeof __codemation_core.RunnableOutputBehaviorResolver !== "undefined" && __codemation_core.RunnableOutputBehaviorResolver) === "function" ? _ref3$1 : Object,
+		typeof (_ref4$1 = typeof __codemation_core.ChildExecutionScopeFactory !== "undefined" && __codemation_core.ChildExecutionScopeFactory) === "function" ? _ref4$1 : Object
 	])
 ], NodeBackedToolRuntime);
 
@@ -3197,14 +5653,8 @@ var _ref, _ref2, _ref3, _ref4;
 let AIAgentNode = class AIAgentNode$1 {
 	kind = "node";
 	outputPorts = ["main"];
-	/**
-	* Engine validates {@link RunnableNodeConfig.inputSchema} (Zod) on {@code item.json} before enqueue, then resolves
-	* per-item **`itemExpr`** leaves on config before {@link #execute}. Prefer modeling prompts as
-	* {@code { messages: [{ role, content }, ...] }} (on input or config) so persisted inputs are visible in the UI.
-	*/
 	inputSchema = unknown();
 	connectionCredentialExecutionContextFactory;
-	/** One resolved model/tools bundle per activation context (same ctx across items in a batch). */
 	preparedByExecutionContext = /* @__PURE__ */ new WeakMap();
 	constructor(nodeResolver, credentialSessions, nodeBackedToolRuntime, executionHelpers, structuredOutputRunner, toolExecutionCoordinator) {
 		this.nodeResolver = nodeResolver;
@@ -3235,9 +5685,6 @@ let AIAgentNode = class AIAgentNode$1 {
 			throw error;
 		}
 	}
-	/**
-	* Resolves the chat model and tools once per activation, then reuses for every item in the batch.
-	*/
 	async prepareExecution(ctx) {
 		const chatModelFactory = this.nodeResolver.resolve(ctx.config.chatModel.type);
 		const languageModelCredentialContext = this.connectionCredentialExecutionContextFactory.forConnectionNode(ctx, {
@@ -3255,9 +5702,6 @@ let AIAgentNode = class AIAgentNode$1 {
 			languageModelConnectionNodeId: __codemation_core.ConnectionNodeIdFactory.languageModelConnectionNodeId(ctx.nodeId)
 		};
 	}
-	/**
-	* One item: build prompts, optionally bind tools, run the multi-turn loop, map the final model message to workflow JSON.
-	*/
 	async runAgentForItem(prepared, item, itemIndex, items) {
 		const { ctx } = prepared;
 		const itemInputsByPort = AgentItemPortMap.fromItem(item);
@@ -3271,8 +5715,8 @@ let AIAgentNode = class AIAgentNode$1 {
 				conversation,
 				agentName: this.getAgentDisplayName(ctx),
 				nodeId: ctx.nodeId,
-				invokeTextModel: async (messages) => await this.invokeModel(prepared.model, prepared.languageModelConnectionNodeId, messages, ctx, itemInputsByPort, prepared.guardrails.modelInvocationOptions),
-				invokeStructuredModel: async (structuredModel, messages) => await this.invokeStructuredModel(structuredModel, prepared.languageModelConnectionNodeId, messages, ctx, itemInputsByPort, prepared.guardrails.modelInvocationOptions)
+				invokeTextModel: async (messages) => await this.invokeTextTurn(prepared, itemInputsByPort, messages, []),
+				invokeStructuredModel: async (schema, messages, structuredOptions) => await this.invokeStructuredTurn(prepared, itemInputsByPort, schema, messages, structuredOptions)
 			});
 			await ctx.telemetry.recordMetric({
 				name: __codemation_core.CodemationTelemetryMetricNames.agentTurns,
@@ -3284,13 +5728,11 @@ let AIAgentNode = class AIAgentNode$1 {
 			});
 			return this.buildOutputItem(item, structuredOutput);
 		}
-		const modelWithTools = this.bindToolsToModel(prepared.model, itemScopedTools);
 		const loopResult = await this.runTurnLoopUntilFinalAnswer({
 			prepared,
 			itemInputsByPort,
 			itemScopedTools,
-			conversation,
-			modelWithTools
+			conversation
 		});
 		await ctx.telemetry.recordMetric({
 			name: __codemation_core.CodemationTelemetryMetricNames.agentTurns,
@@ -3300,30 +5742,34 @@ let AIAgentNode = class AIAgentNode$1 {
 			name: __codemation_core.CodemationTelemetryMetricNames.agentToolCalls,
 			value: loopResult.toolCallCount
 		});
-		const outputJson = await this.resolveFinalOutputJson(prepared, itemInputsByPort, conversation, loopResult.finalResponse, itemScopedTools.length > 0);
+		const outputJson = await this.resolveFinalOutputJson(prepared, itemInputsByPort, conversation, loopResult.finalText, itemScopedTools.length > 0);
 		return this.buildOutputItem(item, outputJson);
 	}
 	/**
-	* Repeatedly invokes the model until it returns without tool calls, or guardrails end the loop.
+	* Multi-turn loop:
+	* - Each turn is a single `generateText` call with tools exposed but **not auto-executed**
+	*   (we control tool dispatch so that {@link AgentToolExecutionCoordinator} drives repair /
+	*   connection-invocation recording / transient-error handling exactly like before).
+	* - When the model returns no tool calls the loop ends with the model's text as the final answer.
+	* - Respects `guardrails.maxTurns` and `guardrails.onTurnLimitReached`.
 	*/
 	async runTurnLoopUntilFinalAnswer(args) {
-		const { prepared, itemInputsByPort, itemScopedTools, conversation, modelWithTools } = args;
-		const { ctx, guardrails, languageModelConnectionNodeId } = prepared;
-		let finalResponse;
+		const { prepared, itemInputsByPort, itemScopedTools, conversation } = args;
+		const { ctx, guardrails } = prepared;
+		let finalText = "";
 		let toolCallCount = 0;
 		let turnCount = 0;
 		const repairAttemptsByToolName = /* @__PURE__ */ new Map();
 		for (let turn = 1; turn <= guardrails.maxTurns; turn++) {
 			turnCount = turn;
-			const response = await this.invokeModel(modelWithTools, languageModelConnectionNodeId, conversation, ctx, itemInputsByPort, guardrails.modelInvocationOptions);
-			finalResponse = response;
-			const toolCalls = AgentMessageFactory.extractToolCalls(response);
-			if (toolCalls.length === 0) break;
+			const result = await this.invokeTextTurn(prepared, itemInputsByPort, conversation, itemScopedTools);
+			finalText = result.text;
+			if (result.toolCalls.length === 0) break;
 			if (this.cannotExecuteAnotherToolRound(turn, guardrails)) {
 				this.finishOrThrowWhenTurnCapHitWithToolCalls(ctx, guardrails);
 				break;
 			}
-			const plannedToolCalls = this.planToolCalls(itemScopedTools, toolCalls, ctx.nodeId);
+			const plannedToolCalls = this.planToolCalls(itemScopedTools, result.toolCalls, ctx.nodeId);
 			toolCallCount += plannedToolCalls.length;
 			await this.markQueuedTools(plannedToolCalls, ctx);
 			const executedToolCalls = await this.toolExecutionCoordinator.execute({
@@ -3332,11 +5778,10 @@ let AIAgentNode = class AIAgentNode$1 {
 				agentName: this.getAgentDisplayName(ctx),
 				repairAttemptsByToolName
 			});
-			this.appendAssistantAndToolMessages(conversation, response, executedToolCalls);
+			this.appendAssistantAndToolMessages(conversation, result.assistantMessage, result.text, result.toolCalls, executedToolCalls);
 		}
-		if (!finalResponse) throw new Error(`AIAgent "${ctx.config.name ?? ctx.nodeId}" did not produce a model response.`);
 		return {
-			finalResponse,
+			finalText,
 			turnCount,
 			toolCallCount
 		};
@@ -3348,30 +5793,30 @@ 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, executedToolCalls) {
-		conversation.push(assistantMessage, ...executedToolCalls.map((toolCall) => AgentMessageFactory.createToolMessage(toolCall.toolCallId, toolCall.serialized)));
+	appendAssistantAndToolMessages(conversation, assistantMessage, text, toolCalls, executedToolCalls) {
+		conversation.push(assistantMessage ?? AgentMessageFactory.createAssistantWithToolCalls(text, toolCalls), AgentMessageFactory.createToolResultsMessage(executedToolCalls));
 	}
-	async resolveFinalOutputJson(prepared, itemInputsByPort, conversation, finalResponse, wasToolEnabledRun) {
-		if (!prepared.ctx.config.outputSchema) return AgentOutputFactory.fromAgentContent(AgentMessageFactory.extractContent(finalResponse));
+	async resolveFinalOutputJson(prepared, itemInputsByPort, conversation, finalText, wasToolEnabledRun) {
+		if (!prepared.ctx.config.outputSchema) return AgentOutputFactory.fromAgentContent(finalText);
+		const conversationWithFinal = wasToolEnabledRun ? [...conversation, {
+			role: "assistant",
+			content: finalText
+		}] : conversation;
 		return await this.structuredOutputRunner.resolve({
 			model: prepared.model,
 			chatModelConfig: prepared.ctx.config.chatModel,
 			schema: prepared.ctx.config.outputSchema,
-			conversation: wasToolEnabledRun ? [...conversation, finalResponse] : conversation,
-			rawFinalResponse: finalResponse,
+			conversation: conversationWithFinal,
+			rawFinalText: finalText,
 			agentName: this.getAgentDisplayName(prepared.ctx),
 			nodeId: prepared.ctx.nodeId,
-			invokeTextModel: async (messages) => await this.invokeModel(prepared.model, prepared.languageModelConnectionNodeId, messages, prepared.ctx, itemInputsByPort, prepared.guardrails.modelInvocationOptions),
-			invokeStructuredModel: async (structuredModel, messages) => await this.invokeStructuredModel(structuredModel, prepared.languageModelConnectionNodeId, messages, prepared.ctx, itemInputsByPort, prepared.guardrails.modelInvocationOptions)
+			invokeTextModel: async (messages) => await this.invokeTextTurn(prepared, itemInputsByPort, messages, []),
+			invokeStructuredModel: async (schema, messages, structuredOptions) => await this.invokeStructuredTurn(prepared, itemInputsByPort, schema, messages, structuredOptions)
 		});
 	}
 	buildOutputItem(item, outputJson) {
 		return AgentOutputFactory.replaceJson(item, outputJson);
 	}
-	bindToolsToModel(model, itemScopedTools) {
-		if (itemScopedTools.length === 0 || !model.bindTools) return model;
-		return model.bindTools(itemScopedTools.map((entry) => entry.langChainTool));
-	}
 	resolveTools(toolConfigs) {
 		const resolvedTools = toolConfigs.map((config$1) => ({
 			config: config$1,
@@ -3390,38 +5835,120 @@ let AIAgentNode = class AIAgentNode$1 {
 				connectionNodeId: __codemation_core.ConnectionNodeIdFactory.toolConnectionNodeId(ctx.nodeId, entry.config.name),
 				getCredentialRequirements: () => entry.config.getCredentialRequirements?.() ?? []
 			});
-			const langChainTool = this.executionHelpers.createDynamicStructuredTool(entry, toolCredentialContext, item, itemIndex, items);
 			return {
 				config: entry.config,
-				langChainTool
+				inputSchema: entry.runtime.inputSchema,
+				execute: async (input, hooks) => {
+					const validated = entry.runtime.inputSchema.parse(input);
+					return await entry.runtime.execute({
+						config: entry.config,
+						input: validated,
+						ctx: toolCredentialContext,
+						item,
+						itemIndex,
+						items,
+						hooks
+					});
+				}
 			};
 		});
 	}
-	async invokeModel(model, nodeId, messages, ctx, inputsByPort, options) {
+	/**
+	* Builds an AI SDK {@link ToolSet} where every tool ships a pre-converted JSON Schema (via
+	* {@link jsonSchema}) — not the raw Zod schema — and carries **no** `execute`. Two reasons:
+	*
+	* 1. Codemation owns tool dispatch + the per-tool repair loop (see {@link AgentToolExecutionCoordinator}),
+	*    so the AI SDK must surface tool calls back to us instead of auto-running them.
+	* 2. The AI SDK's `asSchema` helper discriminates between Zod v3 / Zod v4 / Standard Schema via
+	*    runtime feature-detection (`~standard`, `_zod`, etc.). Handing it a pre-built
+	*    {@link jsonSchema} record — which is tagged with `Symbol.for('vercel.ai.schema')` — skips all
+	*    of that detection and guarantees the provider receives a draft-07 JSON Schema with
+	*    `additionalProperties: false` at every object depth (see {@link OpenAiStrictJsonSchemaFactory}
+	*    for the same logic applied to structured-output schemas). Codemation still runs its own Zod
+	*    validation on tool inputs before execute — the schema handed to the model is advisory.
+	*/
+	buildToolSet(itemScopedTools) {
+		if (itemScopedTools.length === 0) return void 0;
+		const toolSet = {};
+		for (const entry of itemScopedTools) {
+			const schemaRecord = this.executionHelpers.createJsonSchemaRecord(entry.inputSchema, {
+				schemaName: entry.config.name,
+				requireObjectRoot: true
+			});
+			toolSet[entry.config.name] = {
+				description: entry.config.description,
+				inputSchema: (0, ai.jsonSchema)(schemaRecord)
+			};
+		}
+		return toolSet;
+	}
+	/**
+	* One `generateText` turn (no auto tool execution) with Codemation-owned child-span telemetry
+	* and connection-invocation state recording.
+	*/
+	async invokeTextTurn(prepared, itemInputsByPort, messages, itemScopedTools) {
 		const invocationId = __codemation_core.ConnectionInvocationIdFactory.create();
 		const startedAt = /* @__PURE__ */ new Date();
 		const summarizedInput = this.summarizeLlmMessages(messages);
+		const { ctx, model, languageModelConnectionNodeId, guardrails } = prepared;
 		const span = this.createModelInvocationSpan(ctx, invocationId, startedAt);
 		await ctx.nodeState?.markQueued({
-			nodeId,
+			nodeId: languageModelConnectionNodeId,
 			activationId: ctx.activationId,
-			inputsByPort
+			inputsByPort: itemInputsByPort
+		});
+		await ctx.nodeState?.appendConnectionInvocation({
+			invocationId,
+			connectionNodeId: languageModelConnectionNodeId,
+			parentAgentNodeId: ctx.nodeId,
+			parentAgentActivationId: ctx.activationId,
+			status: "queued",
+			managedInput: summarizedInput,
+			queuedAt: startedAt.toISOString(),
+			iterationId: ctx.iterationId,
+			itemIndex: ctx.itemIndex,
+			parentInvocationId: ctx.parentInvocationId
 		});
 		await ctx.nodeState?.markRunning({
-			nodeId,
+			nodeId: languageModelConnectionNodeId,
 			activationId: ctx.activationId,
-			inputsByPort
+			inputsByPort: itemInputsByPort
+		});
+		await ctx.nodeState?.appendConnectionInvocation({
+			invocationId,
+			connectionNodeId: languageModelConnectionNodeId,
+			parentAgentNodeId: ctx.nodeId,
+			parentAgentActivationId: ctx.activationId,
+			status: "running",
+			managedInput: summarizedInput,
+			queuedAt: startedAt.toISOString(),
+			startedAt: startedAt.toISOString(),
+			iterationId: ctx.iterationId,
+			itemIndex: ctx.itemIndex,
+			parentInvocationId: ctx.parentInvocationId
 		});
 		try {
-			const response = await model.invoke(messages, options);
+			const tools = this.buildToolSet(itemScopedTools);
+			const callOptions = this.resolveCallOptions(model, guardrails.modelInvocationOptions);
+			const result = await (0, ai.generateText)({
+				model: model.languageModel,
+				messages: [...messages],
+				tools,
+				toolChoice: tools ? "auto" : void 0,
+				maxOutputTokens: callOptions.maxOutputTokens,
+				temperature: callOptions.temperature,
+				providerOptions: callOptions.providerOptions,
+				maxRetries: 0
+			});
+			const turnResult = this.extractTurnResult(result);
 			const finishedAt = /* @__PURE__ */ new Date();
+			const managedOutput = this.summarizeTurnOutput(turnResult);
 			await ctx.nodeState?.markCompleted({
-				nodeId,
+				nodeId: languageModelConnectionNodeId,
 				activationId: ctx.activationId,
-				inputsByPort,
-				outputs: AgentOutputFactory.fromUnknown({ content: AgentMessageFactory.extractContent(response) })
+				inputsByPort: itemInputsByPort,
+				outputs: AgentOutputFactory.fromUnknown(managedOutput)
 			});
-			const content = AgentMessageFactory.extractContent(response);
 			await span.attachArtifact({
 				kind: "ai.messages",
 				contentType: "application/json",
@@ -3430,26 +5957,29 @@ let AIAgentNode = class AIAgentNode$1 {
 			await span.attachArtifact({
 				kind: "ai.response",
 				contentType: "application/json",
-				previewJson: content
+				previewJson: turnResult.text
 			});
-			await this.recordModelUsageMetrics(span, response, ctx);
+			await this.recordModelUsageMetrics(span, turnResult.usage, ctx);
 			await span.end({
 				status: "ok",
 				endedAt: finishedAt
 			});
 			await ctx.nodeState?.appendConnectionInvocation({
 				invocationId,
-				connectionNodeId: nodeId,
+				connectionNodeId: languageModelConnectionNodeId,
 				parentAgentNodeId: ctx.nodeId,
 				parentAgentActivationId: ctx.activationId,
 				status: "completed",
 				managedInput: summarizedInput,
-				managedOutput: content,
+				managedOutput,
 				queuedAt: startedAt.toISOString(),
 				startedAt: startedAt.toISOString(),
-				finishedAt: finishedAt.toISOString()
+				finishedAt: finishedAt.toISOString(),
+				iterationId: ctx.iterationId,
+				itemIndex: ctx.itemIndex,
+				parentInvocationId: ctx.parentInvocationId
 			});
-			return response;
+			return turnResult;
 		} catch (error) {
 			await span.end({
 				status: "error",
@@ -3460,36 +5990,78 @@ let AIAgentNode = class AIAgentNode$1 {
 				error,
 				invocationId,
 				startedAt,
-				nodeId,
+				nodeId: languageModelConnectionNodeId,
 				ctx,
-				inputsByPort,
-				managedInput: this.summarizeLlmMessages(messages)
+				inputsByPort: itemInputsByPort,
+				managedInput: summarizedInput
 			});
 		}
 	}
-	async invokeStructuredModel(model, nodeId, messages, ctx, inputsByPort, options) {
+	/**
+	* Structured-output turn: runs `generateText({ output: Output.object({ schema }) })` via the
+	* structured-output runner.  We keep this as a separate helper because the runner needs the raw
+	* validated value (not just text) back, and must be able to retry on Zod failures.
+	*/
+	async invokeStructuredTurn(prepared, itemInputsByPort, schema, messages, structuredOptions) {
 		const invocationId = __codemation_core.ConnectionInvocationIdFactory.create();
 		const startedAt = /* @__PURE__ */ new Date();
 		const summarizedInput = this.summarizeLlmMessages(messages);
+		const { ctx, model, languageModelConnectionNodeId, guardrails } = prepared;
 		const span = this.createModelInvocationSpan(ctx, invocationId, startedAt);
 		await ctx.nodeState?.markQueued({
-			nodeId,
+			nodeId: languageModelConnectionNodeId,
 			activationId: ctx.activationId,
-			inputsByPort
+			inputsByPort: itemInputsByPort
+		});
+		await ctx.nodeState?.appendConnectionInvocation({
+			invocationId,
+			connectionNodeId: languageModelConnectionNodeId,
+			parentAgentNodeId: ctx.nodeId,
+			parentAgentActivationId: ctx.activationId,
+			status: "queued",
+			managedInput: summarizedInput,
+			queuedAt: startedAt.toISOString(),
+			iterationId: ctx.iterationId,
+			itemIndex: ctx.itemIndex,
+			parentInvocationId: ctx.parentInvocationId
 		});
 		await ctx.nodeState?.markRunning({
-			nodeId,
+			nodeId: languageModelConnectionNodeId,
 			activationId: ctx.activationId,
-			inputsByPort
+			inputsByPort: itemInputsByPort
+		});
+		await ctx.nodeState?.appendConnectionInvocation({
+			invocationId,
+			connectionNodeId: languageModelConnectionNodeId,
+			parentAgentNodeId: ctx.nodeId,
+			parentAgentActivationId: ctx.activationId,
+			status: "running",
+			managedInput: summarizedInput,
+			queuedAt: startedAt.toISOString(),
+			startedAt: startedAt.toISOString(),
+			iterationId: ctx.iterationId,
+			itemIndex: ctx.itemIndex,
+			parentInvocationId: ctx.parentInvocationId
 		});
 		try {
-			const response = await model.invoke(messages, options);
+			const callOptions = this.resolveCallOptions(model, guardrails.modelInvocationOptions);
+			const outputSchema = structuredOptions?.strict && !this.isZodSchema(schema) ? ai.Output.object({ schema: (0, ai.jsonSchema)(schema) }) : ai.Output.object({ schema });
+			const result = await (0, ai.generateText)({
+				model: model.languageModel,
+				messages: [...messages],
+				experimental_output: outputSchema,
+				maxOutputTokens: callOptions.maxOutputTokens,
+				temperature: callOptions.temperature,
+				providerOptions: callOptions.providerOptions,
+				maxRetries: 0
+			});
+			const turnResult = this.extractTurnResult(result);
 			const finishedAt = /* @__PURE__ */ new Date();
 			await ctx.nodeState?.markCompleted({
-				nodeId,
+				nodeId: languageModelConnectionNodeId,
 				activationId: ctx.activationId,
-				inputsByPort,
-				outputs: AgentOutputFactory.fromUnknown(response)
+				inputsByPort: itemInputsByPort,
+				outputs: AgentOutputFactory.fromUnknown(result.experimental_output)
 			});
 			await span.attachArtifact({
 				kind: "ai.messages",
@@ -3499,26 +6071,29 @@ let AIAgentNode = class AIAgentNode$1 {
 			await span.attachArtifact({
 				kind: "ai.response.structured",
 				contentType: "application/json",
-				previewJson: this.resultToJsonValue(response)
+				previewJson: this.resultToJsonValue(result.experimental_output)
 			});
-			await this.recordModelUsageMetrics(span, response, ctx);
+			await this.recordModelUsageMetrics(span, turnResult.usage, ctx);
 			await span.end({
 				status: "ok",
 				endedAt: finishedAt
 			});
 			await ctx.nodeState?.appendConnectionInvocation({
 				invocationId,
-				connectionNodeId: nodeId,
+				connectionNodeId: languageModelConnectionNodeId,
 				parentAgentNodeId: ctx.nodeId,
 				parentAgentActivationId: ctx.activationId,
 				status: "completed",
 				managedInput: summarizedInput,
-				managedOutput: this.resultToJsonValue(response),
+				managedOutput: this.resultToJsonValue(result.experimental_output),
 				queuedAt: startedAt.toISOString(),
 				startedAt: startedAt.toISOString(),
-				finishedAt: finishedAt.toISOString()
+				finishedAt: finishedAt.toISOString(),
+				iterationId: ctx.iterationId,
+				itemIndex: ctx.itemIndex,
+				parentInvocationId: ctx.parentInvocationId
 			});
-			return response;
+			return result.experimental_output;
 		} catch (error) {
 			await span.end({
 				status: "error",
@@ -3529,13 +6104,77 @@ let AIAgentNode = class AIAgentNode$1 {
 				error,
 				invocationId,
 				startedAt,
-				nodeId,
+				nodeId: languageModelConnectionNodeId,
 				ctx,
-				inputsByPort,
-				managedInput: this.summarizeLlmMessages(messages)
+				inputsByPort: itemInputsByPort,
+				managedInput: summarizedInput
 			});
 		}
 	}
+	isZodSchema(schema) {
+		return typeof schema.parse === "function";
+	}
+	resolveCallOptions(model, overrides) {
+		const defaults = model.defaultCallOptions ?? {};
+		return {
+			maxOutputTokens: overrides?.maxTokens ?? defaults.maxOutputTokens,
+			temperature: defaults.temperature,
+			providerOptions: overrides?.providerOptions ?? defaults.providerOptions
+		};
+	}
+	/**
+	* Build a no-code-friendly output payload for an LLM round.
+	*
+	* Always includes `content` (matching the canvas snapshot shape used elsewhere) and adds a
+	* `toolCalls` array when the round produced tool calls so the execution inspector surfaces the
+	* planned calls instead of just an empty `""` for tool-only rounds.
+	*/
+	summarizeTurnOutput(turnResult) {
+		if (turnResult.toolCalls.length === 0) return { content: turnResult.text };
+		const toolCalls = turnResult.toolCalls.map((toolCall) => ({
+			name: toolCall.name,
+			args: this.resultToJsonValue(toolCall.input) ?? null
+		}));
+		return {
+			content: turnResult.text,
+			toolCalls
+		};
+	}
+	extractTurnResult(result) {
+		const usage = this.extractUsageFromResult(result);
+		const text = result.text;
+		const toolCalls = result.toolCalls.map((toolCall) => ({
+			id: toolCall.toolCallId,
+			name: toolCall.toolName,
+			input: toolCall.input
+		}));
+		return {
+			assistantMessage: this.extractAssistantMessage(result),
+			text,
+			toolCalls,
+			usage
+		};
+	}
+	extractAssistantMessage(result) {
+		const assistantMessages = result.response.messages.filter((m) => m.role === "assistant");
+		return assistantMessages[assistantMessages.length - 1];
+	}
+	extractUsageFromResult(result) {
+		const usage = result.usage;
+		const inputTokens = this.toFiniteNumber(usage.inputTokens);
+		const outputTokens = this.toFiniteNumber(usage.outputTokens);
+		return {
+			inputTokens,
+			outputTokens,
+			totalTokens: this.toFiniteNumber(usage.totalTokens) ?? (inputTokens !== void 0 && outputTokens !== void 0 ? inputTokens + outputTokens : void 0),
+			cachedInputTokens: this.toFiniteNumber(usage.cachedInputTokens),
+			reasoningTokens: this.toFiniteNumber(usage.reasoningTokens)
+		};
+	}
+	toFiniteNumber(value) {
+		if (typeof value !== "number" || !Number.isFinite(value)) return void 0;
+		return value;
+	}
 	createModelInvocationSpan(ctx, invocationId, startedAt) {
 		return ctx.telemetry.startChildSpan({
 			name: "gen_ai.chat.completion",
@@ -3544,13 +6183,22 @@ let AIAgentNode = class AIAgentNode$1 {
 			attributes: {
 				[__codemation_core.CodemationTelemetryAttributeNames.connectionInvocationId]: invocationId,
 				[__codemation_core.GenAiTelemetryAttributeNames.operationName]: "chat",
-				[__codemation_core.GenAiTelemetryAttributeNames.requestModel]: this.resolveChatModelName(ctx.config.chatModel)
+				[__codemation_core.GenAiTelemetryAttributeNames.requestModel]: this.resolveChatModelName(ctx.config.chatModel),
+				...ctx.iterationId ? { [__codemation_core.CodemationTelemetryAttributeNames.iterationId]: ctx.iterationId } : {},
+				...typeof ctx.itemIndex === "number" ? { [__codemation_core.CodemationTelemetryAttributeNames.iterationIndex]: ctx.itemIndex } : {},
+				...ctx.parentInvocationId ? { [__codemation_core.CodemationTelemetryAttributeNames.parentInvocationId]: ctx.parentInvocationId } : {}
 			}
 		});
 	}
-	async recordModelUsageMetrics(span, response, ctx) {
-		const usage = this.extractModelUsageMetrics(response);
-		for (const [name, value] of Object.entries(usage)) {
+	async recordModelUsageMetrics(span, usage, ctx) {
+		const entries = [
+			[__codemation_core.GenAiTelemetryAttributeNames.usageInputTokens, usage.inputTokens],
+			[__codemation_core.GenAiTelemetryAttributeNames.usageOutputTokens, usage.outputTokens],
+			[__codemation_core.GenAiTelemetryAttributeNames.usageTotalTokens, usage.totalTokens],
+			[__codemation_core.GenAiTelemetryAttributeNames.usageCacheReadInputTokens, usage.cachedInputTokens],
+			[__codemation_core.GenAiTelemetryAttributeNames.usageReasoningTokens, usage.reasoningTokens]
+		];
+		for (const [name, value] of entries) {
 			if (value === void 0) continue;
 			await span.recordMetric({
 				name,
@@ -3565,99 +6213,49 @@ let AIAgentNode = class AIAgentNode$1 {
 		const provider = ctx.config.chatModel.provider;
 		const pricingKey = ctx.config.chatModel.modelName;
 		if (!provider || !pricingKey) return;
-		const inputTokens = usage[__codemation_core.GenAiTelemetryAttributeNames.usageInputTokens];
-		const outputTokens = usage[__codemation_core.GenAiTelemetryAttributeNames.usageOutputTokens];
-		if (inputTokens !== void 0) await costTracking.captureUsage({
+		if (usage.inputTokens !== void 0) await costTracking.captureUsage({
 			component: "chat",
 			provider,
 			operation: "completion.input",
 			pricingKey,
 			usageUnit: "input_tokens",
-			quantity: inputTokens,
+			quantity: usage.inputTokens,
 			modelName: pricingKey
 		});
-		if (outputTokens !== void 0) await costTracking.captureUsage({
+		if (usage.outputTokens !== void 0) await costTracking.captureUsage({
 			component: "chat",
 			provider,
 			operation: "completion.output",
 			pricingKey,
 			usageUnit: "output_tokens",
-			quantity: outputTokens,
+			quantity: usage.outputTokens,
 			modelName: pricingKey
 		});
 	}
 	resolveChatModelName(chatModel$1) {
 		return chatModel$1.modelName ?? chatModel$1.name;
 	}
-	extractModelUsageMetrics(response) {
-		const usage = this.extractUsageObject(response);
-		const inputTokens = this.readUsageNumber(usage, [
-			"input_tokens",
-			"inputTokens",
-			"prompt_tokens",
-			"promptTokens"
-		]);
-		const outputTokens = this.readUsageNumber(usage, [
-			"output_tokens",
-			"outputTokens",
-			"completion_tokens",
-			"completionTokens"
-		]);
-		const totalTokens = this.readUsageNumber(usage, ["total_tokens", "totalTokens"]) ?? (inputTokens !== void 0 && outputTokens !== void 0 ? inputTokens + outputTokens : void 0);
-		const cachedInputTokens = this.readUsageNumber(usage, [
-			"cache_read_input_tokens",
-			"cacheReadInputTokens",
-			"input_token_details.cached_tokens"
-		]);
-		const reasoningTokens = this.readUsageNumber(usage, [
-			"reasoning_tokens",
-			"reasoningTokens",
-			"output_token_details.reasoning_tokens"
-		]);
-		return {
-			[__codemation_core.GenAiTelemetryAttributeNames.usageInputTokens]: inputTokens,
-			[__codemation_core.GenAiTelemetryAttributeNames.usageOutputTokens]: outputTokens,
-			[__codemation_core.GenAiTelemetryAttributeNames.usageTotalTokens]: totalTokens,
-			[__codemation_core.GenAiTelemetryAttributeNames.usageCacheReadInputTokens]: cachedInputTokens,
-			[__codemation_core.GenAiTelemetryAttributeNames.usageReasoningTokens]: reasoningTokens
-		};
-	}
-	extractUsageObject(response) {
-		if (!this.isRecord(response)) return;
-		const usageMetadata = response["usage_metadata"];
-		if (this.isRecord(usageMetadata)) return usageMetadata;
-		const responseMetadata = response["response_metadata"];
-		if (this.isRecord(responseMetadata)) {
-			const tokenUsage = responseMetadata["tokenUsage"];
-			if (this.isRecord(tokenUsage)) return tokenUsage;
-			const usage = responseMetadata["usage"];
-			if (this.isRecord(usage)) return usage;
-		}
-	}
-	readUsageNumber(source, keys) {
-		for (const key of keys) {
-			const value = this.readNestedUsageValue(source, key);
-			if (typeof value === "number" && Number.isFinite(value)) return value;
-		}
-	}
-	readNestedUsageValue(source, dottedKey) {
-		if (!source) return;
-		let current = source;
-		for (const segment of dottedKey.split(".")) {
-			if (!this.isRecord(current)) return;
-			current = current[segment];
-		}
-		return current;
-	}
-	isRecord(value) {
-		return typeof value === "object" && value !== null;
-	}
 	async markQueuedTools(plannedToolCalls, ctx) {
-		for (const plannedToolCall of plannedToolCalls) await ctx.nodeState?.markQueued({
-			nodeId: plannedToolCall.nodeId,
-			activationId: ctx.activationId,
-			inputsByPort: AgentToolCallPortMap.fromInput(plannedToolCall.toolCall.input ?? {})
-		});
+		const queuedAt = (/* @__PURE__ */ new Date()).toISOString();
+		for (const plannedToolCall of plannedToolCalls) {
+			await ctx.nodeState?.markQueued({
+				nodeId: plannedToolCall.nodeId,
+				activationId: ctx.activationId,
+				inputsByPort: AgentToolCallPortMap.fromInput(plannedToolCall.toolCall.input ?? {})
+			});
+			await ctx.nodeState?.appendConnectionInvocation({
+				invocationId: plannedToolCall.invocationId,
+				connectionNodeId: plannedToolCall.nodeId,
+				parentAgentNodeId: ctx.nodeId,
+				parentAgentActivationId: ctx.activationId,
+				status: "queued",
+				managedInput: this.resultToJsonValue(plannedToolCall.toolCall.input),
+				queuedAt,
+				iterationId: ctx.iterationId,
+				itemIndex: ctx.itemIndex,
+				parentInvocationId: ctx.parentInvocationId
+			});
+		}
 	}
 	planToolCalls(bindings, toolCalls, parentNodeId) {
 		const invocationCountByToolName = /* @__PURE__ */ new Map();
@@ -3670,7 +6268,8 @@ let AIAgentNode = class AIAgentNode$1 {
 				binding,
 				toolCall,
 				invocationIndex,
-				nodeId: __codemation_core.ConnectionNodeIdFactory.toolConnectionNodeId(parentNodeId, binding.config.name)
+				nodeId: __codemation_core.ConnectionNodeIdFactory.toolConnectionNodeId(parentNodeId, binding.config.name),
+				invocationId: __codemation_core.ConnectionInvocationIdFactory.create()
 			};
 		});
 	}
@@ -3698,7 +6297,10 @@ let AIAgentNode = class AIAgentNode$1 {
 			},
 			queuedAt: args.startedAt.toISOString(),
 			startedAt: args.startedAt.toISOString(),
-			finishedAt: finishedAt.toISOString()
+			finishedAt: finishedAt.toISOString(),
+			iterationId: args.ctx.iterationId,
+			itemIndex: args.ctx.itemIndex,
+			parentInvocationId: args.ctx.parentInvocationId
 		});
 		return effectiveError;
 	}
@@ -3711,7 +6313,7 @@ let AIAgentNode = class AIAgentNode$1 {
 		};
 	}
 	resultToJsonValue(value) {
-		if (value === void 0) return;
+		if (value === void 0) return void 0;
 		const json = JSON.stringify(value);
 		return JSON.parse(json);
 	}
@@ -3726,7 +6328,7 @@ let AIAgentNode = class AIAgentNode$1 {
 	resolveToolRuntime(config$1) {
 		if (this.isNodeBackedToolConfig(config$1)) {
 			const inputSchema = config$1.getInputSchema();
-			if (inputSchema == null) throw new Error(`AIAgent tool "${config$1.name}": node-backed tool is missing inputSchema (cannot build LangChain tool).`);
+			if (inputSchema == null) throw new Error(`AIAgent tool "${config$1.name}": node-backed tool is missing inputSchema (cannot build AI SDK tool).`);
 			return {
 				defaultDescription: `Run workflow node "${config$1.node.name ?? config$1.name}" as an AI tool.`,
 				inputSchema,
@@ -3735,7 +6337,7 @@ let AIAgentNode = class AIAgentNode$1 {
 		}
 		if (this.isCallableToolConfig(config$1)) {
 			const inputSchema = config$1.getInputSchema();
-			if (inputSchema == null) throw new Error(`AIAgent tool "${config$1.name}": callable tool is missing inputSchema (cannot build LangChain tool).`);
+			if (inputSchema == null) throw new Error(`AIAgent tool "${config$1.name}": callable tool is missing inputSchema (cannot build AI SDK tool).`);
 			return {
 				defaultDescription: config$1.description ?? `Callable tool "${config$1.name}".`,
 				inputSchema,
@@ -3753,17 +6355,9 @@ let AIAgentNode = class AIAgentNode$1 {
 			execute: async (args) => await Promise.resolve(tool.execute(args))
 		};
 	}
-	/**
-	* Consumer apps can resolve two copies of `@codemation/core`, breaking `instanceof NodeBackedToolConfig` and
-	* sending node-backed tools down the plugin-tool branch with `inputSchema: undefined` (LangChain then crashes in
-	* json-schema validation). {@link NodeBackedToolConfig#toolKind} is stable across copies.
-	*/
 	isNodeBackedToolConfig(config$1) {
 		return config$1 instanceof __codemation_core.NodeBackedToolConfig || typeof config$1 === "object" && config$1 !== null && config$1.toolKind === "nodeBacked";
 	}
-	/**
-	* Callable tools use {@link CallableToolConfig#toolKind} for cross-package / JSON round-trip safety.
-	*/
 	isCallableToolConfig(config$1) {
 		return config$1 instanceof __codemation_core.CallableToolConfig || typeof config$1 === "object" && config$1 !== null && config$1.toolKind === "callable";
 	}
@@ -3834,6 +6428,52 @@ var AIAgent = class {
 	}
 };
 
+//#endregion
+//#region src/nodes/AssertionNode.ts
+let AssertionNode = class AssertionNode$1 {
+	kind = "node";
+	outputPorts = ["main"];
+	async execute(args) {
+		const ctx = args.ctx;
+		const config$1 = ctx.config;
+		try {
+			return [...await config$1.assertions(args.item, ctx)];
+		} catch (err) {
+			const message = err instanceof Error ? err.message : String(err);
+			return [{
+				name: config$1.name ?? "assertion",
+				score: 0,
+				errored: true,
+				message
+			}];
+		}
+	}
+};
+AssertionNode = __decorate([(0, __codemation_core.node)({ packageName: "@codemation/core-nodes" })], AssertionNode);
+
+//#endregion
+//#region src/nodes/assertion.ts
+/**
+* Generic assertion node — the "callback" form. For declarative shorthands (StringEquals,
+* JudgeByAgent) compose this with helpers added in later phases. Sets `emitsAssertions: true`
+* so host-side persisters know to record its outputs as `TestAssertion` rows.
+*/
+var Assertion = class {
+	kind = "node";
+	type = AssertionNode;
+	icon;
+	name;
+	id;
+	emitsAssertions = true;
+	assertions;
+	constructor(options) {
+		this.name = options.name ?? "Assertion";
+		this.id = options.id;
+		this.icon = options.icon ?? "lucide:check-circle";
+		this.assertions = options.assertions;
+	}
+};
+
 //#endregion
 //#region src/nodes/CallbackResultNormalizerFactory.ts
 var CallbackResultNormalizer = class {
@@ -3903,32 +6543,113 @@ let HttpRequestNode = class HttpRequestNode$1 {
 	}
 	async executeItem(item, ctx) {
 		const url = this.resolveUrl(item, ctx);
-		const response = await fetch(url, { method: ctx.config.method });
+		const credential = await this.resolveCredential(ctx);
+		const spec = {
+			url,
+			method: ctx.config.method,
+			headers: ctx.config.args.headers,
+			query: ctx.config.args.query,
+			body: ctx.config.args.body,
+			credential,
+			download: {
+				mode: ctx.config.downloadMode,
+				binaryName: ctx.config.binaryName
+			},
+			responseFormat: ctx.config.responseFormat,
+			responseBinarySlot: ctx.config.responseBinarySlot,
+			responseSizeCapBytes: ctx.config.responseSizeCapBytes,
+			ctx
+		};
+		const { url: resolvedUrl, init } = await new HttpRequestExecutor(globalThis.fetch, new HttpBodyBuilder(), new HttpUrlBuilder()).buildRequest(spec, item);
+		const response = await globalThis.fetch(resolvedUrl, init);
 		const headers = this.readHeaders(response.headers);
 		const mimeType = this.resolveMimeType(headers);
-		const bodyBinaryName = ctx.config.binaryName;
-		const shouldAttachBody = this.shouldAttachBody(ctx.config.downloadMode, mimeType);
-		let outputItem = { json: {
-			url,
+		if (ctx.config.responseFormat === "binary") return await this.handleBinaryResponse(response, resolvedUrl, headers, mimeType, ctx);
+		const binaryName = ctx.config.binaryName;
+		if (this.shouldAttachBody(ctx.config.downloadMode, mimeType)) {
+			const outputJson = {
+				url: resolvedUrl,
+				method: ctx.config.method,
+				ok: response.ok,
+				status: response.status,
+				statusText: response.statusText,
+				mimeType,
+				headers,
+				bodyBinaryName: binaryName
+			};
+			const attachment = await ctx.binary.attach({
+				name: binaryName,
+				body: response.body ? response.body : new Uint8Array(await response.arrayBuffer()),
+				mimeType,
+				filename: this.resolveFilename(resolvedUrl, headers)
+			});
+			let outputItem = { json: outputJson };
+			outputItem = ctx.binary.withAttachment(outputItem, binaryName, attachment);
+			return outputItem;
+		}
+		const isJson = this.isJsonMimeType(mimeType);
+		let json;
+		let text;
+		if (isJson) try {
+			json = await response.json();
+		} catch {
+			text = await response.text();
+		}
+		else text = await response.text();
+		return { json: {
+			url: resolvedUrl,
 			method: ctx.config.method,
 			ok: response.ok,
 			status: response.status,
 			statusText: response.statusText,
 			mimeType,
 			headers,
-			...shouldAttachBody ? { bodyBinaryName } : {}
+			...json !== void 0 ? { json } : {},
+			...text !== void 0 ? { text } : {}
 		} };
-		if (!shouldAttachBody) return outputItem;
+	}
+	async handleBinaryResponse(response, resolvedUrl, headers, mimeType, ctx) {
+		const slotName = ctx.config.responseBinarySlot;
+		const sizeCap = ctx.config.responseSizeCapBytes;
+		const contentLengthHeader = headers["content-length"];
+		if (contentLengthHeader) {
+			const declaredSize = parseInt(contentLengthHeader, 10);
+			if (!isNaN(declaredSize) && declaredSize > sizeCap) throw new Error(`HttpRequest responseFormat "binary": response Content-Length (${declaredSize} bytes) exceeds responseSizeCapBytes (${sizeCap} bytes).`);
+		}
+		const filename = this.resolveFilename(resolvedUrl, headers);
 		const attachment = await ctx.binary.attach({
-			name: bodyBinaryName,
+			name: slotName,
 			body: response.body ? response.body : new Uint8Array(await response.arrayBuffer()),
 			mimeType,
-			filename: this.resolveFilename(url, headers)
+			filename
 		});
-		outputItem = ctx.binary.withAttachment(outputItem, bodyBinaryName, attachment);
+		let outputItem = { json: {
+			url: resolvedUrl,
+			method: ctx.config.method,
+			ok: response.ok,
+			status: response.status,
+			statusText: response.statusText,
+			headers,
+			binarySlot: slotName,
+			contentType: mimeType,
+			size: attachment.size,
+			...filename !== void 0 ? { filename } : {}
+		} };
+		outputItem = ctx.binary.withAttachment(outputItem, slotName, attachment);
 		return outputItem;
 	}
+	async resolveCredential(ctx) {
+		const slotKey = ctx.config.args.credentialSlot;
+		if (!slotKey) return;
+		try {
+			return await ctx.getCredential(slotKey);
+		} catch {
+			return;
+		}
+	}
 	resolveUrl(item, ctx) {
+		const literalUrl = ctx.config.args.url;
+		if (literalUrl && literalUrl.trim().length > 0) return literalUrl.trim();
 		const candidate = this.asRecord(item.json)[ctx.config.urlField];
 		if (typeof candidate !== "string" || candidate.trim() === "") throw new Error(`HttpRequest node expected item.json.${ctx.config.urlField} to contain a URL string.`);
 		return candidate;
@@ -3949,6 +6670,9 @@ let HttpRequestNode = class HttpRequestNode$1 {
 		if (!contentType) return "application/octet-stream";
 		return contentType.split(";")[0]?.trim() || "application/octet-stream";
 	}
+	isJsonMimeType(mimeType) {
+		return mimeType === "application/json" || mimeType.endsWith("+json");
+	}
 	shouldAttachBody(mode, mimeType) {
 		if (mode === "always") return true;
 		if (mode === "never") return false;
@@ -3975,10 +6699,23 @@ HttpRequestNode = __decorate([(0, __codemation_core.node)({ packageName: "@codem
 
 //#endregion
 //#region src/nodes/httpRequest.ts
+/**
+* The built-in HTTP request credential type IDs accepted by the `HttpRequest` node.
+* These match the four generic credential types shipped with `@codemation/core-nodes`.
+*/
+const HTTP_REQUEST_ACCEPTED_CREDENTIAL_TYPES = [
+	bearerTokenCredentialType.definition.typeId,
+	apiKeyCredentialType.definition.typeId,
+	basicAuthCredentialType.definition.typeId,
+	oauth2ClientCredentialsType.definition.typeId
+];
+/** Default maximum response size for binary mode: 100 MiB. */
+const DEFAULT_RESPONSE_SIZE_CAP_BYTES = 100 * 1024 * 1024;
 var HttpRequest = class {
 	kind = "node";
 	type = HttpRequestNode;
 	execution = { hint: "local" };
+	icon = "lucide:globe";
 	constructor(name, args = {}, retryPolicy = __codemation_core.RetryPolicy.defaultForHttp) {
 		this.name = name;
 		this.args = args;
@@ -3999,6 +6736,25 @@ var HttpRequest = class {
 	get downloadMode() {
 		return this.args.downloadMode ?? "auto";
 	}
+	get responseFormat() {
+		return this.args.responseFormat;
+	}
+	get responseBinarySlot() {
+		return this.args.responseBinarySlot ?? "response";
+	}
+	get responseSizeCapBytes() {
+		return this.args.responseSizeCapBytes ?? DEFAULT_RESPONSE_SIZE_CAP_BYTES;
+	}
+	getCredentialRequirements() {
+		if (!this.args.credentialSlot) return [];
+		return [{
+			slotKey: this.args.credentialSlot,
+			label: "Authentication",
+			acceptedTypes: HTTP_REQUEST_ACCEPTED_CREDENTIAL_TYPES,
+			optional: true,
+			helpText: "Optional credential for authenticating the HTTP request."
+		}];
+	}
 };
 
 //#endregion
@@ -4020,7 +6776,7 @@ var Aggregate = class {
 	type = AggregateNode;
 	execution = { hint: "local" };
 	keepBinaries = true;
-	icon = "lucide:layers";
+	icon = "builtin:aggregate-rows";
 	constructor(name, aggregate, id) {
 		this.name = name;
 		this.aggregate = aggregate;
@@ -4115,7 +6871,7 @@ var If = class {
 	kind = "node";
 	type = IfNode;
 	execution = { hint: "local" };
-	icon = "lucide:split";
+	icon = "lucide:split@rot=90";
 	declaredOutputPorts = ["true", "false"];
 	constructor(name, predicate, id) {
 		this.name = name;
@@ -4124,6 +6880,40 @@ var If = class {
 	}
 };
 
+//#endregion
+//#region src/nodes/IsTestRunNode.ts
+let IsTestRunNode = class IsTestRunNode$1 {
+	kind = "node";
+	execute(args) {
+		const isTest = args.ctx.testContext !== void 0;
+		return (0, __codemation_core.emitPorts)({
+			true: isTest ? [args.item] : [],
+			false: isTest ? [] : [args.item]
+		});
+	}
+};
+IsTestRunNode = __decorate([(0, __codemation_core.node)({ packageName: "@codemation/core-nodes" })], IsTestRunNode);
+
+//#endregion
+//#region src/nodes/isTestRun.ts
+/**
+* Branches per-item on whether the current run is a test run. Output ports: `true`, `false`.
+* The wire payload is unchanged — this is a router, not a transform.
+*/
+var IsTestRun = class {
+	kind = "node";
+	type = IsTestRunNode;
+	execution = { hint: "local" };
+	icon = "lucide:flask-conical";
+	declaredOutputPorts = ["true", "false"];
+	name;
+	id;
+	constructor(name = "Is test run?", id) {
+		this.name = name;
+		this.id = id;
+	}
+};
+
 //#endregion
 //#region src/nodes/SwitchNode.ts
 let SwitchNode = class SwitchNode$1 {
@@ -4180,7 +6970,7 @@ var Split = class {
 	* Mirrors {@link MapData}'s empty-output behavior.
 	*/
 	continueWhenEmptyOutput = true;
-	icon = "lucide:ungroup";
+	icon = "builtin:split-rows";
 	constructor(name, getElements, id) {
 		this.name = name;
 		this.getElements = getElements;
@@ -4188,6 +6978,75 @@ var Split = class {
 	}
 };
 
+//#endregion
+//#region src/nodes/CronTriggerNode.ts
+let CronTriggerNode = class CronTriggerNode$1 {
+	kind = "trigger";
+	outputPorts = ["main"];
+	async setup(ctx) {
+		const job = ctx.config.createJob(async (self) => {
+			const scheduledFor = self.currentRun()?.toISOString() ?? ctx.now().toISOString();
+			await ctx.emit([{ json: {
+				firedAt: ctx.now().toISOString(),
+				scheduledFor
+			} }]);
+		});
+		ctx.registerCleanup({ stop: () => {
+			job.stop();
+		} });
+	}
+	async execute(items, _ctx) {
+		return { main: items };
+	}
+	async getTestItems(ctx) {
+		const nowIso = ctx.now().toISOString();
+		return [{ json: {
+			firedAt: nowIso,
+			scheduledFor: nowIso
+		} }];
+	}
+};
+CronTriggerNode = __decorate([(0, __codemation_core.node)({ packageName: "@codemation/core-nodes" })], CronTriggerNode);
+
+//#endregion
+//#region src/nodes/CronTriggerFactory.ts
+/**
+* Schedules a workflow on a standard cron expression.
+*
+* Each tick emits one item: `{ firedAt: string, scheduledFor: string }` — both ISO-8601 timestamps.
+* `firedAt` is the wall-clock moment the callback ran; `scheduledFor` is the cron-computed
+* firing instant (these differ when the job was delayed).
+*
+* Timezone defaults to UTC when omitted — cron without an explicit TZ is a DST footgun.
+*/
+var CronTrigger = class {
+	kind = "trigger";
+	type = CronTriggerNode;
+	icon = "lucide:clock";
+	id;
+	constructor(name, args, id) {
+		this.name = name;
+		this.args = args;
+		new croner.Cron(args.schedule, {
+			paused: true,
+			timezone: args.timezone
+		});
+		this.id = id;
+	}
+	get schedule() {
+		return this.args.schedule;
+	}
+	get timezone() {
+		return this.args.timezone;
+	}
+	createJob(callback) {
+		return new croner.Cron(this.args.schedule, {
+			timezone: this.args.timezone,
+			protect: true
+		}, callback);
+	}
+};
+
 //#endregion
 //#region src/nodes/ManualTriggerNode.ts
 let ManualTriggerNode = class ManualTriggerNode$1 {
@@ -4251,6 +7110,7 @@ var MapData = class {
 	execution = { hint: "local" };
 	/** Zero mapped items should still allow downstream nodes to run. */
 	continueWhenEmptyOutput = true;
+	icon = "lucide:square-pen";
 	keepBinaries;
 	constructor(name, map, options = {}) {
 		this.name = name;
@@ -4320,7 +7180,7 @@ MergeNode = __decorate([(0, __codemation_core.node)({ packageName: "@codemation/
 var Merge = class {
 	kind = "node";
 	type = MergeNode;
-	icon = "lucide:git-merge";
+	icon = "lucide:merge@rot=90";
 	constructor(name, cfg = { mode: "passThrough" }, id) {
 		this.name = name;
 		this.cfg = cfg;
@@ -4345,6 +7205,7 @@ var NoOp = class {
 	kind = "node";
 	type = NoOpNode;
 	execution = { hint: "local" };
+	icon = "lucide:circle-dashed";
 	constructor(name = "NoOp", id) {
 		this.name = name;
 		this.id = id;
@@ -4417,6 +7278,52 @@ var SubWorkflow = class {
 	}
 };
 
+//#endregion
+//#region src/nodes/TestTriggerNode.ts
+let TestTriggerNode = class TestTriggerNode$1 {
+	kind = "trigger";
+	outputPorts = ["main"];
+	async setup(_ctx) {}
+	async execute(items, _ctx) {
+		return { main: items };
+	}
+};
+TestTriggerNode = __decorate([(0, __codemation_core.node)({ packageName: "@codemation/core-nodes" })], TestTriggerNode);
+
+//#endregion
+//#region src/nodes/testTrigger.ts
+/**
+* Trigger config for a test fixture source. Drop one (or more) of these on the canvas alongside
+* a workflow's live triggers; clicking "Run tests" on the Tests tab invokes
+* {@link TestTriggerOptions.generateItems} via the TestSuiteOrchestrator.
+*/
+var TestTrigger = class {
+	kind = "trigger";
+	triggerKind = "test";
+	type = TestTriggerNode;
+	icon;
+	name;
+	id;
+	concurrency;
+	description;
+	generateItems;
+	caseLabel;
+	credentialRequirements;
+	constructor(options) {
+		this.name = options.name ?? "Test trigger";
+		this.id = options.id;
+		this.icon = options.icon ?? "lucide:flask-conical";
+		this.concurrency = options.concurrency;
+		this.description = options.description;
+		this.credentialRequirements = options.credentialRequirements ?? [];
+		this.generateItems = options.generateItems;
+		this.caseLabel = options.caseLabel;
+	}
+	getCredentialRequirements() {
+		return this.credentialRequirements;
+	}
+};
+
 //#endregion
 //#region src/nodes/WaitDurationFactory.ts
 var WaitDuration = class {
@@ -4450,6 +7357,7 @@ var Wait = class {
 	execution = { hint: "local" };
 	/** Pass-through empty batches should still advance to downstream nodes. */
 	continueWhenEmptyOutput = true;
+	icon = "lucide:hourglass";
 	constructor(name, milliseconds, id) {
 		this.name = name;
 		this.milliseconds = milliseconds;
@@ -4500,7 +7408,7 @@ WebhookTriggerNode = __decorate([(0, __codemation_core.node)({ packageName: "@co
 var WebhookTrigger = class WebhookTrigger {
 	kind = "trigger";
 	type = WebhookTriggerNode;
-	icon = "lucide:globe";
+	icon = "lucide:webhook";
 	constructor(name, args, handler = WebhookTrigger.defaultHandler, id) {
 		this.name = name;
 		this.args = args;
@@ -4596,10 +7504,10 @@ var WorkflowDefinedNodeResolver = class {
 //#endregion
 //#region src/workflowAuthoring/WorkflowDurationParser.types.ts
 var WorkflowDurationParser = class {
-	static parse(duration) {
-		if (typeof duration === "number") return Number.isFinite(duration) && duration > 0 ? Math.floor(duration) : 0;
-		const match = duration.trim().toLowerCase().match(/^(\d+)(ms|s|m|h)$/);
-		if (!match) throw new Error(`Unsupported wait duration "${duration}". Use a number of milliseconds or values like "500ms", "2s", "5m".`);
+	static parse(duration$2) {
+		if (typeof duration$2 === "number") return Number.isFinite(duration$2) && duration$2 > 0 ? Math.floor(duration$2) : 0;
+		const match = duration$2.trim().toLowerCase().match(/^(\d+)(ms|s|m|h)$/);
+		if (!match) throw new Error(`Unsupported wait duration "${duration$2}". Use a number of milliseconds or values like "500ms", "2s", "5m".`);
 		const value = Number(match[1]);
 		const unit = match[2];
 		if (unit === "ms") return value;
@@ -4625,8 +7533,8 @@ var WorkflowBranchBuilder = class WorkflowBranchBuilder {
 	}
 	wait(nameOrDuration, durationOrUndefined, id) {
 		const name = typeof nameOrDuration === "string" && durationOrUndefined !== void 0 ? nameOrDuration : "Wait";
-		const duration = durationOrUndefined ?? nameOrDuration;
-		return this.then(new Wait(name, WorkflowDurationParser.parse(duration), id));
+		const duration$2 = durationOrUndefined ?? nameOrDuration;
+		return this.then(new Wait(name, WorkflowDurationParser.parse(duration$2), id));
 	}
 	split(nameOrGetter, getElementsOrUndefined, id) {
 		const name = typeof nameOrGetter === "string" ? nameOrGetter : "Split";
@@ -4671,8 +7579,8 @@ var WorkflowChain = class WorkflowChain {
 	}
 	wait(nameOrDuration, durationOrUndefined, id) {
 		const name = typeof nameOrDuration === "string" && durationOrUndefined !== void 0 ? nameOrDuration : "Wait";
-		const duration = durationOrUndefined ?? nameOrDuration;
-		return this.then(new Wait(name, WorkflowDurationParser.parse(duration), id));
+		const duration$2 = durationOrUndefined ?? nameOrDuration;
+		return this.then(new Wait(name, WorkflowDurationParser.parse(duration$2), id));
 	}
 	split(nameOrGetter, getElementsOrUndefined, id) {
 		const name = typeof nameOrGetter === "string" ? nameOrGetter : "Split";
@@ -4772,9 +7680,9 @@ var AIAgentConnectionWorkflowExpander = class {
 		const connectionsByParentAndName = this.createConnectionsByParentAndName(workflow$1);
 		const extraNodes = [];
 		let connectionsChanged = false;
-		for (const node$16 of workflow$1.nodes) {
-			if (node$16.type !== AIAgentNode || !__codemation_core.AgentConfigInspector.isAgentNodeConfig(node$16.config)) continue;
-			for (const connectionNode of __codemation_core.AgentConnectionNodeCollector.collect(node$16.id, node$16.config)) {
+		for (const node$20 of workflow$1.nodes) {
+			if (node$20.type !== AIAgentNode || !__codemation_core.AgentConfigInspector.isAgentNodeConfig(node$20.config)) continue;
+			for (const connectionNode of __codemation_core.AgentConnectionNodeCollector.collect(node$20.id, node$20.config)) {
 				if (!existingChildIds.has(connectionNode.nodeId)) {
 					this.assertNoIdCollision(workflow$1, extraNodes, existingChildIds, connectionNode.nodeId);
 					extraNodes.push({
@@ -4853,6 +7761,129 @@ var ConnectionCredentialNodeConfigFactory = class {
 	}
 };
 
+//#endregion
+//#region src/nodes/collections/collectionInsertNode.types.ts
+const collectionInsertNode = (0, __codemation_core.defineNode)({
+	key: "collection-insert",
+	title: "Collection: Insert",
+	description: "Insert a new row into a collection.",
+	icon: "lucide:boxes",
+	configSchema: object({
+		collectionName: string(),
+		data: record(string(), unknown())
+	}),
+	async execute(_args, { config: config$1, execution }) {
+		const store = execution.collections?.[config$1.collectionName];
+		if (!store) throw new Error(`Collection "${config$1.collectionName}" is not registered. Add defineCollection to your codemation config.`);
+		return await store.insert(config$1.data);
+	}
+});
+
+//#endregion
+//#region src/nodes/collections/collectionGetNode.types.ts
+const collectionGetNode = (0, __codemation_core.defineNode)({
+	key: "collection-get",
+	title: "Collection: Get",
+	description: "Get a single row by id from a collection.",
+	icon: "lucide:layers",
+	configSchema: object({
+		collectionName: string(),
+		id: string()
+	}),
+	async execute(_args, { config: config$1, execution }) {
+		const store = execution.collections?.[config$1.collectionName];
+		if (!store) throw new Error(`Collection "${config$1.collectionName}" is not registered. Add defineCollection to your codemation config.`);
+		const row = await store.get(config$1.id);
+		if (row === null) return [];
+		return row;
+	}
+});
+
+//#endregion
+//#region src/nodes/collections/collectionFindOneNode.types.ts
+const collectionFindOneNode = (0, __codemation_core.defineNode)({
+	key: "collection-find-one",
+	title: "Collection: Find One",
+	description: "Find a single row matching a filter in a collection.",
+	icon: "lucide:filter",
+	configSchema: object({
+		collectionName: string(),
+		where: record(string(), unknown())
+	}),
+	async execute(_args, { config: config$1, execution }) {
+		const store = execution.collections?.[config$1.collectionName];
+		if (!store) throw new Error(`Collection "${config$1.collectionName}" is not registered. Add defineCollection to your codemation config.`);
+		const row = await store.findOne(config$1.where);
+		if (row === null) return [];
+		return row;
+	}
+});
+
+//#endregion
+//#region src/nodes/collections/collectionListNode.types.ts
+const collectionListNode = (0, __codemation_core.defineNode)({
+	key: "collection-list",
+	title: "Collection: List",
+	description: "List rows from a collection with optional pagination and filtering.",
+	icon: "lucide:split",
+	configSchema: object({
+		collectionName: string(),
+		limit: number().int().positive().optional(),
+		offset: number().int().nonnegative().optional(),
+		where: record(string(), unknown()).optional()
+	}),
+	async execute(_args, { config: config$1, execution }) {
+		const store = execution.collections?.[config$1.collectionName];
+		if (!store) throw new Error(`Collection "${config$1.collectionName}" is not registered. Add defineCollection to your codemation config.`);
+		const { rows } = await store.list({
+			limit: config$1.limit,
+			offset: config$1.offset,
+			where: config$1.where
+		});
+		return [...rows];
+	}
+});
+
+//#endregion
+//#region src/nodes/collections/collectionUpdateNode.types.ts
+const collectionUpdateNode = (0, __codemation_core.defineNode)({
+	key: "collection-update",
+	title: "Collection: Update",
+	description: "Update a row by id in a collection.",
+	icon: "lucide:square-pen",
+	configSchema: object({
+		collectionName: string(),
+		id: string(),
+		patch: record(string(), unknown())
+	}),
+	async execute(_args, { config: config$1, execution }) {
+		const store = execution.collections?.[config$1.collectionName];
+		if (!store) throw new Error(`Collection "${config$1.collectionName}" is not registered. Add defineCollection to your codemation config.`);
+		return await store.update(config$1.id, config$1.patch);
+	}
+});
+
+//#endregion
+//#region src/nodes/collections/collectionDeleteNode.types.ts
+const collectionDeleteNode = (0, __codemation_core.defineNode)({
+	key: "collection-delete",
+	title: "Collection: Delete",
+	description: "Delete a row by id from a collection.",
+	icon: "lucide:braces",
+	configSchema: object({
+		collectionName: string(),
+		id: string()
+	}),
+	async execute(_args, { config: config$1, execution }) {
+		const store = execution.collections?.[config$1.collectionName];
+		if (!store) throw new Error(`Collection "${config$1.collectionName}" is not registered. Add defineCollection to your codemation config.`);
+		return {
+			deleted: (await store.delete(config$1.id)).deleted,
+			id: config$1.id
+		};
+	}
+});
+
 //#endregion
 exports.AIAgent = AIAgent;
 exports.AIAgentConnectionWorkflowExpander = AIAgentConnectionWorkflowExpander;
@@ -4910,6 +7941,13 @@ Object.defineProperty(exports, 'AggregateNode', {
     return AggregateNode;
   }
 });
+exports.Assertion = Assertion;
+Object.defineProperty(exports, 'AssertionNode', {
+  enumerable: true,
+  get: function () {
+    return AssertionNode;
+  }
+});
 exports.Callback = Callback;
 Object.defineProperty(exports, 'CallbackNode', {
   enumerable: true,
@@ -4927,6 +7965,13 @@ Object.defineProperty(exports, 'ConnectionCredentialNode', {
 });
 exports.ConnectionCredentialNodeConfig = ConnectionCredentialNodeConfig;
 exports.ConnectionCredentialNodeConfigFactory = ConnectionCredentialNodeConfigFactory;
+exports.CronTrigger = CronTrigger;
+Object.defineProperty(exports, 'CronTriggerNode', {
+  enumerable: true,
+  get: function () {
+    return CronTriggerNode;
+  }
+});
 exports.Filter = Filter;
 Object.defineProperty(exports, 'FilterNode', {
   enumerable: true,
@@ -4934,6 +7979,7 @@ Object.defineProperty(exports, 'FilterNode', {
     return FilterNode;
   }
 });
+exports.HTTP_REQUEST_ACCEPTED_CREDENTIAL_TYPES = HTTP_REQUEST_ACCEPTED_CREDENTIAL_TYPES;
 exports.HttpRequest = HttpRequest;
 Object.defineProperty(exports, 'HttpRequestNode', {
   enumerable: true,
@@ -4948,6 +7994,13 @@ Object.defineProperty(exports, 'IfNode', {
     return IfNode;
   }
 });
+exports.IsTestRun = IsTestRun;
+Object.defineProperty(exports, 'IsTestRunNode', {
+  enumerable: true,
+  get: function () {
+    return IsTestRunNode;
+  }
+});
 exports.ManualTrigger = ManualTrigger;
 Object.defineProperty(exports, 'ManualTriggerNode', {
   enumerable: true,
@@ -4983,13 +8036,13 @@ Object.defineProperty(exports, 'OpenAIChatModelFactory', {
     return OpenAIChatModelFactory;
   }
 });
-Object.defineProperty(exports, 'OpenAIStructuredOutputMethodFactory', {
+exports.OpenAiChatModelPresets = OpenAiChatModelPresets;
+Object.defineProperty(exports, 'OpenAiStrictJsonSchemaFactory', {
   enumerable: true,
   get: function () {
-    return OpenAIStructuredOutputMethodFactory;
+    return OpenAiStrictJsonSchemaFactory;
   }
 });
-exports.OpenAiChatModelPresets = OpenAiChatModelPresets;
 exports.Split = Split;
 Object.defineProperty(exports, 'SplitNode', {
   enumerable: true,
@@ -5011,6 +8064,13 @@ Object.defineProperty(exports, 'SwitchNode', {
     return SwitchNode;
   }
 });
+exports.TestTrigger = TestTrigger;
+Object.defineProperty(exports, 'TestTriggerNode', {
+  enumerable: true,
+  get: function () {
+    return TestTriggerNode;
+  }
+});
 exports.Wait = Wait;
 exports.WaitDuration = WaitDuration;
 Object.defineProperty(exports, 'WaitNode', {
@@ -5031,7 +8091,18 @@ Object.defineProperty(exports, 'WebhookTriggerNode', {
 exports.WorkflowAuthoringBuilder = WorkflowAuthoringBuilder;
 exports.WorkflowBranchBuilder = WorkflowBranchBuilder;
 exports.WorkflowChain = WorkflowChain;
+exports.apiKeyCredentialType = apiKeyCredentialType;
+exports.basicAuthCredentialType = basicAuthCredentialType;
+exports.bearerTokenCredentialType = bearerTokenCredentialType;
+exports.collectionDeleteNode = collectionDeleteNode;
+exports.collectionFindOneNode = collectionFindOneNode;
+exports.collectionGetNode = collectionGetNode;
+exports.collectionInsertNode = collectionInsertNode;
+exports.collectionListNode = collectionListNode;
+exports.collectionUpdateNode = collectionUpdateNode;
 exports.createWorkflowBuilder = createWorkflowBuilder;
+exports.defineRestNode = defineRestNode;
+exports.oauth2ClientCredentialsType = oauth2ClientCredentialsType;
 exports.openAiChatModelPresets = openAiChatModelPresets;
 exports.registerCoreNodes = registerCoreNodes;
 exports.workflow = workflow;