@codemation/core-nodes 0.4.2 → 1.0.0

package/dist/index.cjs

@@ -23,18 +23,12 @@ 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);
 
 //#region \0@oxc-project+runtime@0.95.0/helpers/decorate.js
 function __decorate(decorators, target, key, desc) {
@@ -49,166 +43,21 @@ function __decorate(decorators, target, key, desc) {
 let OpenAIChatModelFactory = class OpenAIChatModelFactory$1 {
 	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
-		});
-	}
-};
-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;
-	}
-	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
-		};
 		return {
-			method: this.supportsJsonSchema(model) ? "jsonSchema" : "functionCalling",
-			strict: true
-		};
-	}
-	readModelName(chatModelConfig) {
-		const candidate = chatModelConfig;
-		return typeof candidate.model === "string" ? candidate.model : void 0;
-	}
-	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");
-	}
-	supportsSnapshotAtOrAfter(model, prefix, minimumSnapshotDate) {
-		if (!model.startsWith(prefix)) return false;
-		const snapshotDate = model.slice(prefix.length);
-		return _OpenAIStructuredOutputMethodFactory.isoDatePattern.test(snapshotDate) && snapshotDate >= minimumSnapshotDate;
-	}
-};
-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
-		};
-	}
-	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
-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);
-	}
-};
-
-//#endregion
-//#region src/nodes/AgentOutputFactory.ts
-var AgentOutputFactory = class {
-	static fromUnknown(value) {
-		return { main: [{ json: value }] };
-	}
-	static replaceJson(item, value) {
-		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
@@ -2130,53 +1979,35 @@ 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) {
@@ -2223,6 +2054,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 = this.executionHelpers.createJsonSchemaRecord(schema, {
+			schemaName: options.schemaName,
+			requireObjectRoot: false
+		});
+		this.strictifyRecursive(record);
+		if (options.title !== void 0) record.title = options.title;
+		return record;
+	}
+	strictifyRecursive(node$16) {
+		if (!node$16 || typeof node$16 !== "object" || Array.isArray(node$16)) return;
+		const o = node$16;
+		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;
@@ -2601,31 +2640,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 +2683,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 +2736,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 +2745,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
@@ -2862,8 +2900,8 @@ let AgentToolExecutionCoordinator = class AgentToolExecutionCoordinator$1 {
 			inputsByPort: toolCallInputsByPort
 		});
 		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 ?? {});
+			const serialized = typeof result === "string" ? result : JSON.stringify(result);
 			const finishedAt = /* @__PURE__ */ new Date();
 			await ctx.nodeState?.markCompleted({
 				nodeId: plannedToolCall.nodeId,
@@ -2907,7 +2945,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;
@@ -3070,14 +3108,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));
@@ -3197,14 +3227,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 +3259,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 +3276,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 +3289,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 +3302,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 +3316,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 +3352,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 +3367,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 +3409,93 @@ 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) => {
+					const validated = entry.runtime.inputSchema.parse(input);
+					return await entry.runtime.execute({
+						config: entry.config,
+						input: validated,
+						ctx: toolCredentialContext,
+						item,
+						itemIndex,
+						items
+					});
+				}
 			};
 		});
 	}
-	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?.markRunning({
-			nodeId,
+			nodeId: languageModelConnectionNodeId,
 			activationId: ctx.activationId,
-			inputsByPort
+			inputsByPort: itemInputsByPort
 		});
 		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();
 			await ctx.nodeState?.markCompleted({
-				nodeId,
+				nodeId: languageModelConnectionNodeId,
 				activationId: ctx.activationId,
-				inputsByPort,
-				outputs: AgentOutputFactory.fromUnknown({ content: AgentMessageFactory.extractContent(response) })
+				inputsByPort: itemInputsByPort,
+				outputs: AgentOutputFactory.fromUnknown({ content: turnResult.text })
 			});
-			const content = AgentMessageFactory.extractContent(response);
 			await span.attachArtifact({
 				kind: "ai.messages",
 				contentType: "application/json",
@@ -3430,26 +3504,26 @@ 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: turnResult.text,
 				queuedAt: startedAt.toISOString(),
 				startedAt: startedAt.toISOString(),
 				finishedAt: finishedAt.toISOString()
 			});
-			return response;
+			return turnResult;
 		} catch (error) {
 			await span.end({
 				status: "error",
@@ -3460,36 +3534,53 @@ 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?.markRunning({
-			nodeId,
+			nodeId: languageModelConnectionNodeId,
 			activationId: ctx.activationId,
-			inputsByPort
+			inputsByPort: itemInputsByPort
 		});
 		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 +3590,26 @@ 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()
 			});
-			return response;
+			return result.experimental_output;
 		} catch (error) {
 			await span.end({
 				status: "error",
@@ -3529,13 +3620,59 @@ 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
+		};
+	}
+	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",
@@ -3548,9 +3685,15 @@ let AIAgentNode = class AIAgentNode$1 {
 			}
 		});
 	}
-	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,93 +3708,28 @@ 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,
@@ -3711,7 +3789,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 +3804,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 +3813,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 +3831,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";
 	}
@@ -4983,13 +5053,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,