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

package/dist/.well-known/workflow/v1/manifest.debug.json

@@ -1,5 +1,19 @@
 {
   "steps": {
+    "src/domains/evals/workflow/functions/runDatasetItem.ts": {
+      "callChatApiStep": {
+        "stepId": "step//src/domains/evals/workflow/functions/runDatasetItem.ts//callChatApiStep"
+      },
+      "createRelationStep": {
+        "stepId": "step//src/domains/evals/workflow/functions/runDatasetItem.ts//createRelationStep"
+      },
+      "executeEvaluatorStep": {
+        "stepId": "step//src/domains/evals/workflow/functions/runDatasetItem.ts//executeEvaluatorStep"
+      },
+      "logStep": {
+        "stepId": "step//src/domains/evals/workflow/functions/runDatasetItem.ts//logStep"
+      }
+    },
     "node_modules/.pnpm/workflow@4.0.1-beta.33_@aws-sdk+client-sts@3.970.0_@opentelemetry+api@1.9.0_@types+reac_5c488396978166b4f12e99cb3aa4a769/node_modules/workflow/dist/internal/builtins.js": {
       "__builtin_response_array_buffer": {
         "stepId": "__builtin_response_array_buffer"
@@ -24,20 +38,6 @@
       "logStep": {
         "stepId": "step//src/domains/evals/workflow/functions/evaluateConversation.ts//logStep"
       }
-    },
-    "src/domains/evals/workflow/functions/runDatasetItem.ts": {
-      "callChatApiStep": {
-        "stepId": "step//src/domains/evals/workflow/functions/runDatasetItem.ts//callChatApiStep"
-      },
-      "createRelationStep": {
-        "stepId": "step//src/domains/evals/workflow/functions/runDatasetItem.ts//createRelationStep"
-      },
-      "executeEvaluatorStep": {
-        "stepId": "step//src/domains/evals/workflow/functions/runDatasetItem.ts//executeEvaluatorStep"
-      },
-      "logStep": {
-        "stepId": "step//src/domains/evals/workflow/functions/runDatasetItem.ts//logStep"
-      }
     }
   },
   "workflows": {

package/dist/.well-known/workflow/v1/step.cjs

@@ -127829,7 +127829,9 @@ var FunctionToolInsertSchema = createInsertSchema2(functionTools).extend({
   id: resourceIdSchema
 });
 var FunctionToolUpdateSchema = FunctionToolInsertSchema.partial();
-var FunctionToolApiSelectSchema = createApiSchema(FunctionToolSelectSchema).openapi("FunctionTool");
+var FunctionToolApiSelectSchema = createApiSchema(FunctionToolSelectSchema).extend({
+  relationshipId: external_exports.string().optional()
+}).openapi("FunctionTool");
 var FunctionToolApiInsertSchema = createAgentScopedApiInsertSchema(FunctionToolInsertSchema).openapi("FunctionToolCreate");
 var FunctionToolApiUpdateSchema = createApiUpdateSchema(FunctionToolUpdateSchema).openapi("FunctionToolUpdate");
 var SubAgentFunctionToolRelationSelectSchema = createSelectSchema2(subAgentFunctionToolRelations);

package/dist/createApp.d.ts

@@ -1,10 +1,10 @@
 import { AppConfig } from "./types/app.js";
 import "./types/index.js";
 import { Hono } from "hono";
-import * as hono_types8 from "hono/types";
+import * as hono_types1 from "hono/types";
 
 //#region src/createApp.d.ts
 declare const isWebhookRoute: (path: string) => boolean;
-declare function createAgentsHono(config: AppConfig): Hono<hono_types8.BlankEnv, hono_types8.BlankSchema, "/">;
+declare function createAgentsHono(config: AppConfig): Hono<hono_types1.BlankEnv, hono_types1.BlankSchema, "/">;
 //#endregion
 export { createAgentsHono, isWebhookRoute };

package/dist/domains/evals/routes/datasetTriggers.d.ts

@@ -1,7 +1,7 @@
 import { OpenAPIHono } from "@hono/zod-openapi";
-import * as hono16 from "hono";
+import * as hono14 from "hono";
 
 //#region src/domains/evals/routes/datasetTriggers.d.ts
-declare const app: OpenAPIHono<hono16.Env, {}, "/">;
+declare const app: OpenAPIHono<hono14.Env, {}, "/">;
 //#endregion
 export { app as default };

package/dist/domains/evals/routes/index.d.ts

@@ -1,7 +1,7 @@
 import { OpenAPIHono } from "@hono/zod-openapi";
-import * as hono17 from "hono";
+import * as hono15 from "hono";
 
 //#region src/domains/evals/routes/index.d.ts
-declare const app: OpenAPIHono<hono17.Env, {}, "/">;
+declare const app: OpenAPIHono<hono15.Env, {}, "/">;
 //#endregion
 export { app as default };

package/dist/domains/evals/workflow/routes.d.ts

@@ -1,7 +1,7 @@
 import { Hono } from "hono";
-import * as hono_types1 from "hono/types";
+import * as hono_types5 from "hono/types";
 
 //#region src/domains/evals/workflow/routes.d.ts
-declare const workflowRoutes: Hono<hono_types1.BlankEnv, hono_types1.BlankSchema, "/">;
+declare const workflowRoutes: Hono<hono_types5.BlankEnv, hono_types5.BlankSchema, "/">;
 //#endregion
 export { workflowRoutes };

package/dist/domains/manage/routes/conversations.d.ts

@@ -1,7 +1,7 @@
 import { OpenAPIHono } from "@hono/zod-openapi";
-import * as hono14 from "hono";
+import * as hono16 from "hono";
 
 //#region src/domains/manage/routes/conversations.d.ts
-declare const app: OpenAPIHono<hono14.Env, {}, "/">;
+declare const app: OpenAPIHono<hono16.Env, {}, "/">;
 //#endregion
 export { app as default };

package/dist/domains/manage/routes/index.d.ts

@@ -1,7 +1,7 @@
 import { OpenAPIHono } from "@hono/zod-openapi";
-import * as hono15 from "hono";
+import * as hono17 from "hono";
 
 //#region src/domains/manage/routes/index.d.ts
-declare const app: OpenAPIHono<hono15.Env, {}, "/">;
+declare const app: OpenAPIHono<hono17.Env, {}, "/">;
 //#endregion
 export { app as default };

package/dist/domains/manage/routes/mcp.d.ts

@@ -1,7 +1,7 @@
 import { Hono } from "hono";
-import * as hono_types3 from "hono/types";
+import * as hono_types8 from "hono/types";
 
 //#region src/domains/manage/routes/mcp.d.ts
-declare const app: Hono<hono_types3.BlankEnv, hono_types3.BlankSchema, "/">;
+declare const app: Hono<hono_types8.BlankEnv, hono_types8.BlankSchema, "/">;
 //#endregion
 export { app as default };

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";
@@ -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,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,
@@ -254,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,
@@ -282,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,
@@ -290,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,
@@ -303,6 +335,10 @@ var Agent = class {
 						relationshipId,
 						needsApproval
 					});
+					if (streamRequestId && streamHelper && !isInternalToolForUi) await streamHelper.writeToolOutputError({
+						toolCallId,
+						error: errorMessage
+					});
 					throw error;
 				}
 			}
@@ -372,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);
@@ -410,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,
@@ -439,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,
@@ -498,10 +572,7 @@ var Agent = class {
 							result: enhancedResult,
 							timestamp: Date.now()
 						});
-						return {
-							result: enhancedResult,
-							toolCallId
-						};
+						return enhancedResult;
 					} catch (error) {
 						logger.error({
 							toolName,
@@ -727,6 +798,9 @@ 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 = sessionId ? SandboxExecutorFactory.getForSession(sessionId) : new SandboxExecutorFactory();
 			for (const functionToolDef of functionToolsData) {
@@ -790,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 };