@inkeep/agents-api 0.42.0 → 0.44.0

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

@@ -1,26 +1,18 @@
-import { getLogger as getLogger$1 } from "../../../logger.js";
-import { env } from "../../../env.js";
-import manageDbPool_default from "../../../data/db/manageDbPool.js";
-import runDbClient_default from "../../../data/db/runDbClient.js";
-import { createSSEStreamHelper } from "../utils/stream-helpers.js";
-import { ExecutionHandler } from "../handlers/executionHandler.js";
+import { getLogger } from "../../../logger.js";
+import { processWebhook } from "../services/TriggerService.js";
 import { OpenAPIHono, createRoute, z } from "@hono/zod-openapi";
-import { JsonTransformer, createApiError, createMessage, createOrGetConversation, createTriggerInvocation, generateId, getConversationId, getFullProjectWithRelationIds, getTriggerById, interpolateTemplate, setActiveAgentForConversation, updateTriggerInvocationStatus, verifySigningSecret, verifyTriggerAuth, withRef } from "@inkeep/agents-core";
-import { context, propagation, trace } from "@opentelemetry/api";
-import Ajv from "ajv";
 
 //#region src/domains/run/routes/webhooks.ts
 const app = new OpenAPIHono();
-const logger = getLogger$1("webhooks");
-const ajv = new Ajv({ allErrors: true });
+const logger = getLogger("webhooks");
 /**
 * Webhook endpoint for trigger invocation
-* POST /tenants/:tenantId/projects/:projectId/agents/:agentId/triggers/:triggerId
+* POST /tenants/{tenantId}/projects/{projectId}/agents/{agentId}/triggers/{triggerId}
 */
 const triggerWebhookRoute = createRoute({
 	method: "post",
-	path: "/tenants/:tenantId/projects/:projectId/agents/:agentId/triggers/:triggerId",
-	tags: ["webhooks"],
+	path: "/tenants/{tenantId}/projects/{projectId}/agents/{agentId}/triggers/{triggerId}",
+	tags: ["Webhooks"],
 	summary: "Invoke agent via trigger webhook",
 	description: "Webhook endpoint for third-party services to invoke an agent via a configured trigger",
 	request: {
@@ -37,7 +29,8 @@ const triggerWebhookRoute = createRoute({
 			description: "Webhook accepted and trigger invoked",
 			content: { "application/json": { schema: z.object({
 				success: z.boolean(),
-				invocationId: z.string()
+				invocationId: z.string(),
+				conversationId: z.string()
 			}) } }
 		},
 		400: {
@@ -62,6 +55,10 @@ const triggerWebhookRoute = createRoute({
 		422: {
 			description: "Payload transformation failed",
 			content: { "application/json": { schema: z.object({ error: z.string() }) } }
+		},
+		500: {
+			description: "Internal server error",
+			content: { "application/json": { schema: z.object({ error: z.string() }) } }
 		}
 	}
 });
@@ -74,341 +71,36 @@ app.openapi(triggerWebhookRoute, async (c) => {
 		agentId,
 		triggerId
 	}, "Processing trigger webhook");
-	try {
-		const trigger = await withRef(manageDbPool_default, resolvedRef, (db) => getTriggerById(db)({
-			scopes: {
-				tenantId,
-				projectId,
-				agentId
-			},
-			triggerId
-		}));
-		if (!trigger) throw createApiError({
-			code: "not_found",
-			message: `Trigger ${triggerId} not found`
-		});
-		if (!trigger.enabled) throw createApiError({
-			code: "not_found",
-			message: "Trigger is disabled"
-		});
-		const bodyText = await c.req.text();
-		const payload = bodyText ? JSON.parse(bodyText) : {};
-		if (trigger.authentication) {
-			const authResult = await verifyTriggerAuth(c, trigger.authentication);
-			if (!authResult.success) {
-				if (authResult.status === 401) return c.json({ error: authResult.message || "Unauthorized" }, 401);
-				return c.json({ error: authResult.message || "Forbidden" }, 403);
-			}
-		}
-		if (trigger.signingSecret) {
-			const signatureResult = verifySigningSecret(c, trigger.signingSecret, bodyText);
-			if (!signatureResult.success) return c.json({ error: signatureResult.message || "Invalid signature" }, 403);
-		}
-		if (trigger.inputSchema) {
-			const validate = ajv.compile(trigger.inputSchema);
-			if (!validate(payload)) {
-				const errors = validate.errors?.map((err) => `${err.instancePath} ${err.message}`);
-				return c.json({
-					error: "Payload validation failed",
-					validationErrors: errors
-				}, 400);
-			}
-		}
-		let transformedPayload = payload;
-		if (trigger.outputTransform) try {
-			transformedPayload = await JsonTransformer.transformWithConfig(payload, trigger.outputTransform);
-			logger.debug({
-				triggerId,
-				tenantId,
-				projectId
-			}, "Payload transformation successful");
-		} catch (error) {
-			const errorMessage = error instanceof Error ? error.message : String(error);
-			logger.error({
-				triggerId,
-				tenantId,
-				projectId,
-				error: errorMessage
-			}, "Payload transformation failed");
-			return c.json({ error: `Payload transformation failed: ${errorMessage}` }, 422);
-		}
-		const messageParts = [];
-		if (trigger.messageTemplate) {
-			const interpolatedMessage = interpolateTemplate(trigger.messageTemplate, transformedPayload);
-			messageParts.push({
-				kind: "text",
-				text: interpolatedMessage
-			});
-		}
-		if (transformedPayload != null) messageParts.push({
-			kind: "data",
-			data: transformedPayload,
-			metadata: {
-				source: "trigger",
-				triggerId
-			}
-		});
-		const userMessageText = trigger.messageTemplate ? interpolateTemplate(trigger.messageTemplate, transformedPayload) : JSON.stringify(transformedPayload);
-		const conversationId = getConversationId();
-		const invocationId = generateId();
-		await createTriggerInvocation(runDbClient_default)({
-			id: invocationId,
-			triggerId,
-			tenantId,
-			projectId,
-			agentId,
-			conversationId,
-			status: "pending",
-			requestPayload: payload,
-			transformedPayload
-		});
-		logger.info({
-			tenantId,
-			projectId,
-			agentId,
-			triggerId,
-			invocationId,
-			conversationId
-		}, "Trigger invocation created");
-		invokeAgentAsync({
-			tenantId,
-			projectId,
-			agentId,
-			triggerId,
-			invocationId,
-			conversationId,
-			userMessage: userMessageText,
-			messageParts,
-			resolvedRef
-		}).catch((error) => {
-			logger.error({
-				error,
-				tenantId,
-				projectId,
-				agentId,
-				triggerId,
-				invocationId
-			}, "Async agent invocation failed");
-		});
-		logger.info({
-			tenantId,
-			projectId,
-			agentId,
-			triggerId,
-			invocationId,
-			conversationId
-		}, "Trigger webhook accepted, agent invocation initiated");
-		return c.json({
-			success: true,
-			invocationId
-		}, 202);
-	} catch (error) {
-		logger.error({
-			error,
-			tenantId,
-			projectId,
-			agentId,
-			triggerId
-		}, "Webhook processing failed");
-		throw error;
+	const result = await processWebhook({
+		tenantId,
+		projectId,
+		agentId,
+		triggerId,
+		resolvedRef,
+		rawBody: await c.req.text(),
+		honoContext: c
+	});
+	if (!result.success) {
+		if (result.validationErrors) return c.json({
+			error: result.error,
+			validationErrors: result.validationErrors
+		}, result.status);
+		return c.json({ error: result.error }, result.status);
 	}
+	logger.info({
+		tenantId,
+		projectId,
+		agentId,
+		triggerId,
+		invocationId: result.invocationId,
+		conversationId: result.conversationId
+	}, "Trigger webhook accepted, workflow dispatched");
+	return c.json({
+		success: true,
+		invocationId: result.invocationId,
+		conversationId: result.conversationId
+	}, 202);
 });
-/**
-* Invokes an agent asynchronously for a trigger invocation.
-* This function creates a conversation, stores the user message,
-* and executes the agent using ExecutionHandler.
-* It updates the trigger invocation status based on success/failure.
-*/
-async function invokeAgentAsync(params) {
-	const { tenantId, projectId, agentId, triggerId, invocationId, conversationId, userMessage, messageParts, resolvedRef } = params;
-	return await trace.getTracer("trigger-invocation").startActiveSpan("trigger.invocation", { attributes: {
-		"conversation.id": conversationId,
-		"tenant.id": tenantId,
-		"project.id": projectId,
-		"agent.id": agentId,
-		"invocation.type": "trigger",
-		"trigger.id": triggerId,
-		"trigger.invocation.id": invocationId,
-		"message.content": userMessage,
-		"message.parts": JSON.stringify(messageParts),
-		"message.timestamp": (/* @__PURE__ */ new Date()).toISOString()
-	} }, async (span) => {
-		let currentBag = propagation.getBaggage(context.active());
-		if (!currentBag) currentBag = propagation.createBaggage();
-		currentBag = currentBag.setEntry("conversation.id", { value: conversationId });
-		currentBag = currentBag.setEntry("tenant.id", { value: tenantId });
-		currentBag = currentBag.setEntry("project.id", { value: projectId });
-		currentBag = currentBag.setEntry("agent.id", { value: agentId });
-		currentBag = currentBag.setEntry("invocation.type", { value: "trigger" });
-		currentBag = currentBag.setEntry("trigger.id", { value: triggerId });
-		currentBag = currentBag.setEntry("trigger.invocation.id", { value: invocationId });
-		const ctxWithBaggage = propagation.setBaggage(context.active(), currentBag);
-		return await context.with(ctxWithBaggage, async () => {
-			try {
-				logger.info({
-					tenantId,
-					projectId,
-					agentId,
-					triggerId,
-					invocationId,
-					conversationId
-				}, "Starting async agent invocation");
-				const project = await withRef(manageDbPool_default, resolvedRef, async (db) => {
-					return await getFullProjectWithRelationIds(db)({ scopes: {
-						tenantId,
-						projectId
-					} });
-				});
-				if (!project) throw createApiError({
-					code: "not_found",
-					message: `Project ${projectId} not found`
-				});
-				const fullAgent = project.agents[agentId];
-				if (!fullAgent) throw createApiError({
-					code: "not_found",
-					message: `Agent ${agentId} not found`
-				});
-				logger.debug({
-					tenantId,
-					projectId,
-					agentId,
-					defaultSubAgentId: fullAgent.defaultSubAgentId,
-					subAgentKeys: Object.keys(fullAgent.subAgents || {}),
-					subAgentsCount: Object.keys(fullAgent.subAgents || {}).length
-				}, "Debug: Agent and sub-agent info");
-				const agentKeys = Object.keys(fullAgent.subAgents || {});
-				const firstAgentId = agentKeys.length > 0 ? agentKeys[0] : "";
-				const defaultSubAgentId = fullAgent.defaultSubAgentId || firstAgentId;
-				if (!defaultSubAgentId) throw createApiError({
-					code: "not_found",
-					message: "No default sub-agent found"
-				});
-				const executionContext = {
-					tenantId,
-					projectId,
-					agentId,
-					baseUrl: env.INKEEP_AGENTS_API_URL || "http://localhost:3002",
-					apiKey: "",
-					apiKeyId: "trigger-invocation",
-					resolvedRef,
-					project,
-					metadata: { initiatedBy: {
-						type: "api_key",
-						id: triggerId
-					} }
-				};
-				await createOrGetConversation(runDbClient_default)({
-					tenantId,
-					projectId,
-					id: conversationId,
-					agentId,
-					activeSubAgentId: defaultSubAgentId,
-					ref: executionContext.resolvedRef
-				});
-				await setActiveAgentForConversation(runDbClient_default)({
-					scopes: {
-						tenantId,
-						projectId
-					},
-					conversationId,
-					agentId,
-					subAgentId: defaultSubAgentId,
-					ref: executionContext.resolvedRef
-				});
-				logger.info({
-					conversationId,
-					agentId,
-					defaultSubAgentId
-				}, "Conversation created and agent set");
-				await createMessage(runDbClient_default)({
-					id: generateId(),
-					tenantId,
-					projectId,
-					conversationId,
-					role: "user",
-					content: { parts: messageParts },
-					visibility: "user-facing",
-					messageType: "chat"
-				});
-				logger.info({
-					conversationId,
-					invocationId
-				}, "User message created");
-				const requestId = `trigger-${invocationId}`;
-				const noOpStreamHelper = createSSEStreamHelper({
-					writeSSE: async () => {},
-					sleep: async () => {}
-				}, requestId, Math.floor(Date.now() / 1e3));
-				await new ExecutionHandler().execute({
-					executionContext,
-					conversationId,
-					userMessage,
-					messageParts,
-					initialAgentId: agentId,
-					requestId,
-					sseHelper: noOpStreamHelper,
-					emitOperations: false
-				});
-				await updateTriggerInvocationStatus(runDbClient_default)({
-					scopes: {
-						tenantId,
-						projectId,
-						agentId
-					},
-					triggerId,
-					invocationId,
-					data: { status: "success" }
-				});
-				logger.info({
-					tenantId,
-					projectId,
-					agentId,
-					triggerId,
-					invocationId,
-					conversationId
-				}, "Agent invocation completed successfully");
-				span.end();
-			} catch (error) {
-				const errorMessage = error instanceof Error ? error.message : String(error);
-				logger.error({
-					error,
-					tenantId,
-					projectId,
-					agentId,
-					triggerId,
-					invocationId
-				}, "Agent invocation failed");
-				span.recordException(error instanceof Error ? error : new Error(errorMessage));
-				span.setStatus({
-					code: 2,
-					message: errorMessage
-				});
-				try {
-					await updateTriggerInvocationStatus(runDbClient_default)({
-						scopes: {
-							tenantId,
-							projectId,
-							agentId
-						},
-						triggerId,
-						invocationId,
-						data: {
-							status: "failed",
-							errorMessage
-						}
-					});
-				} catch (updateError) {
-					logger.error({
-						updateError,
-						invocationId
-					}, "Failed to update trigger invocation status to failed");
-				}
-				span.end();
-				throw error;
-			}
-		});
-	});
-}
 var webhooks_default = app;
 
 //#endregion

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

@@ -112,6 +112,7 @@ interface ToolCallData {
   relationshipId?: string;
   needsApproval?: boolean;
   conversationId?: string;
+  inDelegatedAgent?: boolean;
 }
 interface ToolResultData {
   toolName: string;
@@ -121,6 +122,7 @@ interface ToolResultData {
   error?: string;
   relationshipId?: string;
   needsApproval?: boolean;
+  inDelegatedAgent?: boolean;
 }
 interface CompressionEventData {
   reason: 'manual' | 'automatic';
@@ -135,6 +137,7 @@ interface ErrorEventData {
   code?: string;
   severity?: 'error' | 'warning' | 'info';
   context?: any;
+  relationshipId?: string;
 }
 /**
  * Tracks all agent operations and interactions for a single message

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

@@ -345,6 +345,15 @@ var AgentSession = class {
 		this.artifactProcessingErrors.clear();
 		this.artifactCache.clear();
 		if (this.sessionId) toolSessionManager.endSession(this.sessionId);
+		if (this.sessionId) try {
+			const { SandboxExecutorFactory } = await import("../tools/SandboxExecutorFactory.js");
+			await SandboxExecutorFactory.cleanupSession(this.sessionId);
+		} catch (error) {
+			logger.warn({
+				sessionId: this.sessionId,
+				error
+			}, "Failed to cleanup session-scoped sandbox executors");
+		}
 		if (this.scheduledTimeouts) {
 			for (const timeoutId of this.scheduledTimeouts) clearTimeout(timeoutId);
 			this.scheduledTimeouts.clear();
@@ -1120,7 +1129,11 @@ var AgentSessionManager = class {
 	recordEvent(sessionId, eventType, subAgentId, data) {
 		const session = this.sessions.get(sessionId);
 		if (!session) {
-			logger.warn({ sessionId }, "Attempted to record event in non-existent session");
+			logger.warn({
+				sessionId,
+				eventType,
+				subAgentId
+			}, "Attempted to record event in non-existent session (likely session already ended)");
 			return;
 		}
 		session.recordEvent(eventType, subAgentId, data);

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 };

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

@@ -0,0 +1,31 @@
+import { ResolvedRef } from "@inkeep/agents-core";
+import { Context } from "hono";
+
+//#region src/domains/run/services/TriggerService.d.ts
+
+type TriggerWebhookParams = {
+  tenantId: string;
+  projectId: string;
+  agentId: string;
+  triggerId: string;
+  resolvedRef: ResolvedRef;
+  rawBody: string;
+  honoContext: Context;
+};
+type TriggerWebhookResult = {
+  success: true;
+  invocationId: string;
+  conversationId: string;
+} | {
+  success: false;
+  error: string;
+  status: 400 | 401 | 403 | 404 | 422 | 500;
+  validationErrors?: string[];
+};
+/**
+ * Process a trigger webhook request.
+ * Handles validation, transformation, and dispatches async execution.
+ */
+declare function processWebhook(params: TriggerWebhookParams): Promise<TriggerWebhookResult>;
+//#endregion
+export { TriggerWebhookParams, TriggerWebhookResult, processWebhook };