@inkeep/agents-api 0.0.0-dev-20260121145510

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

@@ -0,0 +1,416 @@
+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 { 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 });
+/**
+* Webhook endpoint for trigger invocation
+* 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"],
+	summary: "Invoke agent via trigger webhook",
+	description: "Webhook endpoint for third-party services to invoke an agent via a configured trigger",
+	request: {
+		params: z.object({
+			tenantId: z.string().describe("Tenant ID"),
+			projectId: z.string().describe("Project ID"),
+			agentId: z.string().describe("Agent ID"),
+			triggerId: z.string().describe("Trigger ID")
+		}),
+		body: { content: { "application/json": { schema: z.record(z.string(), z.unknown()).describe("Webhook payload") } } }
+	},
+	responses: {
+		202: {
+			description: "Webhook accepted and trigger invoked",
+			content: { "application/json": { schema: z.object({
+				success: z.boolean(),
+				invocationId: z.string()
+			}) } }
+		},
+		400: {
+			description: "Invalid request payload",
+			content: { "application/json": { schema: z.object({
+				error: z.string(),
+				validationErrors: z.array(z.string()).optional()
+			}) } }
+		},
+		401: {
+			description: "Missing authentication credentials",
+			content: { "application/json": { schema: z.object({ error: z.string() }) } }
+		},
+		403: {
+			description: "Invalid authentication credentials or signature",
+			content: { "application/json": { schema: z.object({ error: z.string() }) } }
+		},
+		404: {
+			description: "Trigger not found or disabled",
+			content: { "application/json": { schema: z.object({ error: z.string() }) } }
+		},
+		422: {
+			description: "Payload transformation failed",
+			content: { "application/json": { schema: z.object({ error: z.string() }) } }
+		}
+	}
+});
+app.openapi(triggerWebhookRoute, async (c) => {
+	const { tenantId, projectId, agentId, triggerId } = c.req.param();
+	const resolvedRef = c.get("resolvedRef");
+	logger.info({
+		tenantId,
+		projectId,
+		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;
+	}
+});
+/**
+* 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.parts.count": messageParts.length,
+		"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
+export { webhooks_default as default };