@inkeep/agents-api 0.0.0-dev-20260121145510

package/dist/domains/run/handlers/executionHandler.js

@@ -0,0 +1,485 @@
+import { getLogger as getLogger$1 } from "../../../logger.js";
+import runDbClient_default from "../../../data/db/runDbClient.js";
+import { AGENT_EXECUTION_MAX_CONSECUTIVE_ERRORS } from "../constants/execution-limits/index.js";
+import { tracer } from "../utils/tracer.js";
+import { registerStreamHelper, unregisterStreamHelper } from "../utils/stream-registry.js";
+import { agentSessionManager } from "../services/AgentSession.js";
+import { resolveModelConfig } from "../utils/model-resolver.js";
+import { agentInitializingOp, completionOp, errorOp } from "../utils/agent-operations.js";
+import { A2AClient } from "../a2a/client.js";
+import { flushBatchProcessor } from "../../../instrumentation.js";
+import { triggerConversationEvaluation } from "../../evals/services/conversationEvaluation.js";
+import { extractTransferData, isTransferTask } from "../a2a/types.js";
+import { executeTransfer } from "../a2a/transfer.js";
+import { BufferingStreamHelper } from "../utils/stream-helpers.js";
+import { AGENT_EXECUTION_TRANSFER_COUNT_DEFAULT, createMessage, createTask, generateId, getActiveAgentForConversation, getTask, setSpanWithError, updateTask } from "@inkeep/agents-core";
+
+//#region src/domains/run/handlers/executionHandler.ts
+const logger = getLogger$1("ExecutionHandler");
+var ExecutionHandler = class {
+	MAX_ERRORS = AGENT_EXECUTION_MAX_CONSECUTIVE_ERRORS;
+	/**
+	* performs exeuction loop
+	*
+	* Do up to limit of MAX_ITERATIONS
+	*
+	* 1. lookup active agent for thread
+	* 2. Send A2A message to selected agent
+	* 3. Parse A2A message response
+	* 4. Handle transfer messages (if any)
+	* 5. Handle completion messages (if any)
+	* 6. If no valid response or transfer, return error
+	* @param params
+	* @returns
+	*/
+	async execute(params) {
+		const { executionContext, conversationId, userMessage, messageParts, initialAgentId, requestId, sseHelper, emitOperations, forwardedHeaders } = params;
+		const { tenantId, projectId, project, agentId, apiKey, baseUrl, resolvedRef } = executionContext;
+		registerStreamHelper(requestId, sseHelper);
+		agentSessionManager.createSession(requestId, executionContext, conversationId);
+		if (emitOperations) agentSessionManager.enableEmitOperations(requestId);
+		logger.info({
+			sessionId: requestId,
+			agentId,
+			conversationId,
+			emitOperations
+		}, "Created AgentSession for message execution");
+		const agent = project.agents[agentId];
+		try {
+			if (agent?.statusUpdates && agent.statusUpdates.enabled !== false) try {
+				if (agent?.defaultSubAgentId) {
+					const resolvedModels = await resolveModelConfig(executionContext, agent.subAgents[agent.defaultSubAgentId]);
+					agentSessionManager.initializeStatusUpdates(requestId, agent.statusUpdates, resolvedModels.summarizer, resolvedModels.base);
+				} else agentSessionManager.initializeStatusUpdates(requestId, agent.statusUpdates, agent.models?.summarizer);
+			} catch (modelError) {
+				logger.warn({
+					error: modelError instanceof Error ? modelError.message : "Unknown error",
+					agentId
+				}, "Failed to resolve models for status updates, using agent-level config");
+				agentSessionManager.initializeStatusUpdates(requestId, agent.statusUpdates, agent.models?.summarizer);
+			}
+		} catch (error) {
+			logger.error({
+				error: error instanceof Error ? error.message : "Unknown error",
+				stack: error instanceof Error ? error.stack : void 0
+			}, "❌ Failed to initialize status updates, continuing without them");
+		}
+		let currentAgentId = initialAgentId;
+		let iterations = 0;
+		let errorCount = 0;
+		let task = null;
+		let fromSubAgentId;
+		try {
+			await sseHelper.writeOperation(agentInitializingOp(requestId, agentId));
+			const taskId = `task_${conversationId}-${requestId}`;
+			logger.info({
+				taskId,
+				currentAgentId,
+				conversationId,
+				requestId
+			}, "Attempting to create or reuse existing task");
+			try {
+				task = await createTask(runDbClient_default)({
+					id: taskId,
+					tenantId,
+					projectId,
+					agentId,
+					subAgentId: currentAgentId,
+					contextId: conversationId,
+					status: "pending",
+					ref: resolvedRef,
+					metadata: {
+						conversation_id: conversationId,
+						message_id: requestId,
+						stream_request_id: requestId,
+						created_at: (/* @__PURE__ */ new Date()).toISOString(),
+						updated_at: (/* @__PURE__ */ new Date()).toISOString(),
+						root_sub_agent_id: initialAgentId,
+						sub_agent_id: currentAgentId
+					}
+				});
+				logger.info({
+					taskId,
+					createdTaskMetadata: Array.isArray(task) ? task[0]?.metadata : task?.metadata
+				}, "Task created with metadata");
+			} catch (error) {
+				if (error?.cause?.code === "23505") {
+					logger.info({
+						taskId,
+						error: error.message
+					}, "Task already exists, fetching existing task");
+					const existingTask = await getTask(runDbClient_default)({ id: taskId });
+					if (existingTask) {
+						task = existingTask;
+						logger.info({
+							taskId,
+							existingTask
+						}, "Successfully reused existing task from race condition");
+					} else {
+						logger.error({
+							taskId,
+							error
+						}, "Task constraint failed but task not found");
+						throw error;
+					}
+				} else {
+					logger.error({
+						taskId,
+						error
+					}, "Failed to create task due to non-constraint error");
+					throw error;
+				}
+			}
+			logger.debug({
+				timestamp: /* @__PURE__ */ new Date(),
+				executionType: "create_initial_task",
+				conversationId,
+				agentId,
+				requestId,
+				currentAgentId,
+				taskId: Array.isArray(task) ? task[0]?.id : task?.id,
+				userMessage: userMessage.substring(0, 100)
+			}, "ExecutionHandler: Initial task created");
+			if (Array.isArray(task)) task = task[0];
+			let currentMessage = userMessage;
+			const maxTransfers = agent?.stopWhen?.transferCountIs ?? AGENT_EXECUTION_TRANSFER_COUNT_DEFAULT;
+			while (iterations < maxTransfers) {
+				iterations++;
+				logger.info({
+					iterations,
+					currentAgentId,
+					agentId,
+					conversationId,
+					fromSubAgentId
+				}, `Execution loop iteration ${iterations} with agent ${currentAgentId}, transfer from: ${fromSubAgentId || "none"}`);
+				const activeAgent = await getActiveAgentForConversation(runDbClient_default)({
+					scopes: {
+						tenantId,
+						projectId
+					},
+					conversationId
+				});
+				logger.info({ activeAgent }, "activeAgent");
+				if (activeAgent && activeAgent.activeSubAgentId !== currentAgentId) {
+					currentAgentId = activeAgent.activeSubAgentId;
+					logger.info({ currentAgentId }, `Updated current agent to: ${currentAgentId}`);
+				}
+				const a2aClient = new A2AClient(`${baseUrl}/run/agents`, { headers: {
+					Authorization: `Bearer ${apiKey}`,
+					"x-inkeep-tenant-id": tenantId,
+					"x-inkeep-project-id": projectId,
+					"x-inkeep-agent-id": agentId,
+					"x-inkeep-sub-agent-id": currentAgentId,
+					...forwardedHeaders || {}
+				} });
+				let messageResponse = null;
+				const messageMetadata = {
+					stream_request_id: requestId,
+					forwardedHeaders
+				};
+				if (fromSubAgentId) messageMetadata.fromSubAgentId = fromSubAgentId;
+				const partsToSend = iterations === 1 && messageParts && messageParts.length > 0 ? messageParts : [{
+					kind: "text",
+					text: currentMessage
+				}];
+				messageResponse = await a2aClient.sendMessage({
+					message: {
+						role: "user",
+						parts: partsToSend,
+						messageId: `${requestId}-iter-${iterations}`,
+						kind: "message",
+						contextId: conversationId,
+						metadata: messageMetadata
+					},
+					configuration: {
+						acceptedOutputModes: ["text", "text/plain"],
+						blocking: false
+					}
+				});
+				if (!messageResponse?.result) {
+					errorCount++;
+					logger.error({
+						currentAgentId,
+						iterations,
+						errorCount,
+						hasError: !!messageResponse?.error,
+						errorDetails: messageResponse?.error,
+						fullResponse: messageResponse
+					}, `No response from agent ${currentAgentId} on iteration ${iterations} (error ${errorCount}/${this.MAX_ERRORS})`);
+					if (errorCount >= this.MAX_ERRORS) {
+						const errorMessage$1 = `Maximum error limit (${this.MAX_ERRORS}) reached`;
+						logger.error({
+							maxErrors: this.MAX_ERRORS,
+							errorCount
+						}, errorMessage$1);
+						await sseHelper.writeOperation(errorOp(errorMessage$1, currentAgentId || "system"));
+						if (task) await updateTask(runDbClient_default)({
+							taskId: task.id,
+							data: {
+								status: "failed",
+								metadata: {
+									...task.metadata,
+									failed_at: (/* @__PURE__ */ new Date()).toISOString(),
+									error: errorMessage$1
+								}
+							}
+						});
+						await agentSessionManager.endSession(requestId);
+						unregisterStreamHelper(requestId);
+						return {
+							success: false,
+							error: errorMessage$1,
+							iterations
+						};
+					}
+					continue;
+				}
+				if (isTransferTask(messageResponse.result)) {
+					const transferData = extractTransferData(messageResponse.result);
+					if (!transferData) {
+						logger.error({ result: messageResponse.result }, "Transfer detected but no transfer data found");
+						continue;
+					}
+					const { targetSubAgentId, fromSubAgentId: transferFromAgent } = transferData;
+					const firstArtifact = messageResponse.result.artifacts[0];
+					const transferReason = firstArtifact?.parts[1]?.kind === "text" ? firstArtifact.parts[1].text : "Transfer initiated";
+					logger.info({
+						targetSubAgentId,
+						transferReason,
+						transferFromAgent
+					}, "Transfer response");
+					await createMessage(runDbClient_default)({
+						id: generateId(),
+						tenantId,
+						projectId,
+						conversationId,
+						role: "agent",
+						content: {
+							text: transferReason,
+							parts: [{
+								kind: "text",
+								text: transferReason
+							}]
+						},
+						visibility: "user-facing",
+						messageType: "chat",
+						fromSubAgentId: currentAgentId,
+						taskId: task.id
+					});
+					currentMessage = currentMessage + "\n\nPlease continue this conversation seamlessly. The previous response in conversation history was from another internal agent, but you must continue as if YOU made that response. All responses must appear as one unified agent - do not repeat what was already communicated.";
+					const { success, targetSubAgentId: newAgentId } = await executeTransfer({
+						projectId,
+						tenantId,
+						threadId: conversationId,
+						agentId,
+						targetSubAgentId,
+						ref: resolvedRef
+					});
+					if (success) {
+						fromSubAgentId = currentAgentId;
+						currentAgentId = newAgentId;
+						logger.info({
+							transferFrom: fromSubAgentId,
+							transferTo: currentAgentId,
+							reason: transferReason
+						}, "Transfer executed, tracking fromSubAgentId for next iteration");
+					}
+					continue;
+				}
+				let responseParts = [];
+				if (messageResponse.result.streamedContent?.parts) {
+					responseParts = messageResponse.result.streamedContent.parts;
+					logger.info({ partsCount: responseParts.length }, "Using streamed content for conversation history");
+				} else {
+					responseParts = messageResponse.result.artifacts?.flatMap((artifact) => artifact.parts || []) || [];
+					logger.info({ partsCount: responseParts.length }, "Using artifacts for conversation history (fallback)");
+				}
+				if (responseParts && responseParts.length > 0) {
+					const agentSessionData = agentSessionManager.getSession(requestId);
+					if (agentSessionData) {
+						const sessionSummary = agentSessionData.getSummary();
+						logger.info(sessionSummary, "AgentSession data after completion");
+					}
+					let textContent = "";
+					for (const part of responseParts) if ((part.kind === "text" || part.type === "text") && part.text) textContent += part.text;
+					return tracer.startActiveSpan("execution_handler.execute", {}, async (span) => {
+						try {
+							span.setAttributes({
+								"ai.response.content": textContent || "No response content",
+								"ai.response.timestamp": (/* @__PURE__ */ new Date()).toISOString(),
+								"subAgent.name": agent?.subAgents[currentAgentId]?.name,
+								"subAgent.id": currentAgentId
+							});
+							await createMessage(runDbClient_default)({
+								id: generateId(),
+								tenantId,
+								projectId,
+								conversationId,
+								role: "agent",
+								content: {
+									text: textContent || void 0,
+									parts: responseParts.map((part) => ({
+										type: part.kind === "text" ? "text" : "data",
+										text: part.kind === "text" ? part.text : void 0,
+										data: part.kind === "data" ? JSON.stringify(part.data) : void 0
+									}))
+								},
+								visibility: "user-facing",
+								messageType: "chat",
+								fromSubAgentId: currentAgentId,
+								taskId: task.id
+							});
+							const updateTaskStart = Date.now();
+							await updateTask(runDbClient_default)({
+								taskId: task.id,
+								data: {
+									status: "completed",
+									metadata: {
+										...task.metadata,
+										completed_at: /* @__PURE__ */ new Date(),
+										response: {
+											text: textContent,
+											parts: responseParts,
+											hasText: !!textContent,
+											hasData: responseParts.some((p) => p.kind === "data")
+										}
+									}
+								}
+							});
+							const updateTaskEnd = Date.now();
+							logger.info({ duration: updateTaskEnd - updateTaskStart }, "Completed updateTask operation");
+							await sseHelper.writeOperation(completionOp(currentAgentId, iterations));
+							await sseHelper.complete();
+							logger.info({}, "Ending AgentSession and cleaning up");
+							await agentSessionManager.endSession(requestId);
+							logger.info({}, "Cleaning up streamHelper");
+							unregisterStreamHelper(requestId);
+							let response;
+							if (sseHelper instanceof BufferingStreamHelper) response = sseHelper.getCapturedResponse().text || "No response content";
+							logger.info({}, "ExecutionHandler returning success");
+							if (!params.datasetRunId) triggerConversationEvaluation({
+								tenantId,
+								projectId,
+								conversationId,
+								resolvedRef
+							}).catch((error) => {
+								logger.error({
+									error,
+									conversationId,
+									tenantId,
+									projectId,
+									resolvedRef
+								}, "Failed to trigger conversation evaluation (non-blocking)");
+							});
+							return {
+								success: true,
+								iterations,
+								response
+							};
+						} catch (error) {
+							setSpanWithError(span, error instanceof Error ? error : new Error(String(error)));
+							throw error;
+						} finally {
+							span.end();
+							await new Promise((resolve) => setImmediate(resolve));
+							await flushBatchProcessor();
+						}
+					});
+				}
+				errorCount++;
+				logger.warn({
+					iterations,
+					errorCount
+				}, `No valid response or transfer on iteration ${iterations} (error ${errorCount}/${this.MAX_ERRORS})`);
+				if (errorCount >= this.MAX_ERRORS) {
+					const errorMessage$1 = `Maximum error limit (${this.MAX_ERRORS}) reached`;
+					logger.error({
+						maxErrors: this.MAX_ERRORS,
+						errorCount
+					}, errorMessage$1);
+					await sseHelper.writeOperation(errorOp(errorMessage$1, currentAgentId || "system"));
+					if (task) await updateTask(runDbClient_default)({
+						taskId: task.id,
+						data: {
+							status: "failed",
+							metadata: {
+								...task.metadata,
+								failed_at: /* @__PURE__ */ new Date(),
+								error: errorMessage$1
+							}
+						}
+					});
+					await agentSessionManager.endSession(requestId);
+					unregisterStreamHelper(requestId);
+					if (!params.datasetRunId) triggerConversationEvaluation({
+						tenantId,
+						projectId,
+						conversationId,
+						resolvedRef
+					}).catch((error) => {
+						logger.error({
+							error,
+							conversationId,
+							tenantId,
+							projectId
+						}, "Failed to trigger conversation evaluation (non-blocking)");
+					});
+					return {
+						success: false,
+						error: errorMessage$1,
+						iterations
+					};
+				}
+			}
+			const errorMessage = `Maximum transfer limit (${maxTransfers}) reached without completion`;
+			logger.error({
+				maxTransfers,
+				iterations
+			}, errorMessage);
+			await sseHelper.writeOperation(errorOp(errorMessage, currentAgentId || "system"));
+			if (task) await updateTask(runDbClient_default)({
+				taskId: task.id,
+				data: {
+					status: "failed",
+					metadata: {
+						...task.metadata,
+						failed_at: /* @__PURE__ */ new Date(),
+						error: errorMessage
+					}
+				}
+			});
+			await agentSessionManager.endSession(requestId);
+			unregisterStreamHelper(requestId);
+			return {
+				success: false,
+				error: errorMessage,
+				iterations
+			};
+		} catch (error) {
+			logger.error({ error }, "Error in execution handler");
+			const errorMessage = error instanceof Error ? error.message : "Unknown execution error";
+			await sseHelper.writeOperation(errorOp(`Execution error: ${errorMessage}`, currentAgentId || "system"));
+			if (task) await updateTask(runDbClient_default)({
+				taskId: task.id,
+				data: {
+					status: "failed",
+					metadata: {
+						...task.metadata,
+						failed_at: /* @__PURE__ */ new Date(),
+						error: errorMessage
+					}
+				}
+			});
+			await agentSessionManager.endSession(requestId);
+			unregisterStreamHelper(requestId);
+			return {
+				success: false,
+				error: errorMessage,
+				iterations
+			};
+		}
+	}
+};
+
+//#endregion
+export { ExecutionHandler };

package/dist/domains/run/index.d.ts

@@ -0,0 +1,13 @@
+import { AppVariables } from "../../types/app.js";
+import "../../types/index.js";
+import { OpenAPIHono } from "@hono/zod-openapi";
+
+//#region src/domains/run/index.d.ts
+declare function createRunRoutes(): OpenAPIHono<{
+  Variables: AppVariables;
+}, {}, "/">;
+declare const runRoutes: OpenAPIHono<{
+  Variables: AppVariables;
+}, {}, "/">;
+//#endregion
+export { createRunRoutes, runRoutes };

package/dist/domains/run/index.js

@@ -0,0 +1,21 @@
+import agents_default from "./routes/agents.js";
+import chat_default from "./routes/chat.js";
+import chatDataStream_default from "./routes/chatDataStream.js";
+import mcp_default from "./routes/mcp.js";
+import webhooks_default from "./routes/webhooks.js";
+import { OpenAPIHono } from "@hono/zod-openapi";
+
+//#region src/domains/run/index.ts
+function createRunRoutes() {
+	const app = new OpenAPIHono();
+	app.route("/v1/chat", chat_default);
+	app.route("/api", chatDataStream_default);
+	app.route("/v1/mcp", mcp_default);
+	app.route("/agents", agents_default);
+	app.route("/", webhooks_default);
+	return app;
+}
+const runRoutes = createRunRoutes();
+
+//#endregion
+export { createRunRoutes, runRoutes };

package/dist/domains/run/routes/agents.d.ts

@@ -0,0 +1,13 @@
+import { OpenAPIHono } from "@hono/zod-openapi";
+import { CredentialStoreRegistry, ResolvedRef } from "@inkeep/agents-core";
+
+//#region src/domains/run/routes/agents.d.ts
+type AppVariables = {
+  credentialStores: CredentialStoreRegistry;
+  ref: ResolvedRef;
+};
+declare const app: OpenAPIHono<{
+  Variables: AppVariables;
+}, {}, "/">;
+//#endregion
+export { app as default };

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

@@ -0,0 +1,141 @@
+import { getLogger as getLogger$1 } from "../../../logger.js";
+import { a2aHandler } from "../a2a/handlers.js";
+import { getRegisteredAgent } from "../data/agents.js";
+import { OpenAPIHono, createRoute, z } from "@hono/zod-openapi";
+import { HeadersScopeSchema, createApiError } from "@inkeep/agents-core";
+
+//#region src/domains/run/routes/agents.ts
+const app = new OpenAPIHono();
+const logger = getLogger$1("agents");
+app.openapi(createRoute({
+	method: "get",
+	path: "/.well-known/agent.json",
+	request: { headers: HeadersScopeSchema },
+	tags: ["a2a"],
+	security: [{ bearerAuth: [] }],
+	responses: {
+		200: {
+			description: "Agent Card for A2A discovery",
+			content: { "application/json": { schema: z.object({
+				name: z.string(),
+				description: z.string().optional(),
+				url: z.string(),
+				version: z.string(),
+				defaultInputModes: z.array(z.string()),
+				defaultOutputModes: z.array(z.string()),
+				skills: z.array(z.any())
+			}) } }
+		},
+		404: { description: "Agent not found" }
+	}
+}), async (c) => {
+	const otelHeaders = {
+		traceparent: c.req.header("traceparent"),
+		tracestate: c.req.header("tracestate"),
+		baggage: c.req.header("baggage")
+	};
+	logger.info({
+		otelHeaders,
+		path: c.req.path,
+		method: c.req.method
+	}, "OpenTelemetry headers: well-known agent.json");
+	const executionContext = c.get("executionContext");
+	const { tenantId, projectId, agentId, subAgentId } = executionContext;
+	logger.info({
+		message: "getRegisteredAgent (agent-level)",
+		tenantId,
+		projectId,
+		agentId,
+		subAgentId
+	}, "agent-level well-known agent.json");
+	const agent = await getRegisteredAgent({
+		executionContext,
+		credentialStoreRegistry: c.get("credentialStores"),
+		sandboxConfig: c.get("sandboxConfig")
+	});
+	logger.info({ agent }, "agent registered: well-known agent.json");
+	if (!agent) throw createApiError({
+		code: "not_found",
+		message: "Agent not found"
+	});
+	return c.json(agent.agentCard);
+});
+app.post("/a2a", async (c) => {
+	const otelHeaders = {
+		traceparent: c.req.header("traceparent"),
+		tracestate: c.req.header("tracestate"),
+		baggage: c.req.header("baggage")
+	};
+	logger.info({
+		otelHeaders,
+		path: c.req.path,
+		method: c.req.method
+	}, "OpenTelemetry headers: a2a");
+	const executionContext = c.get("executionContext");
+	const { tenantId, projectId, agentId, subAgentId, project } = executionContext;
+	if (subAgentId) {
+		logger.info({
+			message: "a2a (agent-level)",
+			tenantId,
+			projectId,
+			agentId,
+			subAgentId
+		}, "agent-level a2a endpoint");
+		const agent$1 = await getRegisteredAgent({
+			executionContext,
+			credentialStoreRegistry: c.get("credentialStores"),
+			sandboxConfig: c.get("sandboxConfig")
+		});
+		if (!agent$1) return c.json({
+			jsonrpc: "2.0",
+			error: {
+				code: -32004,
+				message: "Agent not found"
+			},
+			id: null
+		}, 404);
+		return a2aHandler(c, agent$1);
+	}
+	logger.info({
+		message: "a2a (agent-level)",
+		tenantId,
+		projectId,
+		agentId
+	}, "agent-level a2a endpoint");
+	const agent = project.agents[agentId];
+	if (!agent) return c.json({
+		jsonrpc: "2.0",
+		error: {
+			code: -32004,
+			message: "Agent not found"
+		},
+		id: null
+	}, 404);
+	if (!agent.defaultSubAgentId) return c.json({
+		jsonrpc: "2.0",
+		error: {
+			code: -32004,
+			message: "Agent does not have a default agent configured"
+		},
+		id: null
+	}, 400);
+	executionContext.subAgentId = agent.defaultSubAgentId;
+	const defaultSubAgent = await getRegisteredAgent({
+		executionContext,
+		credentialStoreRegistry: c.get("credentialStores"),
+		sandboxConfig: c.get("sandboxConfig")
+	});
+	if (!defaultSubAgent) return c.json({
+		jsonrpc: "2.0",
+		error: {
+			code: -32004,
+			message: "Agent not found"
+		},
+		id: null
+	}, 404);
+	return a2aHandler(c, defaultSubAgent);
+});
+var agents_default = app;
+
+//#endregion
+export { agents_default as default };

package/dist/domains/run/routes/chat.d.ts

@@ -0,0 +1,14 @@
+import { OpenAPIHono } from "@hono/zod-openapi";
+import { CredentialStoreRegistry, FullExecutionContext } from "@inkeep/agents-core";
+
+//#region src/domains/run/routes/chat.d.ts
+type AppVariables = {
+  credentialStores: CredentialStoreRegistry;
+  executionContext: FullExecutionContext;
+  requestBody?: any;
+};
+declare const app: OpenAPIHono<{
+  Variables: AppVariables;
+}, {}, "/">;
+//#endregion
+export { app as default };