@inkeep/agents-api 0.0.0-dev-20260122003353 → 0.0.0-dev-20260122004923

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";
@@ -223,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 = {
@@ -237,9 +244,26 @@ 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,
@@ -256,7 +280,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,
@@ -284,7 +308,7 @@ 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,
@@ -292,11 +316,17 @@ var Agent = class {
 						relationshipId,
 						needsApproval
 					});
+					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,
@@ -305,6 +335,10 @@ var Agent = class {
 						relationshipId,
 						needsApproval
 					});
+					if (streamRequestId && streamHelper && !isInternalToolForUi) await streamHelper.writeToolOutputError({
+						toolCallId,
+						error: errorMessage
+					});
 					throw error;
 				}
 			}
@@ -374,7 +408,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);
@@ -412,22 +446,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,
@@ -441,6 +505,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,
@@ -500,10 +572,7 @@ var Agent = class {
 							result: enhancedResult,
 							timestamp: Date.now()
 						});
-						return {
-							result: enhancedResult,
-							toolCallId
-						};
+						return enhancedResult;
 					} catch (error) {
 						logger.error({
 							toolName,
@@ -795,10 +864,7 @@ var Agent = class {
 								result,
 								timestamp: Date.now()
 							});
-							return {
-								result,
-								toolCallId
-							};
+							return result;
 						} catch (error) {
 							logger.error({
 								toolName: functionToolDef.name,

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";
@@ -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";
@@ -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.literal("approval-responded"),
+					approval: z.object({
+						id: z.string(),
+						approved: z.boolean(),
+						reason: z.string().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();
 				}
 			} });

package/dist/domains/run/services/ToolApprovalUiBus.d.ts

@@ -0,0 +1,28 @@
+//#region src/domains/run/services/ToolApprovalUiBus.d.ts
+type ToolApprovalUiEvent = {
+  type: 'approval-needed';
+  toolCallId: string;
+  toolName: string;
+  input: any;
+  providerMetadata?: any;
+  approvalId: string;
+} | {
+  type: 'approval-resolved';
+  toolCallId: string;
+  approved: boolean;
+};
+type Listener = (event: ToolApprovalUiEvent) => void | Promise<void>;
+/**
+ * In-process event bus keyed by streamRequestId.
+ *
+ * Used to propagate approval UI events from delegated agents (who must not write to stream)
+ * up to the user-facing request handler, which can stream tool UI parts to the client.
+ */
+declare class ToolApprovalUiBus {
+  private listeners;
+  subscribe(streamRequestId: string, listener: Listener): () => void;
+  publish(streamRequestId: string, event: ToolApprovalUiEvent): Promise<void>;
+}
+declare const toolApprovalUiBus: ToolApprovalUiBus;
+//#endregion
+export { ToolApprovalUiBus, ToolApprovalUiEvent, toolApprovalUiBus };

package/dist/domains/run/services/ToolApprovalUiBus.js

@@ -0,0 +1,44 @@
+import { getLogger } from "../../../logger.js";
+
+//#region src/domains/run/services/ToolApprovalUiBus.ts
+const logger = getLogger("ToolApprovalUiBus");
+/**
+* In-process event bus keyed by streamRequestId.
+*
+* Used to propagate approval UI events from delegated agents (who must not write to stream)
+* up to the user-facing request handler, which can stream tool UI parts to the client.
+*/
+var ToolApprovalUiBus = class {
+	listeners = /* @__PURE__ */ new Map();
+	subscribe(streamRequestId, listener) {
+		if (!streamRequestId) return () => {};
+		const set = this.listeners.get(streamRequestId) ?? /* @__PURE__ */ new Set();
+		set.add(listener);
+		this.listeners.set(streamRequestId, set);
+		return () => {
+			const existing = this.listeners.get(streamRequestId);
+			if (!existing) return;
+			existing.delete(listener);
+			if (existing.size === 0) this.listeners.delete(streamRequestId);
+		};
+	}
+	async publish(streamRequestId, event) {
+		if (!streamRequestId) return;
+		const set = this.listeners.get(streamRequestId);
+		if (!set || set.size === 0) return;
+		for (const listener of set) try {
+			await listener(event);
+		} catch (error) {
+			logger.warn({
+				streamRequestId,
+				eventType: event.type,
+				toolCallId: event.toolCallId,
+				error: error instanceof Error ? error.message : String(error)
+			}, "ToolApprovalUiBus listener failed");
+		}
+	}
+};
+const toolApprovalUiBus = new ToolApprovalUiBus();
+
+//#endregion
+export { ToolApprovalUiBus, toolApprovalUiBus };