@inkeep/agents-run-api 0.0.0-dev-20260113172432 → 0.0.0-dev-20260115183047

package/dist/agents/generateTaskHandler.js

@@ -1,14 +1,16 @@
-import { getLogger } from "../logger.js";
-import dbClient_default from "../data/db/dbClient.js";
+import { env } from "../env.js";
+import { getLogger as getLogger$1 } from "../logger.js";
+import { getUserIdFromContext } from "../types/execution-context.js";
 import { toolSessionManager } from "./ToolSessionManager.js";
 import { agentSessionManager } from "../services/AgentSession.js";
 import { resolveModelConfig } from "../utils/model-resolver.js";
+import { enhanceInternalRelation, enhanceTeamRelation, getArtifactComponentsForSubAgent, getDataComponentsForSubAgent, getSubAgentRelations, getToolsForSubAgent } from "../utils/project.js";
+import { buildTransferRelationConfig } from "./relationTools.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";
+import { InternalServices, ManagementApiClient, TaskState, generateId } from "@inkeep/agents-core";
 
 //#region src/agents/generateTaskHandler.ts
-const logger = getLogger("generateTaskHandler");
+const logger = getLogger$1("generateTaskHandler");
 const createTaskHandler = (config, credentialStoreRegistry) => {
 	return async (task) => {
 		let agent;
@@ -22,141 +24,81 @@ const createTaskHandler = (config, credentialStoreRegistry) => {
 				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) => {
+			const { project, agentId, tenantId, projectId, resolvedRef } = config.executionContext;
+			const currentAgent = project.agents[agentId];
+			const currentSubAgent = currentAgent?.subAgents?.[config.subAgentId];
+			if (!currentSubAgent) return {
+				status: {
+					state: TaskState.Failed,
+					message: `Sub-agent ${config.subAgentId} not found in project`
+				},
+				artifacts: []
+			};
+			const { externalRelations, teamRelations, transferRelations, internalDelegateRelations } = getSubAgentRelations({
+				agent: currentAgent,
+				project,
+				subAgent: currentSubAgent
+			});
+			const allInternalRelations = [...transferRelations, ...internalDelegateRelations];
+			const toolsForAgent = getToolsForSubAgent({
+				agent: currentAgent,
+				project,
+				subAgent: currentSubAgent
+			});
+			const dataComponents = getDataComponentsForSubAgent({
+				project,
+				subAgent: currentSubAgent
+			});
+			const artifactComponents = getArtifactComponentsForSubAgent({
+				project,
+				subAgent: currentSubAgent
+			});
+			const enhancedInternalRelations = allInternalRelations.map((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
-						};
-					}
+					return enhanceInternalRelation({
+						relation,
+						agent: currentAgent,
+						project
+					});
 				} catch (error) {
 					logger.warn({
 						subAgentId: relation.id,
 						error
 					}, "Failed to enhance agent description");
+					return relation;
 				}
-				return relation;
-			}));
-			const enhancedTeamRelations = await Promise.all(teamRelations.data.map(async (relation) => {
+			});
+			const enhancedTeamRelations = teamRelations.map((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
-							}
-						};
-					}
+					return enhanceTeamRelation({
+						relation,
+						project
+					});
 				} catch (error) {
 					logger.warn({
 						targetAgentId: relation.targetAgentId,
 						error
 					}, "Failed to enhance team agent description");
+					return relation;
 				}
-				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);
+			const manageApiClient = new ManagementApiClient({
+				apiUrl: env.INKEEP_AGENTS_MANAGE_API_URL,
+				tenantId,
+				projectId,
+				auth: {
+					mode: "internalService",
+					internalServiceName: InternalServices.INKEEP_AGENTS_RUN_API
+				},
+				ref: resolvedRef.name,
+				userId: config.userId
+			});
+			const toolsForAgentResult = await Promise.all(toolsForAgent.map(async (item) => {
+				const mcpTool = await manageApiClient.getMcpTool(item.tool.id);
+				if (item.relationshipId) mcpTool.relationshipId = item.relationshipId;
 				if (item.selectedTools && item.selectedTools.length > 0) {
 					const selectedToolsSet = new Set(item.selectedTools);
 					mcpTool.availableTools = mcpTool.availableTools?.filter((tool) => selectedToolsSet.has(tool.name)) || [];
@@ -165,9 +107,9 @@ const createTaskHandler = (config, credentialStoreRegistry) => {
 			})) ?? [];
 			agent = new Agent({
 				id: config.subAgentId,
-				tenantId: config.tenantId,
-				projectId: config.projectId,
-				agentId: config.agentId,
+				tenantId,
+				projectId,
+				agentId,
 				baseUrl: config.baseUrl,
 				apiKey: config.apiKey,
 				userId: config.userId,
@@ -178,9 +120,9 @@ const createTaskHandler = (config, credentialStoreRegistry) => {
 				stopWhen: stopWhen || void 0,
 				subAgentRelations: enhancedInternalRelations.map((relation) => ({
 					id: relation.id,
-					tenantId: config.tenantId,
-					projectId: config.projectId,
-					agentId: config.agentId,
+					tenantId,
+					projectId,
+					agentId,
 					baseUrl: config.baseUrl,
 					apiKey: config.apiKey,
 					name: relation.name,
@@ -188,99 +130,24 @@ const createTaskHandler = (config, credentialStoreRegistry) => {
 					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
-					};
+					transferRelations: [],
+					relationId: relation.relationId
 				})),
+				transferRelations: await Promise.all(enhancedInternalRelations.filter((relation) => relation.relationType === "transfer").map((relation) => buildTransferRelationConfig({
+					relation,
+					executionContext: config.executionContext,
+					baseUrl: config.baseUrl,
+					apiKey: config.apiKey
+				}))),
 				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,
+							tenantId,
+							projectId,
+							agentId,
 							baseUrl: config.baseUrl,
 							apiKey: config.apiKey,
 							name: relation.name,
@@ -289,19 +156,21 @@ const createTaskHandler = (config, credentialStoreRegistry) => {
 							delegateRelations: [],
 							subAgentRelations: [],
 							transferRelations: [],
-							tools: []
+							tools: [],
+							project
 						}
 					})),
-					...externalRelations.data.map((relation) => ({
+					...externalRelations.map((relation) => ({
 						type: "external",
 						config: {
 							id: relation.externalAgent.id,
 							name: relation.externalAgent.name,
 							description: relation.externalAgent.description || "",
+							ref: resolvedRef,
 							baseUrl: relation.externalAgent.baseUrl,
 							headers: relation.headers,
 							credentialReferenceId: relation.externalAgent.credentialReferenceId,
-							relationId: relation.id,
+							relationId: relation.relationId,
 							relationType: "delegate"
 						}
 					})),
@@ -309,11 +178,12 @@ const createTaskHandler = (config, credentialStoreRegistry) => {
 						type: "team",
 						config: {
 							id: relation.targetAgent.id,
+							ref: resolvedRef,
 							name: relation.targetAgent.name,
 							description: relation.targetAgent.description || "",
 							baseUrl: config.baseUrl,
 							headers: relation.headers,
-							relationId: relation.id
+							relationId: relation.relationId
 						}
 					}))
 				],
@@ -325,7 +195,7 @@ const createTaskHandler = (config, credentialStoreRegistry) => {
 				conversationHistoryConfig: config.conversationHistoryConfig,
 				sandboxConfig: config.sandboxConfig,
 				forwardedHeaders
-			}, credentialStoreRegistry);
+			}, config.executionContext, credentialStoreRegistry);
 			const artifactStreamRequestId = task.context?.metadata?.streamRequestId;
 			if (artifactStreamRequestId && artifactComponents.length > 0) agentSessionManager.updateArtifactComponents(artifactStreamRequestId, artifactComponents);
 			let contextId = task.context?.conversationId;
@@ -351,8 +221,10 @@ const createTaskHandler = (config, credentialStoreRegistry) => {
 					taskId: task.id,
 					delegationId
 				}, "Delegated agent - streaming disabled");
-				if (streamRequestId && config.tenantId && config.projectId) toolSessionManager.ensureAgentSession(streamRequestId, config.tenantId, config.projectId, contextId, task.id);
+				if (streamRequestId && tenantId && projectId) toolSessionManager.ensureAgentSession(streamRequestId, tenantId, projectId, contextId, task.id);
 			}
+			logger.info({ contextId }, "Context ID");
+			logger.info({ userMessage }, "User Message");
 			const response = await agent.generate(userMessage, {
 				contextId,
 				metadata: {
@@ -473,30 +345,19 @@ const deserializeTaskHandlerConfig = (configJson) => {
 	return JSON.parse(configJson);
 };
 /**
-* Creates a task handler configuration from agent data
+* Creates a task handler configuration from execution context and project 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 { executionContext, subAgentId, baseUrl, apiKey, sandboxConfig } = params;
+	const { project, agentId } = executionContext;
+	const agent = project.agents[agentId];
+	const subAgent = agent?.subAgents?.[subAgentId];
+	if (!subAgent) throw new Error(`Sub-agent not found: ${subAgentId}`);
+	const effectiveModels = await resolveModelConfig(executionContext, subAgent);
 	const effectiveConversationHistoryConfig = subAgent.conversationHistoryConfig;
 	return {
-		tenantId: params.tenantId,
-		projectId: params.projectId,
-		agentId: params.agentId,
-		subAgentId: params.subAgentId,
+		executionContext,
+		subAgentId,
 		agentSchema: {
 			id: subAgent.id,
 			name: subAgent.name,
@@ -508,14 +369,14 @@ const createTaskHandlerConfig = async (params) => {
 			createdAt: subAgent.createdAt,
 			updatedAt: subAgent.updatedAt
 		},
-		baseUrl: params.baseUrl,
-		apiKey: params.apiKey,
+		baseUrl,
+		apiKey,
 		name: subAgent.name,
 		description: subAgent.description || void 0,
 		conversationHistoryConfig: effectiveConversationHistoryConfig,
-		contextConfigId: agent?.contextConfigId || void 0,
-		sandboxConfig: params.sandboxConfig,
-		userId: params.userId
+		contextConfigId: agent?.contextConfig?.id || void 0,
+		sandboxConfig,
+		userId: getUserIdFromContext(executionContext)
 	};
 };
 

package/dist/agents/relationTools.d.ts

@@ -1,6 +1,7 @@
 import { AgentConfig, DelegateRelation } from "./Agent.js";
+import { InternalRelation } from "../utils/project.js";
 import * as _inkeep_agents_core0 from "@inkeep/agents-core";
-import { CredentialStoreRegistry } from "@inkeep/agents-core";
+import { CredentialStoreRegistry, FullExecutionContext } from "@inkeep/agents-core";
 import * as ai0 from "ai";
 
 //#region src/agents/relationTools.d.ts
@@ -22,9 +23,7 @@ declare const createTransferToAgentTool: ({
 declare function createDelegateToAgentTool({
   delegateConfig,
   callingAgentId,
-  tenantId,
-  projectId,
-  agentId,
+  executionContext,
   contextId,
   metadata,
   sessionId,
@@ -33,9 +32,7 @@ declare function createDelegateToAgentTool({
 }: {
   delegateConfig: DelegateRelation;
   callingAgentId: string;
-  tenantId: string;
-  projectId: string;
-  agentId: string;
+  executionContext: FullExecutionContext;
   contextId: string;
   metadata: {
     conversationId: string;
@@ -53,5 +50,19 @@ declare function createDelegateToAgentTool({
   toolCallId: any;
   result: _inkeep_agents_core0.Message | _inkeep_agents_core0.Task;
 }>;
+/**
+ * Parameters for building a transfer relation config
+ */
+type BuildTransferRelationConfigParams = {
+  relation: InternalRelation;
+  executionContext: FullExecutionContext;
+  baseUrl: string;
+  apiKey?: string;
+};
+/**
+ * Build a transfer relation config for an internal relation.
+ * Fetches tools, transfer relations, and external agent relations for the target sub-agent.
+ */
+declare function buildTransferRelationConfig(params: BuildTransferRelationConfigParams): Promise<AgentConfig>;
 //#endregion
-export { createDelegateToAgentTool, createTransferToAgentTool };
+export { BuildTransferRelationConfigParams, buildTransferRelationConfig, createDelegateToAgentTool, createTransferToAgentTool };