@inkeep/agents-api 0.0.0-dev-20260122085034 → 0.0.0-dev-20260122090358

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

@@ -0,0 +1,377 @@
+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 { JsonTransformer, createMessage, createOrGetConversation, createTriggerInvocation, generateId, getConversationId, getFullProjectWithRelationIds, getTriggerById, interpolateTemplate, setActiveAgentForConversation, updateTriggerInvocationStatus, verifySigningSecret, verifyTriggerAuth, withRef } from "@inkeep/agents-core";
+import Ajv from "ajv";
+
+//#region src/domains/run/services/TriggerService.ts
+const logger = getLogger$1("TriggerService");
+const ajv = new Ajv({ allErrors: true });
+/**
+* Process a trigger webhook request.
+* Handles validation, transformation, and dispatches async execution.
+*/
+async function processWebhook(params) {
+	const { tenantId, projectId, agentId, triggerId, resolvedRef, rawBody, honoContext } = params;
+	const trigger = await loadTrigger({
+		tenantId,
+		projectId,
+		agentId,
+		triggerId,
+		resolvedRef
+	});
+	if (!trigger) return {
+		success: false,
+		error: `Trigger ${triggerId} not found`,
+		status: 404
+	};
+	if (!trigger.enabled) return {
+		success: false,
+		error: "Trigger is disabled",
+		status: 404
+	};
+	const payload = rawBody ? JSON.parse(rawBody) : {};
+	const authResult = await verifyAuthentication(trigger, honoContext);
+	if (!authResult.success) return authResult;
+	const signatureResult = verifySignature(trigger, honoContext, rawBody);
+	if (!signatureResult.success) return signatureResult;
+	const validationResult = validatePayload(trigger, payload);
+	if (!validationResult.success) return validationResult;
+	const transformResult = await transformPayload(trigger, payload, {
+		tenantId,
+		projectId,
+		triggerId
+	});
+	if (!transformResult.success) return transformResult;
+	const transformedPayload = transformResult.payload;
+	const { messageParts, userMessageText } = buildMessage(trigger, transformedPayload, triggerId);
+	const { invocationId, conversationId } = await dispatchExecution({
+		tenantId,
+		projectId,
+		agentId,
+		triggerId,
+		resolvedRef,
+		payload,
+		transformedPayload,
+		messageParts,
+		userMessageText
+	});
+	return {
+		success: true,
+		invocationId,
+		conversationId
+	};
+}
+async function loadTrigger(params) {
+	const { tenantId, projectId, agentId, triggerId, resolvedRef } = params;
+	return await withRef(manageDbPool_default, resolvedRef, (db) => getTriggerById(db)({
+		scopes: {
+			tenantId,
+			projectId,
+			agentId
+		},
+		triggerId
+	}));
+}
+async function verifyAuthentication(trigger, honoContext) {
+	if (!trigger.authentication) return { success: true };
+	const authResult = await verifyTriggerAuth(honoContext, trigger.authentication);
+	if (!authResult.success) {
+		if (authResult.status === 401) return {
+			success: false,
+			error: authResult.message || "Unauthorized",
+			status: 401
+		};
+		return {
+			success: false,
+			error: authResult.message || "Forbidden",
+			status: 403
+		};
+	}
+	return { success: true };
+}
+function verifySignature(trigger, honoContext, rawBody) {
+	if (!trigger.signingSecret) return { success: true };
+	const signatureResult = verifySigningSecret(honoContext, trigger.signingSecret, rawBody);
+	if (!signatureResult.success) return {
+		success: false,
+		error: signatureResult.message || "Invalid signature",
+		status: 403
+	};
+	return { success: true };
+}
+function validatePayload(trigger, payload) {
+	if (!trigger.inputSchema) return { success: true };
+	const validate = ajv.compile(trigger.inputSchema);
+	if (!validate(payload)) return {
+		success: false,
+		error: "Payload validation failed",
+		status: 400,
+		validationErrors: validate.errors?.map((err) => `${err.instancePath} ${err.message}`)
+	};
+	return { success: true };
+}
+async function transformPayload(trigger, payload, context) {
+	if (!trigger.outputTransform) return {
+		success: true,
+		payload
+	};
+	try {
+		const transformedPayload = await JsonTransformer.transformWithConfig(payload, trigger.outputTransform);
+		logger.debug(context, "Payload transformation successful");
+		return {
+			success: true,
+			payload: transformedPayload
+		};
+	} catch (error) {
+		const errorMessage = error instanceof Error ? error.message : String(error);
+		logger.error({
+			...context,
+			error: errorMessage
+		}, "Payload transformation failed");
+		return {
+			success: false,
+			error: `Payload transformation failed: ${errorMessage}`,
+			status: 422
+		};
+	}
+}
+function buildMessage(trigger, transformedPayload, triggerId) {
+	const messageParts = [];
+	if (trigger.messageTemplate) {
+		const payloadForTemplate = typeof transformedPayload === "object" && transformedPayload !== null && !Array.isArray(transformedPayload) ? transformedPayload : {};
+		const interpolatedMessage = interpolateTemplate(trigger.messageTemplate, payloadForTemplate);
+		messageParts.push({
+			kind: "text",
+			text: interpolatedMessage
+		});
+	}
+	if (transformedPayload != null) messageParts.push({
+		kind: "data",
+		data: transformedPayload,
+		metadata: {
+			source: "trigger",
+			triggerId
+		}
+	});
+	return {
+		messageParts,
+		userMessageText: trigger.messageTemplate ? (() => {
+			const payloadForTemplate = typeof transformedPayload === "object" && transformedPayload !== null && !Array.isArray(transformedPayload) ? transformedPayload : {};
+			return interpolateTemplate(trigger.messageTemplate, payloadForTemplate);
+		})() : JSON.stringify(transformedPayload)
+	};
+}
+async function dispatchExecution(params) {
+	const { tenantId, projectId, agentId, triggerId, resolvedRef, payload, transformedPayload, messageParts, userMessageText } = params;
+	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");
+	const executionPromise = executeAgentAsync({
+		tenantId,
+		projectId,
+		agentId,
+		triggerId,
+		invocationId,
+		conversationId,
+		userMessage: userMessageText,
+		messageParts,
+		resolvedRef
+	});
+	if (process.env.VERCEL) import("@vercel/functions").then(({ waitUntil }) => {
+		waitUntil(executionPromise);
+	}).catch((err) => {
+		logger.error({ err }, "Failed to import @vercel/functions");
+	});
+	else executionPromise.catch((error) => {
+		const errorMessage = error instanceof Error ? error.message : String(error);
+		const errorStack = error instanceof Error ? error.stack : void 0;
+		logger.error({
+			err: errorMessage,
+			errorStack,
+			tenantId,
+			projectId,
+			agentId,
+			triggerId,
+			invocationId
+		}, "Background trigger execution failed");
+	});
+	logger.info({
+		tenantId,
+		projectId,
+		agentId,
+		triggerId,
+		invocationId,
+		conversationId
+	}, "Async execution dispatched");
+	return {
+		invocationId,
+		conversationId
+	};
+}
+/**
+* Execute the agent asynchronously.
+* This runs after the webhook response is sent.
+*/
+async function executeAgentAsync(params) {
+	const { tenantId, projectId, agentId, triggerId, invocationId, conversationId, userMessage, messageParts, resolvedRef } = params;
+	logger.info({
+		tenantId,
+		projectId,
+		agentId,
+		triggerId,
+		invocationId,
+		conversationId
+	}, "Starting async trigger execution");
+	try {
+		const project = await withRef(manageDbPool_default, resolvedRef, async (db) => {
+			return await getFullProjectWithRelationIds(db)({ scopes: {
+				tenantId,
+				projectId
+			} });
+		});
+		if (!project) throw new Error(`Project ${projectId} not found`);
+		const agent = project.agents?.[agentId];
+		if (!agent) throw new Error(`Agent ${agentId} not found in project`);
+		const defaultSubAgentId = agent.defaultSubAgentId;
+		if (!defaultSubAgentId) throw new Error(`Agent ${agentId} has no default sub-agent configured`);
+		await createOrGetConversation(runDbClient_default)({
+			id: conversationId,
+			tenantId,
+			projectId,
+			agentId,
+			activeSubAgentId: defaultSubAgentId,
+			ref: resolvedRef
+		});
+		await setActiveAgentForConversation(runDbClient_default)({
+			scopes: {
+				tenantId,
+				projectId
+			},
+			conversationId,
+			subAgentId: defaultSubAgentId,
+			agentId,
+			ref: resolvedRef
+		});
+		await createMessage(runDbClient_default)({
+			id: generateId(),
+			tenantId,
+			projectId,
+			conversationId,
+			role: "user",
+			content: {
+				text: userMessage,
+				parts: messageParts
+			},
+			metadata: { a2a_metadata: {
+				triggerId,
+				invocationId
+			} }
+		});
+		const executionContext = {
+			tenantId,
+			projectId,
+			agentId,
+			baseUrl: env.INKEEP_AGENTS_API_URL || "http://localhost:3002",
+			apiKey: env.INKEEP_AGENTS_RUN_API_BYPASS_SECRET || "",
+			apiKeyId: "trigger-invocation",
+			resolvedRef,
+			project,
+			metadata: { initiatedBy: {
+				type: "api_key",
+				id: triggerId
+			} }
+		};
+		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
+		}, "Async trigger execution completed successfully");
+	} catch (error) {
+		const errorMessage = error instanceof Error ? error.message : String(error);
+		const errorStack = error instanceof Error ? error.stack : void 0;
+		logger.error({
+			err: errorMessage,
+			errorStack,
+			tenantId,
+			projectId,
+			agentId,
+			triggerId,
+			invocationId
+		}, "Async trigger execution failed");
+		try {
+			await updateTriggerInvocationStatus(runDbClient_default)({
+				scopes: {
+					tenantId,
+					projectId,
+					agentId
+				},
+				triggerId,
+				invocationId,
+				data: {
+					status: "failed",
+					errorMessage
+				}
+			});
+		} catch (updateError) {
+			const updateErrorMessage = updateError instanceof Error ? updateError.message : String(updateError);
+			logger.error({
+				err: updateErrorMessage,
+				invocationId
+			}, "Failed to update invocation status to failed");
+		}
+		throw error;
+	}
+}
+
+//#endregion
+export { processWebhook };