@inkeep/agents-api 0.0.1 → 0.43.0

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

@@ -33,7 +33,7 @@ var ExecutionHandler = class {
 	* @returns
 	*/
 	async execute(params) {
-		const { executionContext, conversationId, userMessage, initialAgentId, requestId, sseHelper, emitOperations, forwardedHeaders } = params;
+		const { executionContext, conversationId, userMessage, messageParts, initialAgentId, requestId, sseHelper, emitOperations, forwardedHeaders } = params;
 		const { tenantId, projectId, project, agentId, apiKey, baseUrl, resolvedRef } = executionContext;
 		registerStreamHelper(requestId, sseHelper);
 		agentSessionManager.createSession(requestId, executionContext, conversationId);
@@ -178,13 +178,14 @@ var ExecutionHandler = class {
 					forwardedHeaders
 				};
 				if (fromSubAgentId) messageMetadata.fromSubAgentId = fromSubAgentId;
+				const partsToSend = iterations === 1 && messageParts && messageParts.length > 0 ? messageParts : [{
+					kind: "text",
+					text: currentMessage
+				}];
 				messageResponse = await a2aClient.sendMessage({
 					message: {
 						role: "user",
-						parts: [{
-							kind: "text",
-							text: currentMessage
-						}],
+						parts: partsToSend,
 						messageId: `${requestId}-iter-${iterations}`,
 						kind: "message",
 						contextId: conversationId,
@@ -206,30 +207,45 @@ var ExecutionHandler = class {
 						fullResponse: messageResponse
 					}, `No response from agent ${currentAgentId} on iteration ${iterations} (error ${errorCount}/${this.MAX_ERRORS})`);
 					if (errorCount >= this.MAX_ERRORS) {
-						const errorMessage$1 = `Maximum error limit (${this.MAX_ERRORS}) reached`;
+						const errorMessage = `Maximum error limit (${this.MAX_ERRORS}) reached`;
 						logger.error({
 							maxErrors: this.MAX_ERRORS,
 							errorCount
-						}, errorMessage$1);
-						await sseHelper.writeOperation(errorOp(errorMessage$1, currentAgentId || "system"));
-						if (task) await updateTask(runDbClient_default)({
-							taskId: task.id,
-							data: {
-								status: "failed",
-								metadata: {
-									...task.metadata,
-									failed_at: (/* @__PURE__ */ new Date()).toISOString(),
-									error: errorMessage$1
-								}
+						}, errorMessage);
+						return tracer.startActiveSpan("execution_handler.execute", {}, async (span) => {
+							try {
+								span.setAttributes({
+									"ai.response.content": `Hmm.. It seems I might be having some issues right now. Please clear the chat and try again.`,
+									"ai.response.timestamp": (/* @__PURE__ */ new Date()).toISOString(),
+									"subAgent.name": agent?.subAgents[currentAgentId]?.name,
+									"subAgent.id": currentAgentId
+								});
+								setSpanWithError(span, new Error(errorMessage));
+								await sseHelper.writeOperation(errorOp(errorMessage, currentAgentId || "system"));
+								if (task) await updateTask(runDbClient_default)({
+									taskId: task.id,
+									data: {
+										status: "failed",
+										metadata: {
+											...task.metadata,
+											failed_at: (/* @__PURE__ */ new Date()).toISOString(),
+											error: errorMessage
+										}
+									}
+								});
+								await agentSessionManager.endSession(requestId);
+								unregisterStreamHelper(requestId);
+								return {
+									success: false,
+									error: errorMessage,
+									iterations
+								};
+							} finally {
+								span.end();
+								await new Promise((resolve) => setImmediate(resolve));
+								await flushBatchProcessor();
 							}
 						});
-						await agentSessionManager.endSession(requestId);
-						unregisterStreamHelper(requestId);
-						return {
-							success: false,
-							error: errorMessage$1,
-							iterations
-						};
 					}
 					continue;
 				}
@@ -391,12 +407,75 @@ var ExecutionHandler = class {
 					errorCount
 				}, `No valid response or transfer on iteration ${iterations} (error ${errorCount}/${this.MAX_ERRORS})`);
 				if (errorCount >= this.MAX_ERRORS) {
-					const errorMessage$1 = `Maximum error limit (${this.MAX_ERRORS}) reached`;
+					const errorMessage = `Maximum error limit (${this.MAX_ERRORS}) reached`;
 					logger.error({
 						maxErrors: this.MAX_ERRORS,
 						errorCount
-					}, errorMessage$1);
-					await sseHelper.writeOperation(errorOp(errorMessage$1, currentAgentId || "system"));
+					}, errorMessage);
+					return tracer.startActiveSpan("execution_handler.execute", {}, async (span) => {
+						try {
+							span.setAttributes({
+								"ai.response.content": "Hmm.. It seems I might be having some issues right now. Please clear the chat and try again.",
+								"ai.response.timestamp": (/* @__PURE__ */ new Date()).toISOString(),
+								"subAgent.name": agent?.subAgents[currentAgentId]?.name,
+								"subAgent.id": currentAgentId
+							});
+							setSpanWithError(span, new Error(errorMessage));
+							await sseHelper.writeOperation(errorOp(errorMessage, currentAgentId || "system"));
+							if (task) await updateTask(runDbClient_default)({
+								taskId: task.id,
+								data: {
+									status: "failed",
+									metadata: {
+										...task.metadata,
+										failed_at: /* @__PURE__ */ new Date(),
+										error: errorMessage
+									}
+								}
+							});
+							await agentSessionManager.endSession(requestId);
+							unregisterStreamHelper(requestId);
+							if (!params.datasetRunId) triggerConversationEvaluation({
+								tenantId,
+								projectId,
+								conversationId,
+								resolvedRef
+							}).catch((evalError) => {
+								logger.error({
+									error: evalError,
+									conversationId,
+									tenantId,
+									projectId
+								}, "Failed to trigger conversation evaluation (non-blocking)");
+							});
+							return {
+								success: false,
+								error: errorMessage,
+								iterations
+							};
+						} finally {
+							span.end();
+							await new Promise((resolve) => setImmediate(resolve));
+							await flushBatchProcessor();
+						}
+					});
+				}
+			}
+			const maxTransfersErrorMessage = `Maximum transfer limit (${maxTransfers}) reached without completion`;
+			logger.error({
+				maxTransfers,
+				iterations
+			}, maxTransfersErrorMessage);
+			return tracer.startActiveSpan("execution_handler.execute", {}, async (span) => {
+				try {
+					span.setAttributes({
+						"ai.response.content": "Hmm.. It seems I might be having some issues right now. Please clear the chat and try again.",
+						"ai.response.timestamp": (/* @__PURE__ */ new Date()).toISOString(),
+						"subAgent.name": agent?.subAgents[currentAgentId]?.name,
+						"subAgent.id": currentAgentId
+					});
+					setSpanWithError(span, new Error(maxTransfersErrorMessage));
+					await sseHelper.writeOperation(errorOp(maxTransfersErrorMessage, currentAgentId || "system"));
 					if (task) await updateTask(runDbClient_default)({
 						taskId: task.id,
 						data: {
@@ -404,78 +483,64 @@ var ExecutionHandler = class {
 							metadata: {
 								...task.metadata,
 								failed_at: /* @__PURE__ */ new Date(),
-								error: errorMessage$1
+								error: maxTransfersErrorMessage
 							}
 						}
 					});
 					await agentSessionManager.endSession(requestId);
 					unregisterStreamHelper(requestId);
-					if (!params.datasetRunId) triggerConversationEvaluation({
-						tenantId,
-						projectId,
-						conversationId,
-						resolvedRef
-					}).catch((error) => {
-						logger.error({
-							error,
-							conversationId,
-							tenantId,
-							projectId
-						}, "Failed to trigger conversation evaluation (non-blocking)");
-					});
 					return {
 						success: false,
-						error: errorMessage$1,
+						error: maxTransfersErrorMessage,
 						iterations
 					};
-				}
-			}
-			const errorMessage = `Maximum transfer limit (${maxTransfers}) reached without completion`;
-			logger.error({
-				maxTransfers,
-				iterations
-			}, errorMessage);
-			await sseHelper.writeOperation(errorOp(errorMessage, currentAgentId || "system"));
-			if (task) await updateTask(runDbClient_default)({
-				taskId: task.id,
-				data: {
-					status: "failed",
-					metadata: {
-						...task.metadata,
-						failed_at: /* @__PURE__ */ new Date(),
-						error: errorMessage
-					}
+				} finally {
+					span.end();
+					await new Promise((resolve) => setImmediate(resolve));
+					await flushBatchProcessor();
 				}
 			});
-			await agentSessionManager.endSession(requestId);
-			unregisterStreamHelper(requestId);
-			return {
-				success: false,
-				error: errorMessage,
-				iterations
-			};
 		} catch (error) {
-			logger.error({ error }, "Error in execution handler");
 			const errorMessage = error instanceof Error ? error.message : "Unknown execution error";
-			await sseHelper.writeOperation(errorOp(`Execution error: ${errorMessage}`, currentAgentId || "system"));
-			if (task) await updateTask(runDbClient_default)({
-				taskId: task.id,
-				data: {
-					status: "failed",
-					metadata: {
-						...task.metadata,
-						failed_at: /* @__PURE__ */ new Date(),
-						error: errorMessage
-					}
+			const errorStack = error instanceof Error ? error.stack : void 0;
+			logger.error({
+				errorMessage,
+				errorStack
+			}, "Error in execution handler");
+			return tracer.startActiveSpan("execution_handler.execute", {}, async (span) => {
+				try {
+					span.setAttributes({
+						"ai.response.content": "Hmm.. It seems I might be having some issues right now. Please clear the chat and try again.",
+						"ai.response.timestamp": (/* @__PURE__ */ new Date()).toISOString(),
+						"subAgent.name": agent?.subAgents[currentAgentId]?.name,
+						"subAgent.id": currentAgentId
+					});
+					setSpanWithError(span, error instanceof Error ? error : new Error(errorMessage));
+					await sseHelper.writeOperation(errorOp(`Execution error: ${errorMessage}`, currentAgentId || "system"));
+					if (task) await updateTask(runDbClient_default)({
+						taskId: task.id,
+						data: {
+							status: "failed",
+							metadata: {
+								...task.metadata,
+								failed_at: /* @__PURE__ */ new Date(),
+								error: errorMessage
+							}
+						}
+					});
+					await agentSessionManager.endSession(requestId);
+					unregisterStreamHelper(requestId);
+					return {
+						success: false,
+						error: errorMessage,
+						iterations
+					};
+				} finally {
+					span.end();
+					await new Promise((resolve) => setImmediate(resolve));
+					await flushBatchProcessor();
 				}
 			});
-			await agentSessionManager.endSession(requestId);
-			unregisterStreamHelper(requestId);
-			return {
-				success: false,
-				error: errorMessage,
-				iterations
-			};
 		}
 	}
 };

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

@@ -11,7 +11,7 @@ app.openapi(createRoute({
 	method: "get",
 	path: "/.well-known/agent.json",
 	request: { headers: HeadersScopeSchema },
-	tags: ["a2a"],
+	tags: ["A2A"],
 	security: [{ bearerAuth: [] }],
 	responses: {
 		200: {

package/dist/domains/run/routes/chat.js

@@ -3,6 +3,7 @@ import runDbClient_default from "../../../data/db/runDbClient.js";
 import { contextValidationMiddleware } from "../context/validation.js";
 import { handleContextResolution } from "../context/context.js";
 import "../context/index.js";
+import { toolApprovalUiBus } from "../services/ToolApprovalUiBus.js";
 import { errorOp } from "../utils/agent-operations.js";
 import { createSSEStreamHelper } from "../utils/stream-helpers.js";
 import { ExecutionHandler } from "../handlers/executionHandler.js";
@@ -17,7 +18,7 @@ const logger = getLogger$1("completionsHandler");
 const chatCompletionsRoute = createRoute({
 	method: "post",
 	path: "/completions",
-	tags: ["chat"],
+	tags: ["Chat"],
 	summary: "Create chat completion",
 	description: "Creates a new chat completion with streaming SSE response using the configured agent",
 	security: [{ bearerAuth: [] }],
@@ -222,9 +223,50 @@ app.openapi(chatCompletionsRoute, async (c) => {
 				"database.operation": "insert"
 			});
 			return streamSSE(c, async (stream$1) => {
+				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;
+				};
+				let unsubscribe;
 				try {
 					const sseHelper = createSSEStreamHelper(stream$1, requestId, timestamp);
 					await sseHelper.writeRole();
+					const seenToolCalls = /* @__PURE__ */ new Set();
+					const seenOutputs = /* @__PURE__ */ new Set();
+					unsubscribe = toolApprovalUiBus.subscribe(requestId, async (event) => {
+						if (event.type === "approval-needed") {
+							if (seenToolCalls.has(event.toolCallId)) return;
+							seenToolCalls.add(event.toolCallId);
+							await sseHelper.writeToolInputStart({
+								toolCallId: event.toolCallId,
+								toolName: event.toolName
+							});
+							const inputText = JSON.stringify(event.input ?? {});
+							for (const part of chunkString(inputText, 16)) await sseHelper.writeToolInputDelta({
+								toolCallId: event.toolCallId,
+								inputTextDelta: part
+							});
+							await sseHelper.writeToolInputAvailable({
+								toolCallId: event.toolCallId,
+								toolName: event.toolName,
+								input: event.input ?? {},
+								providerMetadata: event.providerMetadata
+							});
+							await sseHelper.writeToolApprovalRequest({
+								approvalId: event.approvalId,
+								toolCallId: event.toolCallId
+							});
+						} else if (event.type === "approval-resolved") {
+							if (seenOutputs.has(event.toolCallId)) return;
+							seenOutputs.add(event.toolCallId);
+							if (event.approved) await sseHelper.writeToolOutputAvailable({
+								toolCallId: event.toolCallId,
+								output: { status: "approved" }
+							});
+							else await sseHelper.writeToolOutputDenied({ toolCallId: event.toolCallId });
+						}
+					});
 					logger.info({ subAgentId }, "Starting execution");
 					const emitOperations = c.req.header("x-emit-operations") === "true";
 					const forwardedHeaders = {};
@@ -275,6 +317,10 @@ app.openapi(chatCompletionsRoute, async (c) => {
 					} catch (streamError) {
 						logger.error({ streamError }, "Failed to write error to stream");
 					}
+				} finally {
+					try {
+						unsubscribe?.();
+					} catch (_e) {}
 				}
 			});
 		});

package/dist/domains/run/routes/chatDataStream.js

@@ -4,6 +4,7 @@ import { contextValidationMiddleware } from "../context/validation.js";
 import { handleContextResolution } from "../context/context.js";
 import "../context/index.js";
 import { pendingToolApprovalManager } from "../services/PendingToolApprovalManager.js";
+import { toolApprovalUiBus } from "../services/ToolApprovalUiBus.js";
 import { errorOp } from "../utils/agent-operations.js";
 import { createBufferingStreamHelper, createVercelStreamHelper } from "../utils/stream-helpers.js";
 import { ExecutionHandler } from "../handlers/executionHandler.js";
@@ -19,7 +20,7 @@ const logger = getLogger$1("chatDataStream");
 const chatDataStreamRoute = createRoute({
 	method: "post",
 	path: "/chat",
-	tags: ["chat"],
+	tags: ["Chat"],
 	summary: "Chat (Vercel Streaming Protocol)",
 	description: "Chat completion endpoint streaming with Vercel data stream protocol.",
 	security: [{ bearerAuth: [] }],
@@ -34,16 +35,31 @@ const chatDataStreamRoute = createRoute({
 				"tool"
 			]),
 			content: z.any(),
-			parts: z.array(z.object({
-				type: z.union([z.enum([
-					"text",
-					"image",
-					"audio",
-					"video",
-					"file"
-				]), z.string().regex(/^data-/, "Type must start with \"data-\"")]),
-				text: z.string().optional()
-			})).optional()
+			parts: z.array(z.union([
+				z.object({
+					type: z.union([z.enum([
+						"text",
+						"image",
+						"audio",
+						"video",
+						"file"
+					]), z.string().regex(/^data-/, "Type must start with \"data-\"")]),
+					text: z.string().optional()
+				}),
+				z.object({
+					type: z.string().regex(/^tool-/, "Type must start with \"tool-\""),
+					toolCallId: z.string(),
+					state: z.any(),
+					approval: z.object({
+						id: z.string(),
+						approved: z.boolean().optional(),
+						reason: z.string().optional()
+					}).optional(),
+					input: z.any().optional(),
+					callProviderMetadata: z.any().optional()
+				}),
+				z.object({ type: z.literal("step-start") })
+			])).optional()
 		})),
 		id: z.string().optional(),
 		conversationId: z.string().optional(),
@@ -74,7 +90,39 @@ app.openapi(chatDataStreamRoute, async (c) => {
 			agentId
 		}, "Extracted chatDataStream parameters");
 		const body = c.get("requestBody") || {};
-		const conversationId = body.conversationId || getConversationId();
+		const approvalPart = (body.messages || []).flatMap((m) => m?.parts || []).find((p) => p?.state === "approval-responded" && typeof p?.toolCallId === "string");
+		const isApprovalResponse = !!approvalPart;
+		const conversationId = isApprovalResponse ? body.conversationId : body.conversationId || getConversationId();
+		if (isApprovalResponse) {
+			if (!conversationId) return c.json({
+				success: false,
+				error: "conversationId is required for approval response"
+			}, 400);
+			const toolCallId = approvalPart.toolCallId;
+			const approved = !!approvalPart.approval?.approved;
+			const reason = approvalPart.approval?.reason;
+			if (!await getConversation(runDbClient_default)({
+				scopes: {
+					tenantId,
+					projectId
+				},
+				conversationId
+			})) return c.json({
+				success: false,
+				error: "Conversation not found"
+			}, 404);
+			if (!(approved ? pendingToolApprovalManager.approveToolCall(toolCallId) : pendingToolApprovalManager.denyToolCall(toolCallId, reason))) return c.json({
+				success: true,
+				toolCallId,
+				approved,
+				alreadyProcessed: true
+			});
+			return c.json({
+				success: true,
+				toolCallId,
+				approved
+			});
+		}
 		const targetTenantId = c.req.header("x-target-tenant-id");
 		const targetProjectId = c.req.header("x-target-project-id");
 		const targetAgentId = c.req.header("x-target-agent-id");
@@ -227,16 +275,58 @@ app.openapi(chatDataStreamRoute, async (c) => {
 			}
 			const dataStream = createUIMessageStream({ execute: async ({ writer }) => {
 				const streamHelper = createVercelStreamHelper(writer);
+				let unsubscribe;
 				try {
 					const emitOperations = c.req.header("x-emit-operations") === "true";
 					const executionHandler = new ExecutionHandler();
 					const datasetRunId = c.req.header("x-inkeep-dataset-run-id");
+					const requestId = `chatds-${Date.now()}`;
+					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 seenToolCalls = /* @__PURE__ */ new Set();
+					const seenOutputs = /* @__PURE__ */ new Set();
+					unsubscribe = toolApprovalUiBus.subscribe(requestId, async (event) => {
+						if (event.type === "approval-needed") {
+							if (seenToolCalls.has(event.toolCallId)) return;
+							seenToolCalls.add(event.toolCallId);
+							await streamHelper.writeToolInputStart({
+								toolCallId: event.toolCallId,
+								toolName: event.toolName
+							});
+							const inputText = JSON.stringify(event.input ?? {});
+							for (const part of chunkString(inputText, 16)) await streamHelper.writeToolInputDelta({
+								toolCallId: event.toolCallId,
+								inputTextDelta: part
+							});
+							await streamHelper.writeToolInputAvailable({
+								toolCallId: event.toolCallId,
+								toolName: event.toolName,
+								input: event.input ?? {},
+								providerMetadata: event.providerMetadata
+							});
+							await streamHelper.writeToolApprovalRequest({
+								approvalId: event.approvalId,
+								toolCallId: event.toolCallId
+							});
+						} else if (event.type === "approval-resolved") {
+							if (seenOutputs.has(event.toolCallId)) return;
+							seenOutputs.add(event.toolCallId);
+							if (event.approved) await streamHelper.writeToolOutputAvailable({
+								toolCallId: event.toolCallId,
+								output: { status: "approved" }
+							});
+							else await streamHelper.writeToolOutputDenied({ toolCallId: event.toolCallId });
+						}
+					});
 					if (!(await executionHandler.execute({
 						executionContext,
 						conversationId,
 						userMessage: userText,
 						initialAgentId: subAgentId,
-						requestId: `chatds-${Date.now()}`,
+						requestId,
 						sseHelper: streamHelper,
 						emitOperations,
 						datasetRunId: datasetRunId || void 0,
@@ -246,6 +336,9 @@ app.openapi(chatDataStreamRoute, async (c) => {
 					logger.error({ err }, "Streaming error");
 					await streamHelper.writeOperation(errorOp("Internal server error", "system"));
 				} finally {
+					try {
+						unsubscribe?.();
+					} catch (_e) {}
 					if ("cleanup" in streamHelper && typeof streamHelper.cleanup === "function") streamHelper.cleanup();
 				}
 			} });
@@ -272,7 +365,7 @@ app.openapi(chatDataStreamRoute, async (c) => {
 const toolApprovalRoute = createRoute({
 	method: "post",
 	path: "/tool-approvals",
-	tags: ["chat"],
+	tags: ["Chat"],
 	summary: "Approve or deny tool execution",
 	description: "Handle user approval/denial of tool execution requests during conversations",
 	security: [{ bearerAuth: [] }],