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

package/dist/agents/relationTools.js

@@ -1,17 +1,22 @@
-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 { getUserIdFromContext } from "../types/execution-context.js";
 import { DELEGATION_TOOL_BACKOFF_EXPONENT, DELEGATION_TOOL_BACKOFF_INITIAL_INTERVAL_MS, DELEGATION_TOOL_BACKOFF_MAX_ELAPSED_TIME_MS, DELEGATION_TOOL_BACKOFF_MAX_INTERVAL_MS } from "../constants/execution-limits/index.js";
 import { toolSessionManager } from "./ToolSessionManager.js";
 import { saveA2AMessageResponse } from "../data/conversations.js";
 import { agentSessionManager } from "../services/AgentSession.js";
+import { getExternalAgentRelationsForTargetSubAgent, getToolsForSubAgent, getTransferRelationsForTargetSubAgent } from "../utils/project.js";
+import { ContextResolver } from "../context/ContextResolver.js";
+import "../context/index.js";
 import { A2AClient } from "../a2a/client.js";
 import { z } from "@hono/zod-openapi";
-import { ContextResolver, CredentialStuffer, SPAN_KEYS, TemplateEngine, createMessage, generateId, generateServiceToken, getCredentialReference, headers } from "@inkeep/agents-core";
+import { CredentialStuffer, InternalServices, ManagementApiClient, SPAN_KEYS, TemplateEngine, createMessage, generateId, generateServiceToken, headers } from "@inkeep/agents-core";
 import { trace } from "@opentelemetry/api";
 import { tool } from "ai";
 
 //#region src/agents/relationTools.ts
-const logger = getLogger("relationships Tools");
+const logger = getLogger$1("relationships Tools");
 const A2A_RETRY_STATUS_CODES = [
 	"429",
 	"500",
@@ -124,7 +129,8 @@ const createTransferToAgentTool = ({ transferConfig, callingAgentId, subAgent, s
 		}
 	});
 };
-function createDelegateToAgentTool({ delegateConfig, callingAgentId, tenantId, projectId, agentId, contextId, metadata, sessionId, subAgent, credentialStoreRegistry }) {
+function createDelegateToAgentTool({ delegateConfig, callingAgentId, executionContext, contextId, metadata, sessionId, subAgent, credentialStoreRegistry }) {
+	const { tenantId, projectId, agentId, project } = executionContext;
 	return tool({
 		description: generateDelegateToolDescription(delegateConfig),
 		inputSchema: z.object({ message: z.string() }),
@@ -148,7 +154,7 @@ function createDelegateToAgentTool({ delegateConfig, callingAgentId, tenantId, p
 			let resolvedHeaders = {};
 			if (isExternal) {
 				if ((delegateConfig.config.credentialReferenceId || delegateConfig.config.headers) && credentialStoreRegistry) {
-					const credentialStuffer = new CredentialStuffer(credentialStoreRegistry, new ContextResolver(tenantId, projectId, dbClient_default, credentialStoreRegistry));
+					const credentialStuffer = new CredentialStuffer(credentialStoreRegistry, new ContextResolver(executionContext, credentialStoreRegistry));
 					const credentialContext = {
 						tenantId,
 						projectId,
@@ -158,13 +164,8 @@ function createDelegateToAgentTool({ delegateConfig, callingAgentId, tenantId, p
 					};
 					let storeReference;
 					if (delegateConfig.config.credentialReferenceId) {
-						const credentialReference = await getCredentialReference(dbClient_default)({
-							scopes: {
-								tenantId,
-								projectId
-							},
-							id: delegateConfig.config.credentialReferenceId
-						});
+						const id = delegateConfig.config.credentialReferenceId;
+						const credentialReference = project.credentialReferences?.[id];
 						if (credentialReference) storeReference = {
 							credentialStoreId: credentialReference.credentialStoreId,
 							retrievalParams: credentialReference.retrievalParams || {}
@@ -177,7 +178,7 @@ function createDelegateToAgentTool({ delegateConfig, callingAgentId, tenantId, p
 					});
 				}
 			} else if (isTeam) {
-				const context$2 = await new ContextResolver(tenantId, projectId, dbClient_default, credentialStoreRegistry).resolveHeaders(metadata.conversationId, contextId);
+				const context$2 = await new ContextResolver(executionContext, credentialStoreRegistry).resolveHeaders(metadata.conversationId, contextId);
 				for (const [key, value] of Object.entries(headers)) resolvedHeaders[key] = TemplateEngine.render(value, context$2, { strict: true });
 				resolvedHeaders.Authorization = `Bearer ${await generateServiceToken({
 					tenantId,
@@ -235,6 +236,7 @@ function createDelegateToAgentTool({ delegateConfig, callingAgentId, tenantId, p
 				fromSubAgentId: callingAgentId,
 				...isInternal ? { toSubAgentId: delegateConfig.config.id } : { toExternalAgentId: delegateConfig.config.id }
 			});
+			logger.info({ messageToSend }, "Created message in database");
 			const response = await a2aClient.sendMessage({ message: messageToSend });
 			if (response.error) throw new Error(response.error.message);
 			await saveA2AMessageResponse(response, {
@@ -269,6 +271,95 @@ function createDelegateToAgentTool({ delegateConfig, callingAgentId, tenantId, p
 		}
 	});
 }
+/**
+* Build a transfer relation config for an internal relation.
+* Fetches tools, transfer relations, and external agent relations for the target sub-agent.
+*/
+async function buildTransferRelationConfig(params) {
+	const { relation, executionContext, baseUrl, apiKey } = params;
+	const { tenantId, projectId, project, agentId } = executionContext;
+	const agent = executionContext.project.agents[agentId];
+	const targetSubAgent = agent.subAgents?.[relation.id];
+	if (!targetSubAgent) throw new Error(`Target sub-agent not found: ${relation.id}`);
+	const targetToolsForSubAgent = getToolsForSubAgent({
+		agent,
+		project,
+		subAgent: targetSubAgent
+	});
+	const manageApiClient = new ManagementApiClient({
+		apiUrl: env.INKEEP_AGENTS_MANAGE_API_URL,
+		tenantId,
+		projectId,
+		auth: {
+			mode: "internalService",
+			internalServiceName: InternalServices.INKEEP_AGENTS_RUN_API
+		},
+		ref: executionContext.resolvedRef.name,
+		userId: getUserIdFromContext(executionContext)
+	});
+	const targetAgentTools = await Promise.all(targetToolsForSubAgent.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$1) => selectedToolsSet.has(tool$1.name)) || [];
+		}
+		return mcpTool;
+	}));
+	const targetTransferRelations = getTransferRelationsForTargetSubAgent({
+		agent,
+		subAgentId: relation.id
+	});
+	const targetExternalAgentRelations = getExternalAgentRelationsForTargetSubAgent({
+		agent,
+		project,
+		subAgentId: relation.id
+	});
+	const targetTransferRelationsConfig = targetTransferRelations.map((rel) => ({
+		baseUrl,
+		apiKey,
+		id: rel.id,
+		tenantId,
+		projectId,
+		agentId,
+		name: rel.name,
+		description: rel.description || void 0,
+		prompt: "",
+		delegateRelations: [],
+		subAgentRelations: [],
+		transferRelations: [],
+		project
+	}));
+	const targetDelegateRelationsConfig = targetExternalAgentRelations.map((rel) => ({
+		type: "external",
+		config: {
+			relationId: rel.relationId || `external-${rel.externalAgent.id}`,
+			id: rel.externalAgent.id,
+			name: rel.externalAgent.name,
+			description: rel.externalAgent.description || "",
+			ref: executionContext.resolvedRef,
+			baseUrl: rel.externalAgent.baseUrl,
+			headers: rel.headers || void 0,
+			credentialReferenceId: rel.externalAgent.credentialReferenceId,
+			relationType: "delegate"
+		}
+	}));
+	return {
+		baseUrl,
+		apiKey,
+		id: relation.id,
+		tenantId,
+		projectId,
+		agentId,
+		name: relation.name,
+		description: relation.description || void 0,
+		prompt: "",
+		delegateRelations: targetDelegateRelationsConfig,
+		subAgentRelations: [],
+		transferRelations: targetTransferRelationsConfig,
+		tools: targetAgentTools
+	};
+}
 
 //#endregion
-export { createDelegateToAgentTool, createTransferToAgentTool };
+export { buildTransferRelationConfig, createDelegateToAgentTool, createTransferToAgentTool };

package/dist/agents/types.d.ts

@@ -1,10 +1,12 @@
 import { AssembleResult } from "../utils/token-estimator.js";
-import { Artifact, ArtifactComponentApiInsert, DataComponentApiInsert } from "@inkeep/agents-core";
+import { Artifact, ArtifactComponentApiInsert, BreakdownComponentDef, DataComponentApiInsert } from "@inkeep/agents-core";
 
 //#region src/agents/types.d.ts
 interface VersionConfig<TConfig> {
   loadTemplates(): Map<string, string>;
   assemble(templates: Map<string, string>, config: TConfig): AssembleResult;
+  /** Returns the breakdown schema defining which components this version tracks */
+  getBreakdownSchema(): BreakdownComponentDef[];
 }
 interface SystemPromptV1 {
   corePrompt: string;
@@ -25,4 +27,4 @@ interface ToolData {
   usageGuidelines?: string;
 }
 //#endregion
-export { SystemPromptV1, ToolData, VersionConfig };
+export { type BreakdownComponentDef, SystemPromptV1, ToolData, VersionConfig };

package/dist/agents/versions/v1/Phase1Config.d.ts

@@ -1,10 +1,11 @@
-import { AssembleResult } from "../../../utils/token-estimator.js";
+import { AssembleResult, BreakdownComponentDef } from "../../../utils/token-estimator.js";
 import { SystemPromptV1, ToolData, VersionConfig } from "../../types.js";
-import { McpTool } from "@inkeep/agents-core";
+import { McpTool, V1_BREAKDOWN_SCHEMA } from "@inkeep/agents-core";
 
 //#region src/agents/versions/v1/Phase1Config.d.ts
 declare class Phase1Config implements VersionConfig<SystemPromptV1> {
   loadTemplates(): Map<string, string>;
+  getBreakdownSchema(): BreakdownComponentDef[];
   static convertMcpToolsToToolData(mcpTools: McpTool[] | undefined): ToolData[];
   private isToolDataArray;
   private normalizeSchema;
@@ -24,4 +25,4 @@ declare class Phase1Config implements VersionConfig<SystemPromptV1> {
   private generateParametersXml;
 }
 //#endregion
-export { Phase1Config };
+export { Phase1Config, V1_BREAKDOWN_SCHEMA };

package/dist/agents/versions/v1/Phase1Config.js

@@ -1,14 +1,15 @@
-import { getLogger } from "../../../logger.js";
+import { getLogger as getLogger$1 } from "../../../logger.js";
 import { calculateBreakdownTotal, createEmptyBreakdown, estimateTokens } from "../../../utils/token-estimator.js";
 import system_prompt_default from "../../../_virtual/_raw_/home/runner/work/agents/agents/agents-run-api/templates/v1/phase1/system-prompt.js";
 import thinking_preparation_default from "../../../_virtual/_raw_/home/runner/work/agents/agents/agents-run-api/templates/v1/phase1/thinking-preparation.js";
 import tool_default from "../../../_virtual/_raw_/home/runner/work/agents/agents/agents-run-api/templates/v1/phase1/tool.js";
 import artifact_default from "../../../_virtual/_raw_/home/runner/work/agents/agents/agents-run-api/templates/v1/shared/artifact.js";
 import artifact_retrieval_guidance_default from "../../../_virtual/_raw_/home/runner/work/agents/agents/agents-run-api/templates/v1/shared/artifact-retrieval-guidance.js";
+import { V1_BREAKDOWN_SCHEMA } from "@inkeep/agents-core";
 import { convertZodToJsonSchema, isZodSchema } from "@inkeep/agents-core/utils/schema-conversion";
 
 //#region src/agents/versions/v1/Phase1Config.ts
-getLogger("Phase1Config");
+getLogger$1("Phase1Config");
 var Phase1Config = class Phase1Config {
 	loadTemplates() {
 		const templates = /* @__PURE__ */ new Map();
@@ -19,15 +20,23 @@ var Phase1Config = class Phase1Config {
 		templates.set("thinking-preparation", thinking_preparation_default);
 		return templates;
 	}
+	getBreakdownSchema() {
+		return V1_BREAKDOWN_SCHEMA;
+	}
 	static convertMcpToolsToToolData(mcpTools) {
 		if (!mcpTools || mcpTools.length === 0) return [];
 		const toolData = [];
-		for (const mcpTool of mcpTools) if (mcpTool.availableTools) for (const toolDef of mcpTool.availableTools) toolData.push({
-			name: toolDef.name,
-			description: toolDef.description || "No description available",
-			inputSchema: toolDef.inputSchema || {},
-			usageGuidelines: `Use this tool from ${mcpTool.name} server when appropriate.`
-		});
+		for (const mcpTool of mcpTools) if (mcpTool.availableTools) for (const toolDef of mcpTool.availableTools) {
+			let usageGuidelines = "";
+			if (mcpTool.config.mcp.prompt) usageGuidelines = `${mcpTool.config.mcp.prompt}\n\n`;
+			usageGuidelines += `Use this tool from ${mcpTool.name} server when appropriate.`;
+			toolData.push({
+				name: toolDef.name,
+				description: toolDef.description || "No description available",
+				inputSchema: toolDef.inputSchema || {},
+				usageGuidelines
+			});
+		}
 		return toolData;
 	}
 	isToolDataArray(tools) {
@@ -45,17 +54,17 @@ var Phase1Config = class Phase1Config {
 		return inputSchema;
 	}
 	assemble(templates, config) {
-		const breakdown = createEmptyBreakdown();
+		const breakdown = createEmptyBreakdown(this.getBreakdownSchema());
 		const systemPromptTemplateContent = templates.get("system-prompt");
 		if (!systemPromptTemplateContent) throw new Error("System prompt template not loaded");
-		breakdown.systemPromptTemplate = estimateTokens(systemPromptTemplateContent.replace("{{CORE_INSTRUCTIONS}}", "").replace("{{AGENT_CONTEXT_SECTION}}", "").replace("{{ARTIFACTS_SECTION}}", "").replace("{{TOOLS_SECTION}}", "").replace("{{THINKING_PREPARATION_INSTRUCTIONS}}", "").replace("{{TRANSFER_INSTRUCTIONS}}", "").replace("{{DELEGATION_INSTRUCTIONS}}", ""));
+		breakdown.components["systemPromptTemplate"] = estimateTokens(systemPromptTemplateContent.replace("{{CORE_INSTRUCTIONS}}", "").replace("{{AGENT_CONTEXT_SECTION}}", "").replace("{{ARTIFACTS_SECTION}}", "").replace("{{TOOLS_SECTION}}", "").replace("{{THINKING_PREPARATION_INSTRUCTIONS}}", "").replace("{{TRANSFER_INSTRUCTIONS}}", "").replace("{{DELEGATION_INSTRUCTIONS}}", ""));
 		let systemPrompt = systemPromptTemplateContent;
 		if (config.corePrompt && config.corePrompt.trim()) {
-			breakdown.coreInstructions = estimateTokens(config.corePrompt);
+			breakdown.components["coreInstructions"] = estimateTokens(config.corePrompt);
 			systemPrompt = systemPrompt.replace("{{CORE_INSTRUCTIONS}}", config.corePrompt);
 		} else systemPrompt = systemPrompt.replace(/<core_instructions>\s*\{\{CORE_INSTRUCTIONS\}\}\s*<\/core_instructions>/g, "");
 		const agentContextSection = this.generateAgentContextSection(config.prompt);
-		breakdown.agentPrompt = estimateTokens(agentContextSection);
+		breakdown.components["agentPrompt"] = estimateTokens(agentContextSection);
 		systemPrompt = systemPrompt.replace("{{AGENT_CONTEXT_SECTION}}", agentContextSection);
 		const toolData = (this.isToolDataArray(config.tools) ? config.tools : Phase1Config.convertMcpToolsToToolData(config.tools)).map((tool) => ({
 			...tool,
@@ -64,21 +73,25 @@ var Phase1Config = class Phase1Config {
 		const hasArtifactComponents = Boolean(config.artifactComponents && config.artifactComponents.length > 0);
 		const artifactsSection = this.generateArtifactsSection(templates, config.artifacts, hasArtifactComponents, config.artifactComponents, config.hasAgentArtifactComponents);
 		const artifactInstructionsTokens = this.getArtifactInstructionsTokens(templates, hasArtifactComponents, config.artifactComponents, config.hasAgentArtifactComponents, (config.artifacts?.length ?? 0) > 0);
-		breakdown.systemPromptTemplate += artifactInstructionsTokens;
-		breakdown.artifactsSection = estimateTokens(config.artifacts?.length > 0 ? config.artifacts.map((artifact) => this.generateArtifactXml(templates, artifact)).join("\n  ") : "");
-		if (hasArtifactComponents) breakdown.artifactComponents = estimateTokens(this.getArtifactCreationInstructions(hasArtifactComponents, config.artifactComponents));
+		breakdown.components["systemPromptTemplate"] += artifactInstructionsTokens;
+		const actualArtifactsXml = config.artifacts?.length > 0 ? config.artifacts.map((artifact) => this.generateArtifactXml(templates, artifact)).join("\n  ") : "";
+		breakdown.components["artifactsSection"] = estimateTokens(actualArtifactsXml);
+		if (hasArtifactComponents) {
+			const creationInstructions = this.getArtifactCreationInstructions(hasArtifactComponents, config.artifactComponents);
+			breakdown.components["artifactComponents"] = estimateTokens(creationInstructions);
+		}
 		systemPrompt = systemPrompt.replace("{{ARTIFACTS_SECTION}}", artifactsSection);
 		const toolsSection = this.generateToolsSection(templates, toolData);
-		breakdown.toolsSection = estimateTokens(toolsSection);
+		breakdown.components["toolsSection"] = estimateTokens(toolsSection);
 		systemPrompt = systemPrompt.replace("{{TOOLS_SECTION}}", toolsSection);
 		const thinkingPreparationSection = this.generateThinkingPreparationSection(templates, config.isThinkingPreparation);
-		breakdown.thinkingPreparation = estimateTokens(thinkingPreparationSection);
+		breakdown.components["thinkingPreparation"] = estimateTokens(thinkingPreparationSection);
 		systemPrompt = systemPrompt.replace("{{THINKING_PREPARATION_INSTRUCTIONS}}", thinkingPreparationSection);
 		const transferSection = this.generateTransferInstructions(config.hasTransferRelations);
-		breakdown.transferInstructions = estimateTokens(transferSection);
+		breakdown.components["transferInstructions"] = estimateTokens(transferSection);
 		systemPrompt = systemPrompt.replace("{{TRANSFER_INSTRUCTIONS}}", transferSection);
 		const delegationSection = this.generateDelegationInstructions(config.hasDelegateRelations);
-		breakdown.delegationInstructions = estimateTokens(delegationSection);
+		breakdown.components["delegationInstructions"] = estimateTokens(delegationSection);
 		systemPrompt = systemPrompt.replace("{{DELEGATION_INSTRUCTIONS}}", delegationSection);
 		calculateBreakdownTotal(breakdown);
 		return {
@@ -432,4 +445,4 @@ ${creationInstructions}
 };
 
 //#endregion
-export { Phase1Config };
+export { Phase1Config, V1_BREAKDOWN_SCHEMA };

package/dist/constants/execution-limits/index.js

@@ -8,7 +8,7 @@ const constantsSchema = z.object(Object.fromEntries(Object.keys(executionLimitsD
 	const defaultValue = executionLimitsDefaults[key];
 	const envKey = `AGENTS_${key}`;
 	if (typeof defaultValue === "boolean") return [envKey, z.coerce.boolean().optional()];
-	else return [envKey, z.coerce.number().optional()];
+	return [envKey, z.coerce.number().optional()];
 })));
 const parseConstants = () => {
 	const envOverrides = constantsSchema.parse(process.env);

package/dist/context/ContextFetcher.d.ts

@@ -0,0 +1,68 @@
+import { ContextFetchDefinition, CredentialStoreRegistry, FullExecutionContext, TemplateContext } from "@inkeep/agents-core";
+
+//#region src/context/ContextFetcher.d.ts
+declare class MissingRequiredVariableError extends Error {
+  constructor(variable: string);
+}
+interface FetchResult {
+  data: unknown;
+  source: string;
+  durationMs: number;
+}
+declare class ContextFetcher {
+  private executionContext;
+  private defaultTimeout;
+  private credentialStuffer?;
+  constructor(executionContext: FullExecutionContext, credentialStoreRegistry?: CredentialStoreRegistry, defaultTimeout?: number);
+  /**
+   * Fetch data according to a fetch definition
+   */
+  fetch(definition: ContextFetchDefinition, context: TemplateContext): Promise<{
+    data: unknown;
+    resolvedUrl: string;
+  }>;
+  private getCredential;
+  /**
+   * Resolve template variables in fetch configuration and inject credential headers
+   */
+  private resolveTemplateVariables;
+  /**
+   * Interpolate template variables in a string using TemplateEngine
+   */
+  private interpolateTemplate;
+  /**
+   * Interpolate template variables in an object recursively using TemplateEngine
+   */
+  private interpolateObjectTemplates;
+  /**
+   * Perform HTTP request
+   */
+  private performRequest;
+  /**
+   * Transform response data using JsonTransformer (JMESPath)
+   */
+  private transformResponse;
+  /**
+   * Validate response against JSON Schema
+   */
+  private validateResponseWithJsonSchema;
+  /**
+   * Test a fetch definition without caching
+   */
+  test(definition: ContextFetchDefinition, context: TemplateContext): Promise<{
+    success: boolean;
+    data?: unknown;
+    resolvedUrl?: string;
+    error?: string;
+    durationMs: number;
+  }>;
+  /**
+   * Get fetcher statistics
+   */
+  getStats(): {
+    tenantId: string;
+    defaultTimeout: number;
+  };
+}
+//#endregion
+export { ContextFetcher, FetchResult, MissingRequiredVariableError };

package/dist/context/ContextFetcher.js

@@ -0,0 +1,276 @@
+import { validateAgainstJsonSchema } from "./validation.js";
+import { CredentialStuffer, JsonTransformer, TemplateEngine, getLogger } from "@inkeep/agents-core";
+
+//#region src/context/ContextFetcher.ts
+const logger = getLogger("context-fetcher");
+var MissingRequiredVariableError = class extends Error {
+	constructor(variable) {
+		super(`Missing required variable: ${variable}`);
+		this.name = "MissingRequiredVariableError";
+	}
+};
+/**
+* GraphQL error checker - validates response for GraphQL errors and throws if found
+*/
+const checkGraphQLErrors = (data) => {
+	if (data && typeof data === "object" && "errors" in data) {
+		const errorObj = data;
+		if (Array.isArray(errorObj.errors) && errorObj.errors.length > 0) {
+			const agentqlErrors = errorObj.errors;
+			const errorMessage = `GraphQL request failed with ${agentqlErrors.length} errors: ${agentqlErrors.map((e) => e.message || "Unknown error").join(", ")}`;
+			throw new Error(errorMessage);
+		}
+	}
+};
+const responseErrorCheckers = [checkGraphQLErrors];
+var ContextFetcher = class {
+	executionContext;
+	defaultTimeout;
+	credentialStuffer;
+	constructor(executionContext, credentialStoreRegistry, defaultTimeout = 1e4) {
+		this.executionContext = executionContext;
+		this.defaultTimeout = defaultTimeout;
+		if (credentialStoreRegistry) this.credentialStuffer = new CredentialStuffer(credentialStoreRegistry);
+		logger.info({
+			tenantId: this.executionContext.tenantId,
+			defaultTimeout: this.defaultTimeout,
+			hasCredentialSupport: !!this.credentialStuffer
+		}, "ContextFetcher initialized");
+	}
+	/**
+	* Fetch data according to a fetch definition
+	*/
+	async fetch(definition, context) {
+		const startTime = Date.now();
+		logger.info({
+			definitionId: definition.id,
+			url: definition.fetchConfig.url
+		}, "Starting context fetch");
+		try {
+			const resolvedConfig = await this.resolveTemplateVariables(definition.fetchConfig, context, definition.credentialReferenceId);
+			const response = await this.performRequest(resolvedConfig);
+			let transformedData = response.data;
+			if (definition.fetchConfig.transform) transformedData = await this.transformResponse(response.data, definition.fetchConfig.transform);
+			if (definition.responseSchema) this.validateResponseWithJsonSchema(transformedData, definition.responseSchema, definition.id);
+			const durationMs = Date.now() - startTime;
+			logger.info({
+				definitionId: definition.id,
+				source: response.source,
+				durationMs
+			}, "Context fetch completed successfully");
+			return {
+				data: transformedData,
+				resolvedUrl: resolvedConfig.url
+			};
+		} catch (error) {
+			const durationMs = Date.now() - startTime;
+			const errorMessage = error instanceof Error ? error.message : "Unknown error";
+			if (error instanceof MissingRequiredVariableError) logger.error({
+				definitionId: definition.id,
+				error: errorMessage,
+				durationMs
+			}, "Context fetch skipped due to missing required variable");
+			logger.error({
+				definitionId: definition.id,
+				error: errorMessage,
+				durationMs
+			}, "Context fetch failed");
+			throw error;
+		}
+	}
+	async getCredential(credentialReferenceId) {
+		const { project, tenantId, projectId } = this.executionContext;
+		try {
+			const credentialReference = project.credentialReferences?.[credentialReferenceId];
+			logger.info({ credentialReference }, "Credential reference");
+			if (!credentialReference || !this.credentialStuffer) throw new Error(`Credential store not found for reference ID: ${credentialReferenceId}`);
+			const credentialContext = {
+				tenantId,
+				projectId
+			};
+			const storeReference = {
+				credentialStoreId: credentialReference.credentialStoreId,
+				retrievalParams: credentialReference.retrievalParams || {}
+			};
+			return await this.credentialStuffer.getCredentials(credentialContext, storeReference);
+		} catch (error) {
+			logger.error({
+				credentialReferenceId,
+				error: error instanceof Error ? error.message : "Unknown error"
+			}, "Failed to resolve credentials for fetch request");
+			throw error;
+		}
+	}
+	/**
+	* Resolve template variables in fetch configuration and inject credential headers
+	*/
+	async resolveTemplateVariables(fetchConfig, context, credentialReferenceId) {
+		const resolved = { ...fetchConfig };
+		const filteredRequiredToFetch = fetchConfig.requiredToFetch?.filter((variable) => variable.startsWith("{{") && variable.endsWith("}}"));
+		if (filteredRequiredToFetch) for (const variable of filteredRequiredToFetch) {
+			let resolvedVariable;
+			try {
+				resolvedVariable = this.interpolateTemplate(variable, context);
+			} catch {
+				throw new MissingRequiredVariableError(variable);
+			}
+			if (resolvedVariable === "" || resolvedVariable === variable) throw new MissingRequiredVariableError(variable);
+		}
+		resolved.url = this.interpolateTemplate(fetchConfig.url, context);
+		logger.info({ resolvedUrl: resolved.url }, "Resolved URL");
+		if (fetchConfig.headers) {
+			resolved.headers = {};
+			for (const [key, value] of Object.entries(fetchConfig.headers)) resolved.headers[key] = this.interpolateTemplate(value, context);
+		}
+		if (fetchConfig.body) resolved.body = this.interpolateObjectTemplates(fetchConfig.body, context);
+		if (credentialReferenceId && this.credentialStuffer) try {
+			const credentialHeaders = (await this.getCredential(credentialReferenceId))?.headers;
+			if (credentialHeaders) {
+				resolved.headers = {
+					...resolved.headers,
+					...credentialHeaders
+				};
+				logger.info({ credentialReferenceId }, "Added credential headers to fetch request");
+			}
+		} catch (error) {
+			logger.error({
+				credentialReferenceId,
+				error: error instanceof Error ? error.message : "Unknown error"
+			}, "Failed to resolve credentials for fetch request");
+			throw error;
+		}
+		return resolved;
+	}
+	/**
+	* Interpolate template variables in a string using TemplateEngine
+	*/
+	interpolateTemplate(template, context) {
+		try {
+			return TemplateEngine.render(template, context, {
+				strict: false,
+				preserveUnresolved: true
+			});
+		} catch (error) {
+			logger.error({
+				template,
+				error: error instanceof Error ? error.message : "Unknown error"
+			}, "Failed to interpolate template variable");
+			return template;
+		}
+	}
+	/**
+	* Interpolate template variables in an object recursively using TemplateEngine
+	*/
+	interpolateObjectTemplates(obj, context) {
+		const result = {};
+		for (const [key, value] of Object.entries(obj)) if (typeof value === "string") result[key] = this.interpolateTemplate(value, context);
+		else if (value && typeof value === "object" && !Array.isArray(value)) result[key] = this.interpolateObjectTemplates(value, context);
+		else result[key] = value;
+		return result;
+	}
+	/**
+	* Perform HTTP request
+	*/
+	async performRequest(config) {
+		const startTime = Date.now();
+		try {
+			logger.debug({
+				url: config.url,
+				method: config.method
+			}, "Performing HTTP request");
+			const response = await fetch(config.url, {
+				method: config.method,
+				headers: config.headers,
+				body: config.body ? JSON.stringify(config.body) : void 0,
+				signal: AbortSignal.timeout(config.timeout || this.defaultTimeout)
+			});
+			if (!response.ok) {
+				const errorText = await response.text();
+				throw /* @__PURE__ */ new Error(`HTTP ${response.status}: ${response.statusText} - ${errorText}`);
+			}
+			const contentType = response.headers.get("content-type") || "";
+			let data;
+			if (contentType.includes("application/json")) data = await response.json();
+			else data = await response.text();
+			const durationMs = Date.now() - startTime;
+			for (const checker of responseErrorCheckers) checker(data);
+			return {
+				data,
+				source: config.url,
+				durationMs
+			};
+		} catch (error) {
+			const durationMs = Date.now() - startTime;
+			const requestError = error instanceof Error ? error : /* @__PURE__ */ new Error("Unknown error");
+			logger.warn({
+				url: config.url,
+				error: requestError.message,
+				durationMs
+			}, "HTTP request failed");
+			throw requestError;
+		}
+	}
+	/**
+	* Transform response data using JsonTransformer (JMESPath)
+	*/
+	async transformResponse(data, transform) {
+		try {
+			return await JsonTransformer.transform(data, transform);
+		} catch (error) {
+			logger.error({
+				transform,
+				error: error instanceof Error ? error.message : "Unknown error"
+			}, "Failed to transform response data");
+			return data;
+		}
+	}
+	/**
+	* Validate response against JSON Schema
+	*/
+	validateResponseWithJsonSchema(data, jsonSchema, definitionId) {
+		try {
+			if (!validateAgainstJsonSchema(jsonSchema, data)) throw new Error("Data does not match JSON Schema");
+		} catch (error) {
+			const errorMessage = error instanceof Error ? error.message : "Unknown validation error";
+			logger.error({
+				definitionId,
+				jsonSchema,
+				error: errorMessage
+			}, "JSON Schema response validation failed");
+			throw new Error(`Response validation failed: ${errorMessage}`);
+		}
+	}
+	/**
+	* Test a fetch definition without caching
+	*/
+	async test(definition, context) {
+		const startTime = Date.now();
+		try {
+			const result = await this.fetch(definition, context);
+			return {
+				success: true,
+				data: result.data,
+				resolvedUrl: result.resolvedUrl,
+				durationMs: Date.now() - startTime
+			};
+		} catch (error) {
+			return {
+				success: false,
+				error: error instanceof Error ? error.message : "Unknown error",
+				durationMs: Date.now() - startTime
+			};
+		}
+	}
+	/**
+	* Get fetcher statistics
+	*/
+	getStats() {
+		return {
+			tenantId: this.executionContext.tenantId,
+			defaultTimeout: this.defaultTimeout
+		};
+	}
+};
+
+//#endregion
+export { ContextFetcher, MissingRequiredVariableError };