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

package/dist/agents/Agent.js

@@ -1,4 +1,5 @@
-import { getLogger } from "../logger.js";
+import { env } from "../env.js";
+import { getLogger as getLogger$1 } from "../logger.js";
 import dbClient_default from "../data/db/dbClient.js";
 import { AGENT_EXECUTION_MAX_GENERATION_STEPS, FUNCTION_TOOL_EXECUTION_TIMEOUT_MS_DEFAULT, FUNCTION_TOOL_SANDBOX_VCPUS_DEFAULT, LLM_GENERATION_FIRST_CALL_TIMEOUT_MS_NON_STREAMING, LLM_GENERATION_FIRST_CALL_TIMEOUT_MS_STREAMING, LLM_GENERATION_MAX_ALLOWED_TIMEOUT_MS, LLM_GENERATION_SUBSEQUENT_CALL_TIMEOUT_MS } from "../constants/execution-limits/index.js";
 import { toolSessionManager } from "./ToolSessionManager.js";
@@ -8,6 +9,8 @@ import { getModelAwareCompressionConfig } from "../services/BaseCompressor.js";
 import { createDefaultConversationHistoryConfig, getConversationHistoryWithCompression } from "../data/conversations.js";
 import { getStreamHelper } from "../utils/stream-registry.js";
 import { agentSessionManager } from "../services/AgentSession.js";
+import { ContextResolver } from "../context/ContextResolver.js";
+import "../context/index.js";
 import { IncrementalStreamParser } from "../services/IncrementalStreamParser.js";
 import { MidGenerationCompressor } from "../services/MidGenerationCompressor.js";
 import { pendingToolApprovalManager } from "../services/PendingToolApprovalManager.js";
@@ -19,10 +22,10 @@ import { withJsonPostProcessing } from "../utils/json-postprocessor.js";
 import { calculateBreakdownTotal, estimateTokens } from "../utils/token-estimator.js";
 import { createDelegateToAgentTool, createTransferToAgentTool } from "./relationTools.js";
 import { SystemPromptBuilder } from "./SystemPromptBuilder.js";
-import { Phase1Config } from "./versions/v1/Phase1Config.js";
+import { Phase1Config, V1_BREAKDOWN_SCHEMA } from "./versions/v1/Phase1Config.js";
 import { Phase2Config } from "./versions/v1/Phase2Config.js";
 import { z } from "@hono/zod-openapi";
-import { ContextResolver, CredentialStuffer, MCPServerType, MCPTransportType, McpClient, ModelFactory, TemplateEngine, agentHasArtifactComponents, createMessage, generateId, getContextConfigById, getCredentialReference, getFullAgentDefinition, getFunction, getFunctionToolsForSubAgent, getLedgerArtifacts, getToolsForAgent, getUserScopedCredentialReference, listTaskIdsByContextId, parseEmbeddedJson } from "@inkeep/agents-core";
+import { CredentialStuffer, InternalServices, JsonTransformer, MCPServerType, MCPTransportType, ManagementApiClient, McpClient, ModelFactory, TemplateEngine, createMessage, generateId, getLedgerArtifacts, listTaskIdsByContextId, parseEmbeddedJson } from "@inkeep/agents-core";
 import { SpanStatusCode, trace } from "@opentelemetry/api";
 import { Output, generateText, streamText, tool } from "ai";
 
@@ -39,7 +42,7 @@ function hasToolCallWithPrefix(prefix) {
 		return false;
 	};
 }
-const logger = getLogger("Agent");
+const logger = getLogger$1("Agent");
 function validateModel(modelString, modelType) {
 	if (!modelString?.trim()) throw new Error(`${modelType} model is required. Please configure models at the project level.`);
 	return modelString.trim();
@@ -62,8 +65,10 @@ var Agent = class {
 	mcpClientCache = /* @__PURE__ */ new Map();
 	mcpConnectionLocks = /* @__PURE__ */ new Map();
 	currentCompressor = null;
-	constructor(config, credentialStoreRegistry) {
+	executionContext;
+	constructor(config, executionContext, credentialStoreRegistry) {
 		this.artifactComponents = config.artifactComponents || [];
+		this.executionContext = executionContext;
 		let processedDataComponents = config.dataComponents || [];
 		if (processedDataComponents.length > 0) processedDataComponents.push({
 			id: "text-content",
@@ -86,7 +91,7 @@ var Agent = class {
 		};
 		this.credentialStoreRegistry = credentialStoreRegistry;
 		if (credentialStoreRegistry) {
-			this.contextResolver = new ContextResolver(config.tenantId, config.projectId, dbClient_default, credentialStoreRegistry);
+			this.contextResolver = new ContextResolver(executionContext, credentialStoreRegistry);
 			this.credentialStuffer = new CredentialStuffer(credentialStoreRegistry, this.contextResolver);
 		}
 	}
@@ -318,9 +323,7 @@ var Agent = class {
 			return [toolName, this.wrapToolWithStreaming(toolName, createDelegateToAgentTool({
 				delegateConfig: relation,
 				callingAgentId: this.config.id,
-				tenantId: this.config.tenantId,
-				projectId: this.config.projectId,
-				agentId: this.config.agentId,
+				executionContext: this.executionContext,
 				contextId: runtimeContext?.contextId || "default",
 				metadata: runtimeContext?.metadata || {
 					conversationId: runtimeContext?.contextId || "default",
@@ -344,7 +347,7 @@ var Agent = class {
 			for (const toolSet of tools) for (const [toolName, toolDef] of Object.entries(toolSet.tools)) {
 				const needsApproval = toolSet.toolPolicies?.[toolName]?.needsApproval || false;
 				const enhancedTool = {
-					...toolDef,
+					...toolDef || {},
 					needsApproval
 				};
 				wrappedTools$1[toolName] = this.wrapToolWithStreaming(toolName, enhancedTool, streamRequestId, "mcp", {
@@ -535,34 +538,24 @@ var Agent = class {
 			headers: {
 				...tool$1.headers,
 				...agentToolRelationHeaders
-			}
+			},
+			toolOverrides: tool$1.config.mcp.toolOverrides
 		};
 	}
 	async getMcpTool(tool$1) {
 		const forwardedHeadersHash = this.config.forwardedHeaders ? Object.keys(this.config.forwardedHeaders).sort().join(",") : "no-fwd";
 		const cacheKey = `${this.config.tenantId}-${this.config.projectId}-${tool$1.id}-${tool$1.credentialReferenceId || "no-cred"}-${forwardedHeadersHash}`;
+		const project = this.executionContext.project;
 		const credentialReferenceId = tool$1.credentialReferenceId;
-		const toolRelation = (await getToolsForAgent(dbClient_default)({ scopes: {
-			tenantId: this.config.tenantId,
-			projectId: this.config.projectId,
-			agentId: this.config.agentId,
-			subAgentId: this.config.id
-		} })).data.find((t) => t.toolId === tool$1.id);
+		const toolRelation = (project.agents[this.config.agentId]?.subAgents?.[this.config.id])?.canUse?.find((t) => t.toolId === tool$1.id);
 		const agentToolRelationHeaders = toolRelation?.headers || void 0;
-		const selectedTools = toolRelation?.selectedTools || void 0;
+		const selectedTools = toolRelation?.toolSelection || void 0;
 		const toolPolicies = toolRelation?.toolPolicies || {};
 		let serverConfig;
 		const isUserScoped = tool$1.credentialScope === "user";
 		const userId = this.config.userId;
 		if (isUserScoped && userId && this.credentialStuffer) {
-			const userCredentialReference = await getUserScopedCredentialReference(dbClient_default)({
-				scopes: {
-					tenantId: this.config.tenantId,
-					projectId: this.config.projectId
-				},
-				toolId: tool$1.id,
-				userId
-			});
+			const userCredentialReference = project.credentialReferences ? Object.values(project.credentialReferences).find((c) => c.toolId === tool$1.id && c.userId === userId) : void 0;
 			if (userCredentialReference) {
 				const storeReference = {
 					credentialStoreId: userCredentialReference.credentialStoreId,
@@ -587,14 +580,8 @@ var Agent = class {
 				}, this.convertToMCPToolConfig(tool$1, agentToolRelationHeaders), void 0, selectedTools);
 			}
 		} else if (credentialReferenceId && this.credentialStuffer) {
-			const credentialReference = await getCredentialReference(dbClient_default)({
-				scopes: {
-					tenantId: this.config.tenantId,
-					projectId: this.config.projectId
-				},
-				id: credentialReferenceId
-			});
-			if (!credentialReference) throw new Error(`Credential store not found: ${credentialReferenceId}`);
+			const credentialReference = project.credentialReferences?.[credentialReferenceId];
+			if (!credentialReference) throw new Error(`Credential reference not found: ${credentialReferenceId}`);
 			const storeReference = {
 				credentialStoreId: credentialReference.credentialStoreId,
 				retrievalParams: credentialReference.retrievalParams || {}
@@ -663,7 +650,8 @@ var Agent = class {
 				throw error;
 			}
 		}
-		const tools = await client.tools();
+		const originalTools = await client.tools();
+		const tools = await this.applyToolOverrides(originalTools, tool$1);
 		if (!tools || Object.keys(tools).length === 0) {
 			const streamRequestId = this.getStreamRequestId();
 			if (streamRequestId) tracer.startActiveSpan("ai.toolCall", { attributes: {
@@ -728,15 +716,19 @@ var Agent = class {
 	}
 	async getFunctionTools(sessionId, streamRequestId) {
 		const functionTools = {};
+		const project = this.executionContext.project;
 		try {
-			const functionToolsData = (await getFunctionToolsForSubAgent(dbClient_default)({
-				scopes: {
-					tenantId: this.config.tenantId,
-					projectId: this.config.projectId,
-					agentId: this.config.agentId
+			const functionToolsData = await new ManagementApiClient({
+				apiUrl: env.INKEEP_AGENTS_MANAGE_API_URL,
+				tenantId: this.config.tenantId,
+				projectId: this.config.projectId,
+				auth: {
+					mode: "internalService",
+					internalServiceName: InternalServices.INKEEP_AGENTS_RUN_API
 				},
-				subAgentId: this.config.id
-			})).data || [];
+				ref: this.executionContext.resolvedRef.name,
+				userId: this.config.userId
+			}).getFunctionToolsForSubAgent(this.config.agentId, this.config.id) ?? [];
 			if (functionToolsData.length === 0) return functionTools;
 			const { SandboxExecutorFactory } = await import("../tools/SandboxExecutorFactory.js");
 			const sandboxExecutor = SandboxExecutorFactory.getInstance();
@@ -746,13 +738,7 @@ var Agent = class {
 					logger.warn({ functionToolId: functionToolDef.id }, "Function tool missing functionId reference");
 					continue;
 				}
-				const functionData = await getFunction(dbClient_default)({
-					functionId,
-					scopes: {
-						tenantId: this.config.tenantId || "default",
-						projectId: this.config.projectId || "default"
-					}
-				});
+				const functionData = project.functions?.[functionId];
 				if (!functionData) {
 					logger.warn({
 						functionId,
@@ -833,24 +819,30 @@ var Agent = class {
 	*/
 	async getResolvedContext(conversationId, headers$1) {
 		try {
+			const project = this.executionContext.project;
 			if (!this.config.contextConfigId) {
 				logger.debug({ agentId: this.config.agentId }, "No context config found for agent");
 				return null;
 			}
-			const contextConfig = await getContextConfigById(dbClient_default)({
-				scopes: {
-					tenantId: this.config.tenantId,
-					projectId: this.config.projectId,
-					agentId: this.config.agentId
-				},
-				id: this.config.contextConfigId
-			});
+			const contextConfig = project.agents[this.config.agentId]?.contextConfig;
+			if (!contextConfig) {
+				logger.warn({ contextConfigId: this.config.contextConfigId }, "Context config not found");
+				return null;
+			}
+			const contextConfigWithScopes = {
+				...contextConfig,
+				tenantId: this.config.tenantId,
+				projectId: this.config.projectId,
+				agentId: this.config.agentId,
+				createdAt: contextConfig.createdAt || "",
+				updatedAt: contextConfig.updatedAt || ""
+			};
 			if (!contextConfig) {
 				logger.warn({ contextConfigId: this.config.contextConfigId }, "Context config not found");
 				return null;
 			}
 			if (!this.contextResolver) throw new Error("Context resolver not found");
-			const result = await this.contextResolver.resolve(contextConfig, {
+			const result = await this.contextResolver.resolve(contextConfigWithScopes, {
 				triggerEvent: "invocation",
 				conversationId,
 				headers: headers$1 || {},
@@ -882,12 +874,9 @@ var Agent = class {
 	* Get the agent prompt for this agent's agent
 	*/
 	async getPrompt() {
+		const agentDefinition = this.executionContext.project.agents[this.config.agentId];
 		try {
-			return (await getFullAgentDefinition(dbClient_default)({ scopes: {
-				tenantId: this.config.tenantId,
-				projectId: this.config.projectId,
-				agentId: this.config.agentId
-			} }))?.prompt || void 0;
+			return agentDefinition?.prompt || void 0;
 		} catch (error) {
 			logger.warn({
 				agentId: this.config.agentId,
@@ -900,12 +889,9 @@ var Agent = class {
 	* Check if any agent in the agent has artifact components configured
 	*/
 	async hasAgentArtifactComponents() {
+		const project = this.executionContext.project;
 		try {
-			const agentDefinition = await getFullAgentDefinition(dbClient_default)({ scopes: {
-				tenantId: this.config.tenantId,
-				projectId: this.config.projectId,
-				agentId: this.config.agentId
-			} });
+			const agentDefinition = project.agents[this.config.agentId];
 			if (!agentDefinition) return false;
 			return Object.values(agentDefinition.subAgents).some((subAgent) => "artifactComponents" in subAgent && subAgent.artifactComponents && subAgent.artifactComponents.length > 0);
 		} catch (error) {
@@ -1012,7 +998,8 @@ var Agent = class {
 			tenantId: this.config.tenantId,
 			projectId: this.config.projectId,
 			conversationId: runtimeContext?.contextId || "",
-			historyConfig
+			historyConfig,
+			ref: this.executionContext.resolvedRef
 		});
 		const componentDataComponents = excludeDataComponents ? [] : this.config.dataComponents || [];
 		const isThinkingPreparation = this.config.dataComponents && this.config.dataComponents.length > 0 && excludeDataComponents;
@@ -1117,6 +1104,162 @@ var Agent = class {
 	getStreamRequestId() {
 		return this.streamRequestId || "";
 	}
+	async applyToolOverrides(originalTools, mcpTool) {
+		const toolOverrides = mcpTool.config.type === "mcp" ? mcpTool.config.mcp?.toolOverrides : void 0;
+		if (!toolOverrides) {
+			logger.debug({ mcpToolName: mcpTool.name }, "No tool overrides configured, using original tools");
+			return originalTools;
+		}
+		if (!originalTools || typeof originalTools !== "object") {
+			logger.warn({
+				mcpToolName: mcpTool.name,
+				originalToolsType: typeof originalTools
+			}, "Invalid original tools structure, skipping overrides");
+			return originalTools || {};
+		}
+		const processedTools = {};
+		const availableToolNames = Object.keys(originalTools);
+		const overrideNames = Object.keys(toolOverrides);
+		const invalidOverrides = overrideNames.filter((name) => !availableToolNames.includes(name));
+		if (invalidOverrides.length > 0) logger.warn({
+			mcpToolName: mcpTool.name,
+			invalidOverrides,
+			availableTools: availableToolNames
+		}, "Tool override configured for non-existent tools");
+		logger.info({
+			mcpToolName: mcpTool.name,
+			totalTools: availableToolNames.length,
+			toolsWithOverrides: overrideNames.length,
+			availableTools: availableToolNames,
+			overrideTools: overrideNames
+		}, "Starting tool override application");
+		for (const [toolName, toolDef] of Object.entries(originalTools)) {
+			if (!toolDef || typeof toolDef !== "object") {
+				logger.warn({
+					mcpToolName: mcpTool.name,
+					toolName,
+					toolDefType: typeof toolDef
+				}, "Invalid tool definition structure, skipping tool");
+				continue;
+			}
+			const override = toolOverrides[toolName];
+			if (override && (override.schema || override.description || override.displayName)) try {
+				logger.debug({
+					mcpToolName: mcpTool.name,
+					toolName,
+					override: {
+						hasSchema: !!override.schema,
+						hasDescription: !!override.description,
+						hasDisplayName: !!override.displayName,
+						hasTransformation: !!override.transformation,
+						transformationType: typeof override.transformation
+					}
+				}, "Processing tool override");
+				let inputSchema;
+				try {
+					inputSchema = override.schema ? jsonSchemaToZod(override.schema) : toolDef.inputSchema;
+				} catch (schemaError) {
+					logger.error({
+						mcpToolName: mcpTool.name,
+						toolName,
+						schemaError: schemaError instanceof Error ? schemaError.message : String(schemaError),
+						overrideSchema: override.schema
+					}, "Failed to convert override schema, using original");
+					inputSchema = toolDef.inputSchema;
+				}
+				const toolId = override.displayName || toolName;
+				const simplifiedTool = tool({
+					description: override.description || toolDef.description || `Tool ${toolId}`,
+					inputSchema,
+					execute: async (simpleArgs) => {
+						let complexArgs = simpleArgs;
+						if (override.transformation) try {
+							const startTime = Date.now();
+							if (typeof override.transformation === "string") complexArgs = await JsonTransformer.transform(simpleArgs, override.transformation, { timeout: 1e4 });
+							else if (typeof override.transformation === "object" && override.transformation !== null) complexArgs = await JsonTransformer.transformWithConfig(simpleArgs, { objectTransformation: override.transformation }, { timeout: 1e4 });
+							else logger.warn({
+								mcpToolName: mcpTool.name,
+								toolName,
+								transformationType: typeof override.transformation
+							}, "Invalid transformation type, skipping transformation");
+							const duration = Date.now() - startTime;
+							logger.debug({
+								mcpToolName: mcpTool.name,
+								toolName,
+								transformationDuration: duration,
+								hasSimpleArgs: !!simpleArgs,
+								hasComplexArgs: !!complexArgs,
+								transformation: typeof override.transformation === "string" ? override.transformation.substring(0, 100) + "..." : "object-transformation"
+							}, "Successfully transformed tool arguments");
+						} catch (transformError) {
+							const errorMessage = transformError instanceof Error ? transformError.message : String(transformError);
+							logger.error({
+								mcpToolName: mcpTool.name,
+								toolName,
+								transformError: errorMessage,
+								transformation: override.transformation,
+								simpleArgs
+							}, "Failed to transform tool arguments, using original arguments");
+							complexArgs = simpleArgs;
+						}
+						if (typeof toolDef.execute !== "function") throw new Error(`Original tool ${toolName} does not have a valid execute function`);
+						try {
+							logger.debug({
+								mcpToolName: mcpTool.name,
+								toolName,
+								hasComplexArgs: !!complexArgs
+							}, "Executing original tool with processed arguments");
+							return await toolDef.execute(complexArgs);
+						} catch (executeError) {
+							const errorMessage = executeError instanceof Error ? executeError.message : String(executeError);
+							logger.error({
+								mcpToolName: mcpTool.name,
+								toolName,
+								executeError: errorMessage,
+								complexArgs
+							}, "Failed to execute original tool");
+							throw new Error(`Tool execution failed for ${toolName}: ${errorMessage}`);
+						}
+					}
+				});
+				const finalToolName = override.displayName || toolName;
+				processedTools[finalToolName] = simplifiedTool;
+				logger.info({
+					mcpToolName: mcpTool.name,
+					originalToolName: toolName,
+					finalToolName,
+					displayName: override.displayName,
+					hasSchemaOverride: !!override.schema,
+					hasDescriptionOverride: !!override.description,
+					hasTransformation: !!override.transformation
+				}, "Successfully applied tool overrides");
+			} catch (error) {
+				const errorMessage = error instanceof Error ? error.message : String(error);
+				logger.error({
+					mcpToolName: mcpTool.name,
+					toolName,
+					error: errorMessage,
+					override
+				}, "Failed to apply tool overrides, using original tool");
+				processedTools[toolName] = toolDef;
+			}
+			else {
+				processedTools[toolName] = toolDef;
+				logger.debug({
+					mcpToolName: mcpTool.name,
+					toolName
+				}, "No overrides configured for tool, using original");
+			}
+		}
+		const processedToolNames = Object.keys(processedTools);
+		logger.info({
+			mcpToolName: mcpTool.name,
+			originalToolCount: availableToolNames.length,
+			processedToolCount: processedToolNames.length,
+			processedTools: processedToolNames
+		}, "Completed tool override application");
+		return processedTools;
+	}
 	/**
 	* Format tool result for storage in conversation history
 	*/
@@ -1291,11 +1434,9 @@ ${typeof cleanResult === "string" ? cleanResult : JSON.stringify(cleanResult, nu
 	}
 	async agentHasArtifactComponents() {
 		try {
-			return await agentHasArtifactComponents(dbClient_default)({ scopes: {
-				tenantId: this.config.tenantId,
-				projectId: this.config.projectId,
-				agentId: this.config.agentId
-			} });
+			const subAgents = this.executionContext.project.agents[this.config.agentId]?.subAgents;
+			if (!subAgents) return false;
+			return Object.values(subAgents).some((subAgent) => subAgent.artifactComponents?.length ?? false);
 		} catch (error) {
 			logger.error({
 				error,
@@ -1316,20 +1457,10 @@ ${typeof cleanResult === "string" ? cleanResult : JSON.stringify(cleanResult, nu
 				const conversationId = runtimeContext?.metadata?.conversationId;
 				if (conversationId) this.setConversationId(conversationId);
 				const { conversationHistory, contextBreakdown } = await this.buildConversationHistory(contextId, taskId, userMessage, streamRequestId, initialContextBreakdown);
-				span.setAttributes({
-					"context.breakdown.system_template_tokens": contextBreakdown.systemPromptTemplate,
-					"context.breakdown.core_instructions_tokens": contextBreakdown.coreInstructions,
-					"context.breakdown.agent_prompt_tokens": contextBreakdown.agentPrompt,
-					"context.breakdown.tools_tokens": contextBreakdown.toolsSection,
-					"context.breakdown.artifacts_tokens": contextBreakdown.artifactsSection,
-					"context.breakdown.data_components_tokens": contextBreakdown.dataComponents,
-					"context.breakdown.artifact_components_tokens": contextBreakdown.artifactComponents,
-					"context.breakdown.transfer_instructions_tokens": contextBreakdown.transferInstructions,
-					"context.breakdown.delegation_instructions_tokens": contextBreakdown.delegationInstructions,
-					"context.breakdown.thinking_preparation_tokens": contextBreakdown.thinkingPreparation,
-					"context.breakdown.conversation_history_tokens": contextBreakdown.conversationHistory,
-					"context.breakdown.total_tokens": contextBreakdown.total
-				});
+				const breakdownAttributes = {};
+				for (const componentDef of V1_BREAKDOWN_SCHEMA) breakdownAttributes[componentDef.spanAttribute] = contextBreakdown.components[componentDef.key] ?? 0;
+				breakdownAttributes["context.breakdown.total_tokens"] = contextBreakdown.total;
+				span.setAttributes(breakdownAttributes);
 				const { primaryModelSettings, modelSettings, hasStructuredOutput, shouldStreamPhase1, timeoutMs } = this.configureModelSettings();
 				let response;
 				let textResponse;
@@ -1499,8 +1630,11 @@ ${typeof cleanResult === "string" ? cleanResult : JSON.stringify(cleanResult, nu
 		}
 		const conversationHistoryTokens = estimateTokens(conversationHistory);
 		const updatedContextBreakdown = {
-			...initialContextBreakdown,
-			conversationHistory: conversationHistoryTokens
+			components: {
+				...initialContextBreakdown.components,
+				conversationHistory: conversationHistoryTokens
+			},
+			total: initialContextBreakdown.total
 		};
 		calculateBreakdownTotal(updatedContextBreakdown);
 		return {
@@ -1666,7 +1800,7 @@ ${typeof cleanResult === "string" ? cleanResult : JSON.stringify(cleanResult, nu
 			streamRequestId: this.getStreamRequestId(),
 			subAgentId: this.config.id
 		};
-		return new IncrementalStreamParser(streamHelper, this.config.tenantId, contextId, artifactParserOptions);
+		return new IncrementalStreamParser(streamHelper, this.executionContext, contextId, artifactParserOptions);
 	}
 	buildTelemetryConfig(phase) {
 		return {
@@ -1861,7 +1995,7 @@ ${output}${structureHintsFormatted}`;
 		let formattedContent = response.formattedContent || null;
 		if (!formattedContent) {
 			const session = toolSessionManager.getSession(sessionId);
-			const responseFormatter = new ResponseFormatter(this.config.tenantId, {
+			const responseFormatter = new ResponseFormatter(this.executionContext, {
 				sessionId,
 				taskId: session?.taskId,
 				projectId: session?.projectId,

package/dist/agents/ToolSessionManager.js

@@ -1,9 +1,9 @@
-import { getLogger } from "../logger.js";
+import { getLogger as getLogger$1 } from "../logger.js";
 import { SESSION_CLEANUP_INTERVAL_MS, SESSION_TOOL_RESULT_CACHE_TIMEOUT_MS } from "../constants/execution-limits/index.js";
 import { generateId } from "@inkeep/agents-core";
 
 //#region src/agents/ToolSessionManager.ts
-const logger = getLogger("ToolSessionManager");
+const logger = getLogger$1("ToolSessionManager");
 /**
 * Manages tool execution state during agent generation sessions.
 * Allows tools to access previous tool call results within the same execution.

package/dist/agents/generateTaskHandler.d.ts

@@ -1,6 +1,6 @@
 import { A2ATask, A2ATaskResult } from "../a2a/types.js";
 import { SandboxConfig } from "../types/execution-context.js";
-import { AgentConversationHistoryConfig, CredentialStoreRegistry, SubAgentApiSelect } from "@inkeep/agents-core";
+import { AgentConversationHistoryConfig, CredentialStoreRegistry, FullExecutionContext, SubAgentApiSelect } from "@inkeep/agents-core";
 
 //#region src/agents/generateTaskHandler.d.ts
 
@@ -8,9 +8,7 @@ import { AgentConversationHistoryConfig, CredentialStoreRegistry, SubAgentApiSel
  * Serializable configuration for creating task handlers
  */
 interface TaskHandlerConfig {
-  tenantId: string;
-  projectId: string;
-  agentId: string;
+  executionContext: FullExecutionContext;
   subAgentId: string;
   agentSchema: SubAgentApiSelect;
   name: string;
@@ -33,17 +31,14 @@ declare const serializeTaskHandlerConfig: (config: TaskHandlerConfig) => string;
  */
 declare const deserializeTaskHandlerConfig: (configJson: string) => TaskHandlerConfig;
 /**
- * Creates a task handler configuration from agent data
+ * Creates a task handler configuration from execution context and project data
  */
 declare const createTaskHandlerConfig: (params: {
-  tenantId: string;
-  projectId: string;
-  agentId: string;
+  executionContext: FullExecutionContext;
   subAgentId: string;
   baseUrl: string;
   apiKey?: string;
   sandboxConfig?: SandboxConfig;
-  userId?: string;
 }) => Promise<TaskHandlerConfig>;
 //#endregion
 export { TaskHandlerConfig, createTaskHandler, createTaskHandlerConfig, deserializeTaskHandlerConfig, serializeTaskHandlerConfig };