@inkeep/agents-api 0.0.1 → 0.43.0

package/dist/domains/mcp/routes/mcp.js

@@ -0,0 +1,45 @@
+import { env } from "../../../env.js";
+import { Hono } from "hono";
+import { StreamableHTTPTransport } from "@hono/mcp";
+import { HeaderForwardingHook, InkeepAgentsCore, SDKHooks, createConsoleLogger, createMCPServer } from "@inkeep/agents-mcp";
+
+//#region src/domains/mcp/routes/mcp.ts
+const app = new Hono();
+/**
+* Headers to forward from incoming requests to downstream API calls.
+* x-forwarded-cookie is mapped to cookie for browser compatibility
+* (browsers don't allow setting Cookie header directly).
+*/
+const FORWARDED_HEADERS = [
+	"x-forwarded-cookie",
+	"authorization",
+	"cookie"
+];
+app.all("/", async (c) => {
+	const transport = new StreamableHTTPTransport();
+	const noOpLogger = createConsoleLogger("error");
+	const headersToForward = {};
+	for (const headerName of FORWARDED_HEADERS) {
+		const value = c.req.header(headerName);
+		if (value) headersToForward[headerName] = value;
+	}
+	if (headersToForward["x-forwarded-cookie"] && !headersToForward.cookie) headersToForward.cookie = headersToForward["x-forwarded-cookie"];
+	const createSDKWithHeaders = () => {
+		const hooks = new SDKHooks();
+		hooks.registerBeforeRequestHook(new HeaderForwardingHook(headersToForward));
+		return new InkeepAgentsCore({
+			serverURL: env.INKEEP_AGENTS_API_URL,
+			hooks
+		});
+	};
+	await createMCPServer({
+		logger: noOpLogger,
+		serverURL: env.INKEEP_AGENTS_API_URL,
+		getSDK: createSDKWithHeaders
+	}).server.connect(transport);
+	return transport.handleRequest(c);
+});
+var mcp_default = app;
+
+//#endregion
+export { mcp_default as default };

package/dist/domains/run/a2a/handlers.js

@@ -61,11 +61,7 @@ async function handleMessageSend(c, agent, request) {
 		};
 		const task = {
 			id: generateId(),
-			input: { parts: params.message.parts.map((part) => ({
-				kind: part.kind,
-				text: part.kind === "text" ? part.text : void 0,
-				data: part.kind === "data" ? part.data : void 0
-			})) },
+			input: { parts: params.message.parts },
 			context: {
 				conversationId: params.message.contextId,
 				metadata: {
@@ -320,11 +316,7 @@ async function handleMessageStream(c, agent, request) {
 		else if (cookie) forwardedHeaders["x-forwarded-cookie"] = cookie;
 		const task = {
 			id: generateId(),
-			input: { parts: params.message.parts.map((part) => ({
-				kind: part.kind,
-				text: part.kind === "text" ? part.text : void 0,
-				data: part.kind === "data" ? part.data : void 0
-			})) },
+			input: { parts: params.message.parts },
 			context: {
 				conversationId: params.message.contextId,
 				metadata: {

package/dist/domains/run/a2a/types.d.ts

@@ -1,4 +1,4 @@
-import { AgentCard, Artifact, Message, Task, TaskState } from "@inkeep/agents-core";
+import { AgentCard, Artifact, Message, Part, Task, TaskState } from "@inkeep/agents-core";
 
 //#region src/domains/run/a2a/types.d.ts
 interface RegisteredAgent {
@@ -12,11 +12,7 @@ interface RegisteredAgent {
 interface A2ATask {
   id: string;
   input: {
-    parts: Array<{
-      kind: string;
-      text?: string;
-      data?: any;
-    }>;
+    parts: Part[];
   };
   context?: {
     conversationId?: string;

package/dist/domains/run/agents/Agent.d.ts

@@ -99,6 +99,7 @@ declare class Agent {
   private mcpConnectionLocks;
   private currentCompressor;
   private executionContext;
+  private functionToolRelationshipIdByName;
   constructor(config: AgentConfig, executionContext: FullExecutionContext, credentialStoreRegistry?: CredentialStoreRegistry);
   /**
    * Get the maximum number of generation steps for this agent

package/dist/domains/run/agents/Agent.js

@@ -15,6 +15,7 @@ import { IncrementalStreamParser } from "../services/IncrementalStreamParser.js"
 import { MidGenerationCompressor } from "../services/MidGenerationCompressor.js";
 import { pendingToolApprovalManager } from "../services/PendingToolApprovalManager.js";
 import { ResponseFormatter } from "../services/ResponseFormatter.js";
+import { toolApprovalUiBus } from "../services/ToolApprovalUiBus.js";
 import { generateToolId } from "../utils/agent-operations.js";
 import { jsonSchemaToZod } from "../utils/data-component-schema.js";
 import { ArtifactCreateSchema, ArtifactReferenceSchema } from "../utils/artifact-component-schema.js";
@@ -25,7 +26,7 @@ import { SystemPromptBuilder } from "./SystemPromptBuilder.js";
 import { Phase1Config, V1_BREAKDOWN_SCHEMA } from "./versions/v1/Phase1Config.js";
 import { Phase2Config } from "./versions/v1/Phase2Config.js";
 import { z } from "@hono/zod-openapi";
-import { CredentialStuffer, JsonTransformer, MCPServerType, MCPTransportType, McpClient, ModelFactory, TemplateEngine, createMessage, generateId, getFunctionToolsForSubAgent, getLedgerArtifacts, listTaskIdsByContextId, parseEmbeddedJson, withRef } from "@inkeep/agents-core";
+import { CredentialStuffer, JsonTransformer, MCPServerType, MCPTransportType, McpClient, ModelFactory, TemplateEngine, buildComposioMCPUrl, createMessage, generateId, getFunctionToolsForSubAgent, getLedgerArtifacts, listTaskIdsByContextId, parseEmbeddedJson, withRef } from "@inkeep/agents-core";
 import { Output, generateText, streamText, tool } from "ai";
 import { SpanStatusCode, trace } from "@opentelemetry/api";
 
@@ -66,6 +67,7 @@ var Agent = class {
 	mcpConnectionLocks = /* @__PURE__ */ new Map();
 	currentCompressor = null;
 	executionContext;
+	functionToolRelationshipIdByName = /* @__PURE__ */ new Map();
 	constructor(config, executionContext, credentialStoreRegistry) {
 		this.artifactComponents = config.artifactComponents || [];
 		this.executionContext = executionContext;
@@ -135,6 +137,7 @@ var Agent = class {
 			if (tool$1.config.mcp.activeTools?.includes(toolName)) return true;
 			return tool$1.name === toolName;
 		}))?.relationshipId;
+		if (toolType === "tool") return this.functionToolRelationshipIdByName.get(toolName);
 		if (toolType === "delegation") return this.config.delegateRelations.find((relation) => this.#createRelationToolName("delegate", relation.config.id) === toolName)?.config.relationId;
 	}
 	/**
@@ -221,6 +224,12 @@ var Agent = class {
 			execute: async (args, context$1) => {
 				const startTime = Date.now();
 				const toolCallId = context$1?.toolCallId || generateToolId();
+				const streamHelper = this.getStreamingHelper();
+				const chunkString = (s, size = 16) => {
+					const out = [];
+					for (let i = 0; i < s.length; i += size) out.push(s.slice(i, i + size));
+					return out;
+				};
 				const activeSpan = trace.getActiveSpan();
 				if (activeSpan) {
 					const attributes = {
@@ -235,14 +244,32 @@ var Agent = class {
 					if (options?.mcpServerName) attributes["ai.toolCall.mcpServerName"] = options.mcpServerName;
 					activeSpan.setAttributes(attributes);
 				}
-				const isInternalTool = toolName.includes("save_tool_result") || toolName.includes("thinking_complete") || toolName.startsWith("transfer_to_");
+				const isInternalToolForUi = toolName.includes("save_tool_result") || toolName.includes("thinking_complete") || toolName.startsWith("transfer_to_") || toolName.startsWith("delegate_to_");
 				const needsApproval = options?.needsApproval || false;
-				if (streamRequestId && !isInternalTool) {
+				if (streamRequestId && streamHelper && !isInternalToolForUi) {
+					const inputText = JSON.stringify(args ?? {});
+					await streamHelper.writeToolInputStart({
+						toolCallId,
+						toolName
+					});
+					for (const part of chunkString(inputText, 16)) await streamHelper.writeToolInputDelta({
+						toolCallId,
+						inputTextDelta: part
+					});
+					await streamHelper.writeToolInputAvailable({
+						toolCallId,
+						toolName,
+						input: args ?? {},
+						providerMetadata: context$1?.providerMetadata
+					});
+				}
+				if (streamRequestId && !isInternalToolForUi) {
 					const toolCallData = {
 						toolName,
 						input: args,
 						toolCallId,
-						relationshipId
+						relationshipId,
+						inDelegatedAgent: this.isDelegatedAgent
 					};
 					if (needsApproval) {
 						toolCallData.needsApproval = true;
@@ -254,7 +281,7 @@ var Agent = class {
 					const result = await originalExecute(args, context$1);
 					const duration = Date.now() - startTime;
 					const toolResultConversationId = this.getToolResultConversationId();
-					if (streamRequestId && !isInternalTool && toolResultConversationId) try {
+					if (streamRequestId && !isInternalToolForUi && toolResultConversationId) try {
 						const messagePayload = {
 							id: generateId(),
 							tenantId: this.config.tenantId,
@@ -282,26 +309,38 @@ var Agent = class {
 							conversationId: toolResultConversationId
 						}, "Failed to store tool result in conversation history");
 					}
-					if (streamRequestId && !isInternalTool) agentSessionManager.recordEvent(streamRequestId, "tool_result", this.config.id, {
+					if (streamRequestId && !isInternalToolForUi) agentSessionManager.recordEvent(streamRequestId, "tool_result", this.config.id, {
 						toolName,
 						output: result,
 						toolCallId,
 						duration,
 						relationshipId,
-						needsApproval
+						needsApproval,
+						inDelegatedAgent: this.isDelegatedAgent
+					});
+					const isDeniedResult = !!result && typeof result === "object" && "__inkeepToolDenied" in result && result.__inkeepToolDenied === true;
+					if (streamRequestId && streamHelper && !isInternalToolForUi) if (isDeniedResult) await streamHelper.writeToolOutputDenied({ toolCallId });
+					else await streamHelper.writeToolOutputAvailable({
+						toolCallId,
+						output: result
 					});
 					return result;
 				} catch (error) {
 					const duration = Date.now() - startTime;
 					const errorMessage = error instanceof Error ? error.message : "Unknown error";
-					if (streamRequestId && !isInternalTool) agentSessionManager.recordEvent(streamRequestId, "tool_result", this.config.id, {
+					if (streamRequestId && !isInternalToolForUi) agentSessionManager.recordEvent(streamRequestId, "tool_result", this.config.id, {
 						toolName,
 						output: null,
 						toolCallId,
 						duration,
 						error: errorMessage,
 						relationshipId,
-						needsApproval
+						needsApproval,
+						inDelegatedAgent: this.isDelegatedAgent
+					});
+					if (streamRequestId && streamHelper && !isInternalToolForUi) await streamHelper.writeToolOutputError({
+						toolCallId,
+						errorText: errorMessage
 					});
 					throw error;
 				}
@@ -372,7 +411,7 @@ var Agent = class {
 			const sessionWrappedTool = tool({
 				description: originalTool.description,
 				inputSchema: originalTool.inputSchema,
-				execute: async (args, { toolCallId }) => {
+				execute: async (args, { toolCallId, providerMetadata }) => {
 					let processedArgs;
 					try {
 						processedArgs = parseEmbeddedJson(args);
@@ -410,22 +449,52 @@ var Agent = class {
 							requestSpan.setStatus({ code: SpanStatusCode.OK });
 							requestSpan.end();
 						});
-						const approvalResult = await pendingToolApprovalManager.waitForApproval(toolCallId, toolName, args, this.conversationId || "unknown", this.config.id);
-						if (!approvalResult.approved) return tracer.startActiveSpan("tool.approval_denied", { attributes: {
-							"tool.name": toolName,
-							"tool.callId": toolCallId,
-							"subAgent.id": this.config.id,
-							"subAgent.name": this.config.name
-						} }, (denialSpan) => {
-							logger.info({
-								toolName,
-								toolCallId,
-								reason: approvalResult.reason
-							}, "Tool execution denied by user");
-							denialSpan.setStatus({ code: SpanStatusCode.OK });
-							denialSpan.end();
-							return `User denied approval to run this tool: ${approvalResult.reason}`;
+						const streamHelper = this.getStreamingHelper();
+						if (streamHelper) await streamHelper.writeToolApprovalRequest({
+							approvalId: `aitxt-${toolCallId}`,
+							toolCallId
 						});
+						else if (this.isDelegatedAgent) {
+							const streamRequestId$1 = this.getStreamRequestId();
+							if (streamRequestId$1) await toolApprovalUiBus.publish(streamRequestId$1, {
+								type: "approval-needed",
+								toolCallId,
+								toolName,
+								input: finalArgs,
+								providerMetadata,
+								approvalId: `aitxt-${toolCallId}`
+							});
+						}
+						const approvalResult = await pendingToolApprovalManager.waitForApproval(toolCallId, toolName, args, this.conversationId || "unknown", this.config.id);
+						if (!approvalResult.approved) {
+							if (!streamHelper && this.isDelegatedAgent) {
+								const streamRequestId$1 = this.getStreamRequestId();
+								if (streamRequestId$1) await toolApprovalUiBus.publish(streamRequestId$1, {
+									type: "approval-resolved",
+									toolCallId,
+									approved: false
+								});
+							}
+							return tracer.startActiveSpan("tool.approval_denied", { attributes: {
+								"tool.name": toolName,
+								"tool.callId": toolCallId,
+								"subAgent.id": this.config.id,
+								"subAgent.name": this.config.name
+							} }, (denialSpan) => {
+								logger.info({
+									toolName,
+									toolCallId,
+									reason: approvalResult.reason
+								}, "Tool execution denied by user");
+								denialSpan.setStatus({ code: SpanStatusCode.OK });
+								denialSpan.end();
+								return {
+									__inkeepToolDenied: true,
+									toolCallId,
+									reason: approvalResult.reason
+								};
+							});
+						}
 						tracer.startActiveSpan("tool.approval_approved", { attributes: {
 							"tool.name": toolName,
 							"tool.callId": toolCallId,
@@ -439,6 +508,14 @@ var Agent = class {
 							approvedSpan.setStatus({ code: SpanStatusCode.OK });
 							approvedSpan.end();
 						});
+						if (!streamHelper && this.isDelegatedAgent) {
+							const streamRequestId$1 = this.getStreamRequestId();
+							if (streamRequestId$1) await toolApprovalUiBus.publish(streamRequestId$1, {
+								type: "approval-resolved",
+								toolCallId,
+								approved: true
+							});
+						}
 					}
 					logger.debug({
 						toolName,
@@ -475,7 +552,8 @@ var Agent = class {
 										toolCallId,
 										errorMessage,
 										relationshipId
-									}
+									},
+									relationshipId
 								});
 							}
 							const activeSpan = trace.getActiveSpan();
@@ -498,10 +576,7 @@ var Agent = class {
 							result: enhancedResult,
 							timestamp: Date.now()
 						});
-						return {
-							result: enhancedResult,
-							toolCallId
-						};
+						return enhancedResult;
 					} catch (error) {
 						logger.error({
 							toolName,
@@ -606,12 +681,7 @@ var Agent = class {
 				headers: agentToolRelationHeaders
 			};
 		}
-		if (serverConfig.url?.toString().includes("composio.dev")) {
-			const urlObj = new URL(serverConfig.url.toString());
-			if (isUserScoped && userId) urlObj.searchParams.set("user_id", userId);
-			else urlObj.searchParams.set("user_id", `${this.config.tenantId}||${this.config.projectId}`);
-			serverConfig.url = urlObj.toString();
-		}
+		if (serverConfig.url) serverConfig.url = buildComposioMCPUrl(serverConfig.url.toString(), this.config.tenantId, this.config.projectId, isUserScoped ? "user" : "project", userId);
 		if (this.config.forwardedHeaders && Object.keys(this.config.forwardedHeaders).length > 0) serverConfig.headers = {
 			...serverConfig.headers,
 			...this.config.forwardedHeaders
@@ -670,6 +740,7 @@ var Agent = class {
 				"project.id": this.config.projectId || "unknown"
 			} }, (span) => {
 				setSpanWithError$1(span, /* @__PURE__ */ new Error(`0 effective tools available for ${tool$1.name}`));
+				const relationshipId = this.#getRelationshipIdForTool(tool$1.name, "mcp");
 				agentSessionManager.recordEvent(streamRequestId, "error", this.config.id, {
 					message: `MCP server has 0 effective tools. Double check the selected tools in your graph and the active tools in the MCP server configuration.`,
 					code: "no_tools_available",
@@ -678,7 +749,8 @@ var Agent = class {
 						toolName: tool$1.name,
 						serverUrl: tool$1.config.type === "mcp" ? tool$1.config.mcp.server.url : "unknown",
 						operation: "mcp_tool_discovery"
-					}
+					},
+					relationshipId
 				});
 				span.end();
 			});
@@ -727,8 +799,11 @@ var Agent = class {
 				});
 			})).data ?? [];
 			if (functionToolsData.length === 0) return functionTools;
+			this.functionToolRelationshipIdByName = new Map(functionToolsData.flatMap((t) => {
+				return t.relationshipId ? [[t.name, t.relationshipId]] : [];
+			}));
 			const { SandboxExecutorFactory } = await import("../tools/SandboxExecutorFactory.js");
-			const sandboxExecutor = SandboxExecutorFactory.getInstance();
+			const sandboxExecutor = sessionId ? SandboxExecutorFactory.getForSession(sessionId) : new SandboxExecutorFactory();
 			for (const functionToolDef of functionToolsData) {
 				const functionId = functionToolDef.functionId;
 				if (!functionId) {
@@ -744,10 +819,12 @@ var Agent = class {
 					continue;
 				}
 				const zodSchema = jsonSchemaToZod(functionData.inputSchema);
+				const toolPolicies = functionToolDef.toolPolicies;
+				const needsApproval = !!toolPolicies?.["*"]?.needsApproval || !!toolPolicies?.[functionToolDef.name]?.needsApproval;
 				const aiTool = tool({
 					description: functionToolDef.description || functionToolDef.name,
 					inputSchema: zodSchema,
-					execute: async (args, { toolCallId }) => {
+					execute: async (args, { toolCallId, providerMetadata }) => {
 						let processedArgs;
 						try {
 							processedArgs = parseEmbeddedJson(args);
@@ -764,6 +841,95 @@ var Agent = class {
 							processedArgs = args;
 						}
 						const finalArgs = processedArgs;
+						if (needsApproval) {
+							logger.info({
+								toolName: functionToolDef.name,
+								toolCallId,
+								args: finalArgs
+							}, "Function tool requires approval - waiting for user response");
+							const currentSpan = trace.getActiveSpan();
+							if (currentSpan) currentSpan.addEvent("tool.approval.requested", {
+								"tool.name": functionToolDef.name,
+								"tool.callId": toolCallId,
+								"subAgent.id": this.config.id
+							});
+							tracer.startActiveSpan("tool.approval_requested", { attributes: {
+								"tool.name": functionToolDef.name,
+								"tool.callId": toolCallId,
+								"subAgent.id": this.config.id,
+								"subAgent.name": this.config.name
+							} }, (requestSpan) => {
+								requestSpan.setStatus({ code: SpanStatusCode.OK });
+								requestSpan.end();
+							});
+							const streamHelper = this.getStreamingHelper();
+							if (streamHelper) await streamHelper.writeToolApprovalRequest({
+								approvalId: `aitxt-${toolCallId}`,
+								toolCallId
+							});
+							else if (this.isDelegatedAgent) {
+								const streamRequestId$1 = this.getStreamRequestId();
+								if (streamRequestId$1) await toolApprovalUiBus.publish(streamRequestId$1, {
+									type: "approval-needed",
+									toolCallId,
+									toolName: functionToolDef.name,
+									input: finalArgs,
+									providerMetadata,
+									approvalId: `aitxt-${toolCallId}`
+								});
+							}
+							const approvalResult = await pendingToolApprovalManager.waitForApproval(toolCallId, functionToolDef.name, args, this.conversationId || "unknown", this.config.id);
+							if (!approvalResult.approved) {
+								if (!streamHelper && this.isDelegatedAgent) {
+									const streamRequestId$1 = this.getStreamRequestId();
+									if (streamRequestId$1) await toolApprovalUiBus.publish(streamRequestId$1, {
+										type: "approval-resolved",
+										toolCallId,
+										approved: false
+									});
+								}
+								return tracer.startActiveSpan("tool.approval_denied", { attributes: {
+									"tool.name": functionToolDef.name,
+									"tool.callId": toolCallId,
+									"subAgent.id": this.config.id,
+									"subAgent.name": this.config.name
+								} }, (denialSpan) => {
+									logger.info({
+										toolName: functionToolDef.name,
+										toolCallId,
+										reason: approvalResult.reason
+									}, "Function tool execution denied by user");
+									denialSpan.setStatus({ code: SpanStatusCode.OK });
+									denialSpan.end();
+									return {
+										__inkeepToolDenied: true,
+										toolCallId,
+										reason: approvalResult.reason
+									};
+								});
+							}
+							tracer.startActiveSpan("tool.approval_approved", { attributes: {
+								"tool.name": functionToolDef.name,
+								"tool.callId": toolCallId,
+								"subAgent.id": this.config.id,
+								"subAgent.name": this.config.name
+							} }, (approvedSpan) => {
+								logger.info({
+									toolName: functionToolDef.name,
+									toolCallId
+								}, "Function tool approved, continuing with execution");
+								approvedSpan.setStatus({ code: SpanStatusCode.OK });
+								approvedSpan.end();
+							});
+							if (!streamHelper && this.isDelegatedAgent) {
+								const streamRequestId$1 = this.getStreamRequestId();
+								if (streamRequestId$1) await toolApprovalUiBus.publish(streamRequestId$1, {
+									type: "approval-resolved",
+									toolCallId,
+									approved: true
+								});
+							}
+						}
 						logger.debug({
 							toolName: functionToolDef.name,
 							toolCallId,
@@ -790,10 +956,7 @@ var Agent = class {
 								result,
 								timestamp: Date.now()
 							});
-							return {
-								result,
-								toolCallId
-							};
+							return result;
 						} catch (error) {
 							logger.error({
 								toolName: functionToolDef.name,
@@ -804,7 +967,7 @@ var Agent = class {
 						}
 					}
 				});
-				functionTools[functionToolDef.name] = this.wrapToolWithStreaming(functionToolDef.name, aiTool, streamRequestId || "", "tool");
+				functionTools[functionToolDef.name] = this.wrapToolWithStreaming(functionToolDef.name, aiTool, streamRequestId || "", "tool", { needsApproval });
 			}
 		} catch (error) {
 			logger.error({ error }, "Failed to load function tools from database");

package/dist/domains/run/agents/generateTaskHandler.js

@@ -15,7 +15,13 @@ const createTaskHandler = (config, credentialStoreRegistry) => {
 	return async (task) => {
 		let agent;
 		try {
-			const userMessage = task.input.parts.filter((part) => part.text).map((part) => part.text).join(" ");
+			const textParts = task.input.parts.filter((part) => part.kind === "text").map((part) => part.text).join(" ");
+			const dataParts = task.input.parts.filter((part) => part.kind === "data" && part.data != null);
+			let userMessage = textParts;
+			if (dataParts.length > 0) userMessage = `${textParts}${dataParts.map((part) => {
+				const metadata = part.metadata;
+				return `\n\n<structured_data${metadata?.source ? ` (source: ${metadata.source})` : ""}>\n${JSON.stringify(part.data, null, 2)}\n</structured_data>`;
+			}).join("")}`;
 			if (!userMessage.trim()) return {
 				status: {
 					state: TaskState.Failed,
@@ -224,7 +230,13 @@ const createTaskHandler = (config, credentialStoreRegistry) => {
 				if (streamRequestId && tenantId && projectId) toolSessionManager.ensureAgentSession(streamRequestId, tenantId, projectId, contextId, task.id);
 			}
 			logger.info({ contextId }, "Context ID");
-			logger.info({ userMessage }, "User Message");
+			logger.info({
+				userMessage: userMessage.substring(0, 500),
+				inputPartsCount: task.input.parts.length,
+				textPartsCount: task.input.parts.filter((p) => p.kind === "text").length,
+				dataPartsCount: task.input.parts.filter((p) => p.kind === "data").length,
+				hasDataParts: task.input.parts.some((p) => p.kind === "data")
+			}, "User Message with parts breakdown");
 			const response = await agent.generate(userMessage, {
 				contextId,
 				metadata: {

package/dist/domains/run/context/ContextFetcher.js

@@ -1,4 +1,4 @@
-import { validateAgainstJsonSchema } from "./validation.js";
+import { validationHelper } from "./validation.js";
 import { CredentialStuffer, JsonTransformer, TemplateEngine, getLogger } from "@inkeep/agents-core";
 
 //#region src/domains/run/context/ContextFetcher.ts
@@ -228,16 +228,17 @@ var ContextFetcher = class {
 	* Validate response against JSON Schema
 	*/
 	validateResponseWithJsonSchema(data, jsonSchema, definitionId) {
-		try {
-			if (!validateAgainstJsonSchema(jsonSchema, data)) throw new Error("Data does not match JSON Schema");
-		} catch (error) {
-			const errorMessage = error instanceof Error ? error.message : "Unknown validation error";
+		const validate = validationHelper(jsonSchema);
+		if (!validate(data)) {
+			const errors = validate.errors || [];
+			const formattedErrors = errors.map((e) => `${e.instancePath || "/"}: ${e.message}`).join("; ");
 			logger.error({
 				definitionId,
 				jsonSchema,
-				error: errorMessage
+				errors,
+				formattedErrors
 			}, "JSON Schema response validation failed");
-			throw new Error(`Response validation failed: ${errorMessage}`);
+			throw new Error(`Response validation failed: ${formattedErrors}`);
 		}
 	}
 	/**

package/dist/domains/run/context/ContextResolver.js

@@ -1,8 +1,8 @@
 import { ContextCache } from "./contextCache.js";
 import { ContextFetcher, MissingRequiredVariableError } from "./ContextFetcher.js";
 import { getLogger, getTracer, setSpanWithError } from "@inkeep/agents-core";
-import { SpanStatusCode } from "@opentelemetry/api";
 import crypto from "node:crypto";
+import { SpanStatusCode } from "@opentelemetry/api";
 
 //#region src/domains/run/context/ContextResolver.ts
 const logger = getLogger("context-resolver");

package/dist/domains/run/handlers/executionHandler.d.ts

@@ -1,11 +1,13 @@
 import { StreamHelper } from "../utils/stream-helpers.js";
-import { FullExecutionContext } from "@inkeep/agents-core";
+import { FullExecutionContext, Part } from "@inkeep/agents-core";
 
 //#region src/domains/run/handlers/executionHandler.d.ts
 interface ExecutionHandlerParams {
   executionContext: FullExecutionContext;
   conversationId: string;
   userMessage: string;
+  /** Optional message parts for rich content (text + data). Used on first iteration only. */
+  messageParts?: Part[];
   initialAgentId: string;
   requestId: string;
   sseHelper: StreamHelper;