@inkeep/agents-run-api 0.39.5 → 0.41.0

package/dist/agents/generateTaskHandler.js

@@ -0,0 +1,523 @@
+import { getLogger } from "../logger.js";
+import dbClient_default from "../data/db/dbClient.js";
+import { toolSessionManager } from "./ToolSessionManager.js";
+import { agentSessionManager } from "../services/AgentSession.js";
+import { resolveModelConfig } from "../utils/model-resolver.js";
+import { Agent } from "./Agent.js";
+import { generateDescriptionWithRelationData } from "../data/agents.js";
+import { TaskState, dbResultToMcpTool, generateId, getAgentById, getAgentWithDefaultSubAgent, getArtifactComponentsForAgent, getDataComponentsForAgent, getExternalAgentsForSubAgent, getRelatedAgentsForAgent, getSubAgentById, getTeamAgentsForSubAgent, getToolsForAgent } from "@inkeep/agents-core";
+
+//#region src/agents/generateTaskHandler.ts
+const logger = getLogger("generateTaskHandler");
+const createTaskHandler = (config, credentialStoreRegistry) => {
+	return async (task) => {
+		let agent;
+		try {
+			const userMessage = task.input.parts.filter((part) => part.text).map((part) => part.text).join(" ");
+			if (!userMessage.trim()) return {
+				status: {
+					state: TaskState.Failed,
+					message: "No text content found in task input"
+				},
+				artifacts: []
+			};
+			const forwardedHeaders = task.context?.metadata?.forwardedHeaders;
+			const [internalRelations, externalRelations, teamRelations, toolsForAgent, dataComponents, artifactComponents] = await Promise.all([
+				getRelatedAgentsForAgent(dbClient_default)({
+					scopes: {
+						tenantId: config.tenantId,
+						projectId: config.projectId,
+						agentId: config.agentId
+					},
+					subAgentId: config.subAgentId
+				}),
+				getExternalAgentsForSubAgent(dbClient_default)({ scopes: {
+					tenantId: config.tenantId,
+					projectId: config.projectId,
+					agentId: config.agentId,
+					subAgentId: config.subAgentId
+				} }),
+				getTeamAgentsForSubAgent(dbClient_default)({ scopes: {
+					tenantId: config.tenantId,
+					projectId: config.projectId,
+					agentId: config.agentId,
+					subAgentId: config.subAgentId
+				} }),
+				getToolsForAgent(dbClient_default)({ scopes: {
+					tenantId: config.tenantId,
+					projectId: config.projectId,
+					agentId: config.agentId,
+					subAgentId: config.subAgentId
+				} }),
+				getDataComponentsForAgent(dbClient_default)({ scopes: {
+					tenantId: config.tenantId,
+					projectId: config.projectId,
+					agentId: config.agentId,
+					subAgentId: config.subAgentId
+				} }),
+				getArtifactComponentsForAgent(dbClient_default)({ scopes: {
+					tenantId: config.tenantId,
+					projectId: config.projectId,
+					agentId: config.agentId,
+					subAgentId: config.subAgentId
+				} })
+			]);
+			const enhancedInternalRelations = await Promise.all(internalRelations.data.map(async (relation) => {
+				try {
+					if (await getSubAgentById(dbClient_default)({
+						scopes: {
+							tenantId: config.tenantId,
+							projectId: config.projectId,
+							agentId: config.agentId
+						},
+						subAgentId: relation.id
+					})) {
+						const relatedAgentRelations = await getRelatedAgentsForAgent(dbClient_default)({
+							scopes: {
+								tenantId: config.tenantId,
+								projectId: config.projectId,
+								agentId: config.agentId
+							},
+							subAgentId: relation.id
+						});
+						const relatedAgentExternalAgentRelations = await getExternalAgentsForSubAgent(dbClient_default)({ scopes: {
+							tenantId: config.tenantId,
+							projectId: config.projectId,
+							agentId: config.agentId,
+							subAgentId: relation.id
+						} });
+						const relatedAgentTeamAgentRelations = await getTeamAgentsForSubAgent(dbClient_default)({ scopes: {
+							tenantId: config.tenantId,
+							projectId: config.projectId,
+							agentId: config.agentId,
+							subAgentId: relation.id
+						} });
+						const enhancedDescription = generateDescriptionWithRelationData(relation.description || "", relatedAgentRelations.data, relatedAgentExternalAgentRelations.data, relatedAgentTeamAgentRelations.data);
+						return {
+							...relation,
+							description: enhancedDescription
+						};
+					}
+				} catch (error) {
+					logger.warn({
+						subAgentId: relation.id,
+						error
+					}, "Failed to enhance agent description");
+				}
+				return relation;
+			}));
+			const enhancedTeamRelations = await Promise.all(teamRelations.data.map(async (relation) => {
+				try {
+					const teamAgentWithDefault = await getAgentWithDefaultSubAgent(dbClient_default)({ scopes: {
+						tenantId: config.tenantId,
+						projectId: config.projectId,
+						agentId: relation.targetAgentId
+					} });
+					if (teamAgentWithDefault?.defaultSubAgent) {
+						const defaultSubAgent = teamAgentWithDefault.defaultSubAgent;
+						const relatedAgentRelations = await getRelatedAgentsForAgent(dbClient_default)({
+							scopes: {
+								tenantId: config.tenantId,
+								projectId: config.projectId,
+								agentId: relation.targetAgentId
+							},
+							subAgentId: defaultSubAgent.id
+						});
+						const relatedAgentExternalAgentRelations = await getExternalAgentsForSubAgent(dbClient_default)({ scopes: {
+							tenantId: config.tenantId,
+							projectId: config.projectId,
+							agentId: relation.targetAgentId,
+							subAgentId: defaultSubAgent.id
+						} });
+						const relatedAgentTeamAgentRelations = await getTeamAgentsForSubAgent(dbClient_default)({ scopes: {
+							tenantId: config.tenantId,
+							projectId: config.projectId,
+							agentId: relation.targetAgentId,
+							subAgentId: defaultSubAgent.id
+						} });
+						const enhancedDescription = generateDescriptionWithRelationData(teamAgentWithDefault.description || "", relatedAgentRelations.data, relatedAgentExternalAgentRelations.data, relatedAgentTeamAgentRelations.data);
+						return {
+							...relation,
+							targetAgent: {
+								...relation.targetAgent,
+								description: enhancedDescription
+							}
+						};
+					}
+				} catch (error) {
+					logger.warn({
+						targetAgentId: relation.targetAgentId,
+						error
+					}, "Failed to enhance team agent description");
+				}
+				return relation;
+			}));
+			const prompt = "prompt" in config.agentSchema ? config.agentSchema.prompt || void 0 : "";
+			const models = "models" in config.agentSchema ? config.agentSchema.models : void 0;
+			const stopWhen = "stopWhen" in config.agentSchema ? config.agentSchema.stopWhen : void 0;
+			const toolsForAgentResult = await Promise.all(toolsForAgent.data.map(async (item) => {
+				const mcpTool = await dbResultToMcpTool(item.tool, dbClient_default, credentialStoreRegistry, item.id, config.userId);
+				if (item.selectedTools && item.selectedTools.length > 0) {
+					const selectedToolsSet = new Set(item.selectedTools);
+					mcpTool.availableTools = mcpTool.availableTools?.filter((tool) => selectedToolsSet.has(tool.name)) || [];
+				}
+				return mcpTool;
+			})) ?? [];
+			agent = new Agent({
+				id: config.subAgentId,
+				tenantId: config.tenantId,
+				projectId: config.projectId,
+				agentId: config.agentId,
+				baseUrl: config.baseUrl,
+				apiKey: config.apiKey,
+				userId: config.userId,
+				name: config.name,
+				description: config.description || "",
+				prompt,
+				models: models || void 0,
+				stopWhen: stopWhen || void 0,
+				subAgentRelations: enhancedInternalRelations.map((relation) => ({
+					id: relation.id,
+					tenantId: config.tenantId,
+					projectId: config.projectId,
+					agentId: config.agentId,
+					baseUrl: config.baseUrl,
+					apiKey: config.apiKey,
+					name: relation.name,
+					description: relation.description || void 0,
+					prompt: "",
+					delegateRelations: [],
+					subAgentRelations: [],
+					transferRelations: []
+				})),
+				transferRelations: await Promise.all(enhancedInternalRelations.filter((relation) => relation.relationType === "transfer").map(async (relation) => {
+					const targetToolsForAgent = await getToolsForAgent(dbClient_default)({ scopes: {
+						tenantId: config.tenantId,
+						projectId: config.projectId,
+						agentId: config.agentId,
+						subAgentId: relation.id
+					} });
+					let targetTransferRelations = { data: [] };
+					let targetDelegateRelations = { data: [] };
+					try {
+						const [transferRel, delegateRel] = await Promise.all([getRelatedAgentsForAgent(dbClient_default)({
+							scopes: {
+								tenantId: config.tenantId,
+								projectId: config.projectId,
+								agentId: config.agentId
+							},
+							subAgentId: relation.id
+						}), getExternalAgentsForSubAgent(dbClient_default)({ scopes: {
+							tenantId: config.tenantId,
+							projectId: config.projectId,
+							agentId: config.agentId,
+							subAgentId: relation.id
+						} })]);
+						targetTransferRelations = transferRel;
+						targetDelegateRelations = delegateRel;
+					} catch (err) {
+						logger.info({
+							agentId: relation.id,
+							error: err?.message || "Unknown error"
+						}, "Could not fetch relations for target agent (likely external/team agent), using basic info only");
+					}
+					const targetAgentTools = await Promise.all(targetToolsForAgent.data.map(async (item) => {
+						const mcpTool = await dbResultToMcpTool(item.tool, dbClient_default, credentialStoreRegistry, item.id, config.userId);
+						if (item.selectedTools && item.selectedTools.length > 0) {
+							const selectedToolsSet = new Set(item.selectedTools);
+							mcpTool.availableTools = mcpTool.availableTools?.filter((tool) => selectedToolsSet.has(tool.name)) || [];
+						}
+						return mcpTool;
+					})) ?? [];
+					const targetTransferRelationsConfig = targetTransferRelations.data.filter((rel) => rel.relationType === "transfer").map((rel) => ({
+						baseUrl: config.baseUrl,
+						apiKey: config.apiKey,
+						id: rel.id,
+						tenantId: config.tenantId,
+						projectId: config.projectId,
+						agentId: config.agentId,
+						name: rel.name,
+						description: rel.description,
+						prompt: "",
+						delegateRelations: [],
+						subAgentRelations: [],
+						transferRelations: []
+					}));
+					const targetDelegateRelationsConfig = targetDelegateRelations.data.map((rel) => ({
+						type: "external",
+						config: {
+							id: rel.externalAgent.id,
+							name: rel.externalAgent.name,
+							description: rel.externalAgent.description || "",
+							baseUrl: rel.externalAgent.baseUrl,
+							headers: rel.headers,
+							credentialReferenceId: rel.externalAgent.credentialReferenceId,
+							relationId: rel.id,
+							relationType: "delegate"
+						}
+					}));
+					return {
+						baseUrl: config.baseUrl,
+						apiKey: config.apiKey,
+						id: relation.id,
+						tenantId: config.tenantId,
+						projectId: config.projectId,
+						agentId: config.agentId,
+						name: relation.name,
+						description: relation.description || void 0,
+						prompt: "",
+						delegateRelations: targetDelegateRelationsConfig,
+						subAgentRelations: [],
+						transferRelations: targetTransferRelationsConfig,
+						tools: targetAgentTools
+					};
+				})),
+				delegateRelations: [
+					...enhancedInternalRelations.filter((relation) => relation.relationType === "delegate").map((relation) => ({
+						type: "internal",
+						config: {
+							id: relation.id,
+							relationId: relation.relationId,
+							tenantId: config.tenantId,
+							projectId: config.projectId,
+							agentId: config.agentId,
+							baseUrl: config.baseUrl,
+							apiKey: config.apiKey,
+							name: relation.name,
+							description: relation.description || void 0,
+							prompt: "",
+							delegateRelations: [],
+							subAgentRelations: [],
+							transferRelations: [],
+							tools: []
+						}
+					})),
+					...externalRelations.data.map((relation) => ({
+						type: "external",
+						config: {
+							id: relation.externalAgent.id,
+							name: relation.externalAgent.name,
+							description: relation.externalAgent.description || "",
+							baseUrl: relation.externalAgent.baseUrl,
+							headers: relation.headers,
+							credentialReferenceId: relation.externalAgent.credentialReferenceId,
+							relationId: relation.id,
+							relationType: "delegate"
+						}
+					})),
+					...enhancedTeamRelations.map((relation) => ({
+						type: "team",
+						config: {
+							id: relation.targetAgent.id,
+							name: relation.targetAgent.name,
+							description: relation.targetAgent.description || "",
+							baseUrl: config.baseUrl,
+							headers: relation.headers,
+							relationId: relation.id
+						}
+					}))
+				],
+				tools: toolsForAgentResult,
+				functionTools: [],
+				dataComponents,
+				artifactComponents,
+				contextConfigId: config.contextConfigId || void 0,
+				conversationHistoryConfig: config.conversationHistoryConfig,
+				sandboxConfig: config.sandboxConfig,
+				forwardedHeaders
+			}, credentialStoreRegistry);
+			const artifactStreamRequestId = task.context?.metadata?.streamRequestId;
+			if (artifactStreamRequestId && artifactComponents.length > 0) agentSessionManager.updateArtifactComponents(artifactStreamRequestId, artifactComponents);
+			let contextId = task.context?.conversationId;
+			if (!contextId || contextId === "default" || contextId === "") {
+				const taskIdMatch = task.id.match(/^task_([^-]+-[^-]+-\d+)-/);
+				if (taskIdMatch) {
+					contextId = taskIdMatch[1];
+					logger.info({
+						taskId: task.id,
+						extractedContextId: contextId,
+						subAgentId: config.subAgentId
+					}, "Extracted contextId from task ID for delegation");
+				} else contextId = "default";
+			}
+			const streamRequestId = task.context?.metadata?.stream_request_id || task.context?.metadata?.streamRequestId;
+			const isDelegation = task.context?.metadata?.isDelegation === true;
+			const delegationId = task.context?.metadata?.delegationId;
+			agent.setDelegationStatus(isDelegation);
+			agent.setDelegationId(delegationId);
+			if (isDelegation) {
+				logger.info({
+					subAgentId: config.subAgentId,
+					taskId: task.id,
+					delegationId
+				}, "Delegated agent - streaming disabled");
+				if (streamRequestId && config.tenantId && config.projectId) toolSessionManager.ensureAgentSession(streamRequestId, config.tenantId, config.projectId, contextId, task.id);
+			}
+			const response = await agent.generate(userMessage, {
+				contextId,
+				metadata: {
+					conversationId: contextId,
+					taskId: task.id,
+					threadId: contextId,
+					streamRequestId,
+					...config.apiKey ? { apiKey: config.apiKey } : {}
+				}
+			});
+			agent.cleanupCompression();
+			const stepContents = response.steps && Array.isArray(response.steps) ? response.steps.flatMap((step) => {
+				return step.content && Array.isArray(step.content) ? step.content : [];
+			}) : [];
+			const allToolCalls = stepContents.filter((content) => content.type === "tool-call");
+			const allToolResults = stepContents.filter((content) => content.type === "tool-result");
+			const allThoughts = stepContents.filter((content) => content.type === "text");
+			if (allToolCalls.length > 0) {
+				for (const toolCall of allToolCalls) if (toolCall.toolName.includes("transfer") || toolCall.toolName.includes("transferToRefundAgent")) {
+					const toolResult = allToolResults.find((result) => result.toolCallId === toolCall.toolCallId);
+					logger.info({
+						toolCallName: toolCall.toolName,
+						toolCallId: toolCall.toolCallId,
+						hasToolResult: !!toolResult,
+						toolResultOutput: toolResult?.output,
+						toolResultKeys: toolResult?.output ? Object.keys(toolResult.output) : []
+					}, "[DEBUG] Transfer tool result found");
+					const isValidTransferResult = (output) => {
+						return typeof output === "object" && output !== null && "type" in output && "targetSubAgentId" in output && output.type === "transfer" && typeof output.targetSubAgentId === "string";
+					};
+					const transferReason = response.text || (response.object ? JSON.stringify(response.object) : "") || allThoughts[allThoughts.length - 1]?.text || "Agent requested transfer. No reason provided.";
+					if (toolResult?.output && isValidTransferResult(toolResult.output)) {
+						const transferResult = toolResult.output;
+						logger.info({
+							validationPassed: true,
+							transferResult,
+							targetSubAgentId: transferResult.targetSubAgentId,
+							fromSubAgentId: transferResult.fromSubAgentId
+						}, "[DEBUG] Transfer validation passed, extracted data");
+						const artifactData = {
+							type: "transfer",
+							targetSubAgentId: transferResult.targetSubAgentId,
+							fromSubAgentId: transferResult.fromSubAgentId,
+							task_id: task.id,
+							reason: transferReason,
+							original_message: userMessage
+						};
+						logger.info({
+							artifactData,
+							artifactDataKeys: Object.keys(artifactData)
+						}, "[DEBUG] Artifact data being returned");
+						return {
+							status: {
+								state: TaskState.Completed,
+								message: `Transfer requested to ${transferResult.targetSubAgentId}`
+							},
+							artifacts: [{
+								artifactId: generateId(),
+								parts: [{
+									kind: "data",
+									data: artifactData
+								}],
+								createdAt: (/* @__PURE__ */ new Date()).toISOString()
+							}]
+						};
+					}
+					logger.warn({
+						hasToolResult: !!toolResult,
+						hasOutput: !!toolResult?.output,
+						validationPassed: false,
+						output: toolResult?.output
+					}, "[DEBUG] Transfer validation FAILED");
+				}
+			}
+			const parts = (response.formattedContent?.parts || []).map((part) => ({
+				kind: part.kind,
+				...part.kind === "text" && { text: part.text },
+				...part.kind === "data" && { data: part.data }
+			}));
+			return {
+				status: { state: TaskState.Completed },
+				artifacts: [{
+					artifactId: generateId(),
+					parts,
+					createdAt: (/* @__PURE__ */ new Date()).toISOString()
+				}]
+			};
+		} catch (error) {
+			console.error("Task handler error:", error);
+			try {
+				if (agent) agent.cleanupCompression();
+			} catch (cleanupError) {
+				logger.warn({ cleanupError }, "Failed to cleanup agent compression on error");
+			}
+			const errorMessage = error instanceof Error ? error.message : "Unknown error occurred";
+			const isConnectionRefused = errorMessage.includes("Connection refused. Please check if the MCP server is running.");
+			return {
+				status: {
+					state: TaskState.Failed,
+					message: errorMessage,
+					type: isConnectionRefused ? "connection_refused" : "unknown"
+				},
+				artifacts: []
+			};
+		}
+	};
+};
+/**
+* Serializes a TaskHandlerConfig to JSON
+*/
+const serializeTaskHandlerConfig = (config) => {
+	return JSON.stringify(config, null, 2);
+};
+/**
+* Deserializes a TaskHandlerConfig from JSON
+*/
+const deserializeTaskHandlerConfig = (configJson) => {
+	return JSON.parse(configJson);
+};
+/**
+* Creates a task handler configuration from agent data
+*/
+const createTaskHandlerConfig = async (params) => {
+	const subAgent = await getSubAgentById(dbClient_default)({
+		scopes: {
+			tenantId: params.tenantId,
+			projectId: params.projectId,
+			agentId: params.agentId
+		},
+		subAgentId: params.subAgentId
+	});
+	const agent = await getAgentById(dbClient_default)({ scopes: {
+		tenantId: params.tenantId,
+		projectId: params.projectId,
+		agentId: params.agentId
+	} });
+	if (!subAgent) throw new Error(`Agent not found: ${params.subAgentId}`);
+	const effectiveModels = await resolveModelConfig(params.agentId, subAgent);
+	const effectiveConversationHistoryConfig = subAgent.conversationHistoryConfig;
+	return {
+		tenantId: params.tenantId,
+		projectId: params.projectId,
+		agentId: params.agentId,
+		subAgentId: params.subAgentId,
+		agentSchema: {
+			id: subAgent.id,
+			name: subAgent.name,
+			description: subAgent.description,
+			prompt: subAgent.prompt,
+			models: effectiveModels,
+			conversationHistoryConfig: effectiveConversationHistoryConfig || null,
+			stopWhen: subAgent.stopWhen || null,
+			createdAt: subAgent.createdAt,
+			updatedAt: subAgent.updatedAt
+		},
+		baseUrl: params.baseUrl,
+		apiKey: params.apiKey,
+		name: subAgent.name,
+		description: subAgent.description || void 0,
+		conversationHistoryConfig: effectiveConversationHistoryConfig,
+		contextConfigId: agent?.contextConfigId || void 0,
+		sandboxConfig: params.sandboxConfig,
+		userId: params.userId
+	};
+};
+
+//#endregion
+export { createTaskHandler, createTaskHandlerConfig, deserializeTaskHandlerConfig, serializeTaskHandlerConfig };

package/dist/agents/relationTools.d.ts

@@ -0,0 +1,57 @@
+import { AgentConfig, DelegateRelation } from "./Agent.js";
+import * as _inkeep_agents_core0 from "@inkeep/agents-core";
+import { CredentialStoreRegistry } from "@inkeep/agents-core";
+import * as ai0 from "ai";
+
+//#region src/agents/relationTools.d.ts
+declare const createTransferToAgentTool: ({
+  transferConfig,
+  callingAgentId,
+  subAgent,
+  streamRequestId
+}: {
+  transferConfig: AgentConfig;
+  callingAgentId: string;
+  subAgent: any;
+  streamRequestId?: string;
+}) => ai0.Tool<Record<string, never>, {
+  type: string;
+  targetSubAgentId: string;
+  fromSubAgentId: string;
+}>;
+declare function createDelegateToAgentTool({
+  delegateConfig,
+  callingAgentId,
+  tenantId,
+  projectId,
+  agentId,
+  contextId,
+  metadata,
+  sessionId,
+  subAgent,
+  credentialStoreRegistry
+}: {
+  delegateConfig: DelegateRelation;
+  callingAgentId: string;
+  tenantId: string;
+  projectId: string;
+  agentId: string;
+  contextId: string;
+  metadata: {
+    conversationId: string;
+    threadId: string;
+    streamRequestId?: string;
+    streamBaseUrl?: string;
+    apiKey?: string;
+  };
+  sessionId?: string;
+  subAgent: any;
+  credentialStoreRegistry?: CredentialStoreRegistry;
+}): ai0.Tool<{
+  message: string;
+}, {
+  toolCallId: any;
+  result: _inkeep_agents_core0.Message | _inkeep_agents_core0.Task;
+}>;
+//#endregion
+export { createDelegateToAgentTool, createTransferToAgentTool };