@inkeep/agents-run-api 0.39.4 → 0.40.0

package/dist/handlers/executionHandler.js

@@ -0,0 +1,456 @@
+import { getLogger } from "../logger.js";
+import { flushBatchProcessor } from "../instrumentation.js";
+import dbClient_default from "../data/db/dbClient.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 { 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, getAgentWithDefaultSubAgent, getFullAgent, getTask, setSpanWithError, updateTask } from "@inkeep/agents-core";
+
+//#region src/handlers/executionHandler.ts
+const logger = getLogger("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, initialAgentId, requestId, sseHelper, emitOperations } = params;
+		const { tenantId, projectId, agentId, apiKey, baseUrl } = executionContext;
+		registerStreamHelper(requestId, sseHelper);
+		agentSessionManager.createSession(requestId, agentId, tenantId, projectId, conversationId);
+		if (emitOperations) agentSessionManager.enableEmitOperations(requestId);
+		logger.info({
+			sessionId: requestId,
+			agentId,
+			conversationId,
+			emitOperations
+		}, "Created AgentSession for message execution");
+		let agentConfig = null;
+		try {
+			agentConfig = await getFullAgent(dbClient_default)({ scopes: {
+				tenantId,
+				projectId,
+				agentId
+			} });
+			if (agentConfig?.statusUpdates && agentConfig.statusUpdates.enabled !== false) try {
+				const agentWithDefault = await getAgentWithDefaultSubAgent(dbClient_default)({ scopes: {
+					tenantId,
+					projectId,
+					agentId
+				} });
+				if (agentWithDefault?.defaultSubAgent) {
+					const resolvedModels = await resolveModelConfig(agentId, agentWithDefault.defaultSubAgent);
+					agentSessionManager.initializeStatusUpdates(requestId, agentConfig.statusUpdates, resolvedModels.summarizer, resolvedModels.base);
+				} else agentSessionManager.initializeStatusUpdates(requestId, agentConfig.statusUpdates, agentConfig.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, agentConfig.statusUpdates, agentConfig.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(dbClient_default)({
+					id: taskId,
+					tenantId,
+					projectId,
+					agentId,
+					subAgentId: currentAgentId,
+					contextId: conversationId,
+					status: "pending",
+					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(dbClient_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 = agentConfig?.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(dbClient_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}/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
+				} });
+				let messageResponse = null;
+				const messageMetadata = { stream_request_id: requestId };
+				if (fromSubAgentId) messageMetadata.fromSubAgentId = fromSubAgentId;
+				messageResponse = await a2aClient.sendMessage({
+					message: {
+						role: "user",
+						parts: [{
+							kind: "text",
+							text: currentMessage
+						}],
+						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
+					}, `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(dbClient_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(dbClient_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,
+						targetSubAgentId
+					});
+					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": agentConfig?.subAgents[currentAgentId]?.name,
+								"subAgent.id": currentAgentId
+							});
+							await createMessage(dbClient_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(dbClient_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");
+							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(dbClient_default)({
+						taskId: task.id,
+						data: {
+							status: "failed",
+							metadata: {
+								...task.metadata,
+								failed_at: /* @__PURE__ */ new Date(),
+								error: errorMessage$1
+							}
+						}
+					});
+					await agentSessionManager.endSession(requestId);
+					unregisterStreamHelper(requestId);
+					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(dbClient_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(dbClient_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/index.d.ts

@@ -1,37 +1,16 @@
-import { z } from "@hono/zod-openapi";
-import { CredentialStore, CredentialStoreRegistry, ServerConfig } from "@inkeep/agents-core";
-import * as hono0 from "hono";
+import { NativeSandboxConfig, SandboxConfig, VercelSandboxConfig } from "./types/execution-context.js";
+import { createExecutionHono } from "./create-app.js";
+import "./env.js";
+import { CredentialStore, ServerConfig } from "@inkeep/agents-core";
 import { Hono } from "hono";
-import * as hono_types3 from "hono/types";
+import * as hono_types1 from "hono/types";
 
-//#region src/types/execution-context.d.ts
-
-interface CommonSandboxConfig {
-  runtime: 'node22' | 'typescript';
-  timeout?: number;
-  vcpus?: number;
-}
-interface NativeSandboxConfig extends CommonSandboxConfig {
-  provider: 'native';
-}
-interface VercelSandboxConfig extends CommonSandboxConfig {
-  provider: 'vercel';
-  teamId: string;
-  projectId: string;
-  token: string;
-}
-type SandboxConfig = NativeSandboxConfig | VercelSandboxConfig;
-//#endregion
-//#region src/app.d.ts
-declare function createExecutionHono(serverConfig: ServerConfig, credentialStores: CredentialStoreRegistry, sandboxConfig?: SandboxConfig): Hono<hono_types3.BlankEnv, hono_types3.BlankSchema, "/">;
-//#endregion
 //#region src/index.d.ts
-declare const app: hono0.Hono<hono_types3.BlankEnv, hono_types3.BlankSchema, "/">;
+declare const app: Hono<hono_types1.BlankEnv, hono_types1.BlankSchema, "/">;
 declare function createExecutionApp(config?: {
   serverConfig?: ServerConfig;
   credentialStores?: CredentialStore[];
   sandboxConfig?: SandboxConfig;
-}): hono0.Hono<hono_types3.BlankEnv, hono_types3.BlankSchema, "/">;
+}): Hono<hono_types1.BlankEnv, hono_types1.BlankSchema, "/">;
 //#endregion
-export { type NativeSandboxConfig, type SandboxConfig, type VercelSandboxConfig, createExecutionApp, createExecutionHono, app as default };
-//# sourceMappingURL=index.d.ts.map
+export { Hono, type NativeSandboxConfig, type SandboxConfig, type VercelSandboxConfig, createExecutionApp, createExecutionHono, app as default };