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

package/dist/context/ContextResolver.d.ts

@@ -0,0 +1,56 @@
+import { ContextConfigApiSelect, CredentialStoreRegistry, FullExecutionContext } from "@inkeep/agents-core";
+
+//#region src/context/ContextResolver.d.ts
+interface ResolvedContext {
+  [templateKey: string]: unknown;
+}
+interface ContextResolutionOptions {
+  triggerEvent: 'initialization' | 'invocation';
+  conversationId: string;
+  headers?: Record<string, unknown>;
+  tenantId: string;
+}
+interface ContextResolutionResult {
+  resolvedContext: ResolvedContext;
+  headers: Record<string, unknown>;
+  fetchedDefinitions: string[];
+  cacheHits: string[];
+  cacheMisses: string[];
+  errors: Array<{
+    definitionId: string;
+    error: string;
+  }>;
+  skipped: Array<{
+    definitionId: string;
+    reason: string;
+  }>;
+  totalDurationMs: number;
+}
+declare class ContextResolver {
+  private fetcher;
+  private cache;
+  private executionContext;
+  constructor(executionContext: FullExecutionContext, credentialStoreRegistry?: CredentialStoreRegistry);
+  /**
+   * Resolve all contexts for a given configuration and trigger event
+   */
+  resolve(contextConfig: ContextConfigApiSelect, options: ContextResolutionOptions): Promise<ContextResolutionResult>;
+  /**
+   * Resolve a single context variable
+   */
+  private resolveSingleFetchDefinition;
+  /**
+   * Resolve the headers for a given conversation
+   */
+  resolveHeaders(conversationId: string, contextConfigId: string): Promise<Record<string, unknown>>;
+  /**
+   * Create a hash of the headers for cache invalidation
+   */
+  private createRequestHash;
+  /**
+   * Clear cache
+   */
+  clearCache(tenantId: string, projectId: string, conversationId: string): Promise<void>;
+}
+//#endregion
+export { ContextResolutionOptions, ContextResolutionResult, ContextResolver, ResolvedContext };

package/dist/context/ContextResolver.js

@@ -0,0 +1,273 @@
+import { ContextCache } from "./contextCache.js";
+import { ContextFetcher, MissingRequiredVariableError } from "./ContextFetcher.js";
+import { getLogger, getTracer, setSpanWithError } from "@inkeep/agents-core";
+import { SpanStatusCode } from "@opentelemetry/api";
+import crypto from "node:crypto";
+
+//#region src/context/ContextResolver.ts
+const logger = getLogger("context-resolver");
+const tracer = getTracer("context-resolver");
+var ContextResolver = class {
+	fetcher;
+	cache;
+	executionContext;
+	constructor(executionContext, credentialStoreRegistry) {
+		this.executionContext = executionContext;
+		this.fetcher = new ContextFetcher(executionContext, credentialStoreRegistry);
+		this.cache = new ContextCache(executionContext);
+		logger.info({
+			tenantId: this.executionContext.tenantId,
+			hasCredentialSupport: !!credentialStoreRegistry
+		}, "ContextResolver initialized");
+	}
+	/**
+	* Resolve all contexts for a given configuration and trigger event
+	*/
+	async resolve(contextConfig, options) {
+		const startTime = Date.now();
+		logger.info({
+			contextConfigId: contextConfig.id,
+			triggerEvent: options.triggerEvent,
+			conversationId: options.conversationId
+		}, "Starting context resolution");
+		return tracer.startActiveSpan("context.resolve", { attributes: {
+			"context.config_id": contextConfig.id,
+			"context.trigger_event": options.triggerEvent
+		} }, async (parentSpan) => {
+			try {
+				const result = {
+					resolvedContext: {},
+					headers: options.headers || {},
+					fetchedDefinitions: [],
+					cacheHits: [],
+					cacheMisses: [],
+					errors: [],
+					skipped: [],
+					totalDurationMs: 0
+				};
+				result.resolvedContext.headers = result.headers;
+				const currentHeaders = await this.cache.get({
+					conversationId: options.conversationId,
+					contextConfigId: contextConfig.id,
+					contextVariableKey: "headers"
+				});
+				if (options.headers && Object.keys(options.headers).length > 0) {
+					await this.cache.invalidateHeaders(this.executionContext.tenantId, this.executionContext.projectId, options.conversationId, contextConfig.id);
+					logger.info({
+						conversationId: options.conversationId,
+						contextConfigId: contextConfig.id
+					}, "Invalidated headers in cache");
+					await this.cache.set({
+						contextConfigId: contextConfig.id,
+						contextVariableKey: "headers",
+						conversationId: options.conversationId,
+						value: options.headers,
+						tenantId: this.executionContext.tenantId
+					});
+					logger.info({
+						conversationId: options.conversationId,
+						contextConfigId: contextConfig.id
+					}, "Headers set in cache");
+				} else if (currentHeaders) result.headers = currentHeaders.value;
+				else result.headers = {};
+				result.resolvedContext.headers = result.headers;
+				const contextVariables = contextConfig.contextVariables || {};
+				const contextVariableEntries = Object.entries(contextVariables);
+				if (contextVariableEntries.length === 0) {
+					logger.info({ contextConfigId: contextConfig.id }, "No context variables in context config");
+					result.totalDurationMs = Date.now() - startTime;
+					parentSpan.setStatus({ code: SpanStatusCode.OK });
+					return result;
+				}
+				contextVariableEntries.filter(([, def]) => def.trigger === "initialization");
+				const invocationDefs = contextVariableEntries.filter(([, def]) => def.trigger === "invocation");
+				if (options.triggerEvent === "invocation" && invocationDefs.length > 0) await this.cache.invalidateInvocationDefinitions(this.executionContext.tenantId, this.executionContext.projectId, options.conversationId, contextConfig.id, invocationDefs.map(([, def]) => def.id));
+				const requestHash = this.createRequestHash(result.headers);
+				const fetchPromises = contextVariableEntries.map(([templateKey, definition]) => this.resolveSingleFetchDefinition(contextConfig, definition, templateKey, options, requestHash, result).catch((error) => {
+					const errorMessage = error instanceof Error ? error.message : "Unknown error";
+					if (error instanceof MissingRequiredVariableError) {
+						logger.info({
+							contextConfigId: contextConfig.id,
+							definitionId: definition.id,
+							templateKey,
+							reason: errorMessage
+						}, "Context fetch skipped due to missing required variable");
+						result.skipped.push({
+							definitionId: definition.id,
+							reason: errorMessage
+						});
+						if (definition.defaultValue !== void 0) {
+							result.resolvedContext[templateKey] = definition.defaultValue;
+							logger.info({
+								contextConfigId: contextConfig.id,
+								definitionId: definition.id,
+								templateKey
+							}, "Using default value for skipped context variable");
+						}
+						return;
+					}
+					logger.error({
+						contextConfigId: contextConfig.id,
+						definitionId: definition.id,
+						templateKey,
+						error: errorMessage
+					}, "Failed to resolve context variable");
+					result.errors.push({
+						definitionId: definition.id,
+						error: errorMessage
+					});
+					if (definition.defaultValue !== void 0) {
+						result.resolvedContext[templateKey] = definition.defaultValue;
+						logger.info({
+							contextConfigId: contextConfig.id,
+							definitionId: definition.id,
+							templateKey
+						}, "Using default value for failed context variable");
+					}
+				}));
+				await Promise.all(fetchPromises);
+				result.totalDurationMs = Date.now() - startTime;
+				parentSpan.addEvent("context.resolution.completed", {
+					resolved_keys: Object.keys(result.resolvedContext),
+					fetched_definitions: result.fetchedDefinitions,
+					skipped_definitions: result.skipped.map((s) => s.definitionId)
+				});
+				if (result.errors.length > 0) parentSpan.setStatus({
+					code: SpanStatusCode.ERROR,
+					message: `Context resolution completed with errors`
+				});
+				else parentSpan.setStatus({ code: SpanStatusCode.OK });
+				logger.info({
+					contextConfigId: contextConfig.id,
+					resolvedKeys: Object.keys(result.resolvedContext),
+					fetchedDefinitions: result.fetchedDefinitions.length,
+					cacheHits: result.cacheHits.length,
+					cacheMisses: result.cacheMisses.length,
+					errors: result.errors.length,
+					skipped: result.skipped.length,
+					totalDurationMs: result.totalDurationMs
+				}, "Context resolution completed");
+				return result;
+			} catch (error) {
+				const durationMs = Date.now() - startTime;
+				setSpanWithError(parentSpan, error instanceof Error ? error : new Error(String(error)));
+				logger.error({
+					contextConfigId: contextConfig.id,
+					error: error instanceof Error ? error.message : String(error),
+					durationMs
+				}, "Context resolution failed");
+				throw error;
+			} finally {
+				parentSpan.end();
+			}
+		});
+	}
+	/**
+	* Resolve a single context variable
+	*/
+	async resolveSingleFetchDefinition(contextConfig, definition, templateKey, options, requestHash, result) {
+		const cachedEntry = await this.cache.get({
+			conversationId: options.conversationId,
+			contextConfigId: contextConfig.id,
+			contextVariableKey: templateKey,
+			requestHash
+		});
+		if (cachedEntry) {
+			result.resolvedContext[templateKey] = cachedEntry.value;
+			result.cacheHits.push(definition.id);
+			logger.debug({
+				definitionId: definition.id,
+				templateKey,
+				conversationId: options.conversationId
+			}, "Cache hit for context variable");
+			return;
+		}
+		result.cacheMisses.push(definition.id);
+		logger.debug({
+			definitionId: definition.id,
+			templateKey,
+			conversationId: options.conversationId
+		}, "Cache miss for context variable, fetching data");
+		const definitionWithConversationId = {
+			...definition,
+			fetchConfig: {
+				...definition.fetchConfig,
+				conversationId: options.conversationId
+			}
+		};
+		const fetchedData = await tracer.startActiveSpan("context-resolver.resolve_single_fetch_definition", { attributes: {
+			"context.definition_id": definition.id,
+			"context.template_key": templateKey,
+			"context.url_template": definition.fetchConfig.url,
+			"context.method": definition.fetchConfig.method,
+			"context.trigger": definition.trigger
+		} }, async (parentSpan) => {
+			try {
+				const { data, resolvedUrl } = await this.fetcher.fetch(definitionWithConversationId, result.resolvedContext);
+				parentSpan.setStatus({ code: SpanStatusCode.OK });
+				parentSpan.addEvent("context.fetch_success", {
+					definition_id: definition.id,
+					template_key: templateKey,
+					source: resolvedUrl
+				});
+				return data;
+			} catch (error) {
+				if (error instanceof MissingRequiredVariableError) {
+					parentSpan.setStatus({ code: SpanStatusCode.OK });
+					parentSpan.addEvent("context.fetch_skipped", {
+						definition_id: definition.id,
+						template_key: templateKey,
+						reason: error.message
+					});
+				} else setSpanWithError(parentSpan, error instanceof Error ? error : new Error(String(error)));
+				throw error;
+			} finally {
+				parentSpan.end();
+			}
+		});
+		result.resolvedContext[templateKey] = fetchedData;
+		result.fetchedDefinitions.push(definition.id);
+		await this.cache.set({
+			contextConfigId: contextConfig.id,
+			contextVariableKey: templateKey,
+			conversationId: options.conversationId,
+			value: fetchedData,
+			requestHash,
+			tenantId: this.executionContext.tenantId
+		});
+		logger.debug({
+			definitionId: definition.id,
+			templateKey,
+			conversationId: options.conversationId
+		}, "Context variable resolved and cached");
+	}
+	/**
+	* Resolve the headers for a given conversation
+	*/
+	async resolveHeaders(conversationId, contextConfigId) {
+		const cachedEntry = await this.cache.get({
+			conversationId,
+			contextConfigId,
+			contextVariableKey: "headers"
+		});
+		if (cachedEntry) return cachedEntry.value;
+		return {};
+	}
+	/**
+	* Create a hash of the headers for cache invalidation
+	*/
+	createRequestHash(headers$1) {
+		const contextString = JSON.stringify(headers$1, Object.keys(headers$1).sort());
+		return crypto.createHash("sha256").update(contextString).digest("hex").substring(0, 16);
+	}
+	/**
+	* Clear cache
+	*/
+	async clearCache(tenantId, projectId, conversationId) {
+		await this.cache.clearConversation(tenantId, projectId, conversationId);
+		logger.info({ conversationId }, "Context cache cleared for conversation");
+	}
+};
+
+//#endregion
+export { ContextResolver };

package/dist/context/context.d.ts

@@ -0,0 +1,19 @@
+import { ResolvedContext } from "./ContextResolver.js";
+import { CredentialStoreRegistry, FullExecutionContext } from "@inkeep/agents-core";
+
+//#region src/context/context.d.ts
+declare function determineContextTrigger(tenantId: string, projectId: string, conversationId: string): Promise<'initialization' | 'invocation'>;
+declare function handleContextConfigChange(executionContext: FullExecutionContext, conversationId: string, newContextConfigId: string, credentialStores?: CredentialStoreRegistry): Promise<void>;
+declare function handleContextResolution({
+  executionContext,
+  conversationId,
+  headers,
+  credentialStores
+}: {
+  executionContext: FullExecutionContext;
+  conversationId: string;
+  headers: Record<string, unknown>;
+  credentialStores?: CredentialStoreRegistry;
+}): Promise<ResolvedContext | null>;
+//#endregion
+export { determineContextTrigger, handleContextConfigChange, handleContextResolution };

package/dist/context/context.js

@@ -0,0 +1,108 @@
+import dbClient_default from "../data/db/dbClient.js";
+import { ContextResolver } from "./ContextResolver.js";
+import { getConversation, getLogger, getTracer, setSpanWithError, updateConversation } from "@inkeep/agents-core";
+import { SpanStatusCode } from "@opentelemetry/api";
+
+//#region src/context/context.ts
+const logger = getLogger("context");
+const tracer = getTracer("context");
+async function determineContextTrigger(tenantId, projectId, conversationId) {
+	const conversation = await getConversation(dbClient_default)({
+		scopes: {
+			tenantId,
+			projectId
+		},
+		conversationId
+	});
+	if (!conversation || !conversation.lastContextResolution) return "initialization";
+	return "invocation";
+}
+async function handleContextConfigChange(executionContext, conversationId, newContextConfigId, credentialStores) {
+	const { tenantId, projectId, agentId } = executionContext;
+	const conversation = await getConversation(dbClient_default)({
+		scopes: {
+			tenantId,
+			projectId
+		},
+		conversationId
+	});
+	if (!conversation) return;
+	if (conversation.lastContextResolution) {
+		await new ContextResolver(executionContext, credentialStores).clearCache(tenantId, projectId, conversationId);
+		logger.info({
+			conversationId,
+			agentId,
+			contextConfigId: newContextConfigId
+		}, "Potential context config change for existing conversation, cache cleared");
+	}
+}
+async function handleContextResolution({ executionContext, conversationId, headers: headers$1, credentialStores }) {
+	return tracer.startActiveSpan("context.handle_context_resolution", { attributes: { "context.headers_keys": Object.keys(headers$1) } }, async (parentSpan) => {
+		const { tenantId, projectId, agentId, project } = executionContext;
+		const agent = project.agents[agentId];
+		let trigger;
+		try {
+			const contextConfig = agent.contextConfig;
+			if (!contextConfig) {
+				logger.debug({ agentId }, "No context config found for agent");
+				return null;
+			}
+			await handleContextConfigChange(executionContext, conversationId, contextConfig.id, credentialStores);
+			trigger = await determineContextTrigger(tenantId, projectId, conversationId);
+			const contextResult = await new ContextResolver(executionContext, credentialStores).resolve(contextConfig, {
+				triggerEvent: trigger,
+				conversationId,
+				headers: headers$1,
+				tenantId
+			});
+			logger.info({ contextResult }, "Context result");
+			const resolvedContext = {
+				...contextResult.resolvedContext,
+				$env: process.env
+			};
+			await updateConversation(dbClient_default)({
+				scopes: {
+					tenantId,
+					projectId
+				},
+				conversationId,
+				data: { lastContextResolution: (/* @__PURE__ */ new Date()).toISOString() }
+			});
+			if (contextResult.errors.length > 0) parentSpan.setStatus({
+				code: SpanStatusCode.ERROR,
+				message: `Context resolution completed with errors`
+			});
+			else parentSpan.setStatus({ code: SpanStatusCode.OK });
+			logger.info({
+				conversationId,
+				agentId,
+				contextConfigId: contextConfig.id,
+				trigger,
+				resolvedKeys: Object.keys(resolvedContext),
+				cacheHits: contextResult.cacheHits.length,
+				cacheMisses: contextResult.cacheMisses.length,
+				fetchedDefinitions: contextResult.fetchedDefinitions.length,
+				errors: contextResult.errors.length
+			}, "Context resolution completed (contextConfigId derived from agent)");
+			return resolvedContext;
+		} catch (error) {
+			const errorMessage = error instanceof Error ? error.message : "Unknown error";
+			parentSpan.setAttributes({
+				"context.final_status": "failed",
+				"context.error_message": errorMessage
+			});
+			setSpanWithError(parentSpan, error instanceof Error ? error : new Error(String(error)));
+			logger.error({
+				error: errorMessage,
+				contextConfigId: agent?.contextConfig?.id,
+				trigger: await determineContextTrigger(tenantId, projectId, conversationId).catch(() => "unknown")
+			}, "Failed to resolve context, proceeding without context resolution");
+			return null;
+		} finally {
+			parentSpan.end();
+		}
+	});
+}
+
+//#endregion
+export { determineContextTrigger, handleContextConfigChange, handleContextResolution };

package/dist/context/contextCache.d.ts

@@ -0,0 +1,56 @@
+import { FullExecutionContext } from "@inkeep/agents-core";
+
+//#region src/context/contextCache.d.ts
+interface CacheEntry {
+  contextConfigId: string;
+  contextVariableKey: string;
+  conversationId: string;
+  value: unknown;
+  requestHash?: string;
+  tenantId: string;
+}
+/**
+ * Context cache with request hash-based invalidation and graceful error handling.
+ *
+ * Implements conversation-scoped caching with smart cache invalidation based on
+ * request hash changes. All cache errors are treated as cache misses to ensure
+ * system reliability.
+ */
+declare class ContextCache {
+  private executionContext;
+  constructor(executionContext: FullExecutionContext);
+  /**
+   * Get cached context data for a conversation
+   */
+  get({
+    conversationId,
+    contextConfigId,
+    contextVariableKey,
+    requestHash
+  }: {
+    conversationId: string;
+    contextConfigId: string;
+    contextVariableKey: string;
+    requestHash?: string;
+  }): Promise<CacheEntry | null>;
+  /**
+   * Set cached context data for a conversation
+   */
+  set(entry: CacheEntry): Promise<void>;
+  /**
+   * Clear cache entries for a specific conversation
+   */
+  clearConversation(tenantId: string, projectId: string, conversationId: string): Promise<void>;
+  /**
+   * Clear all cache entries for a specific context configuration
+   */
+  clearContextConfig(tenantId: string, projectId: string, contextConfigId: string): Promise<void>;
+  /**
+   * Clean up expired or orphaned cache entries
+   */
+  cleanup(): Promise<void>;
+  invalidateInvocationDefinitions(tenantId: string, projectId: string, conversationId: string, contextConfigId: string, definitionIds: string[]): Promise<void>;
+  invalidateHeaders(tenantId: string, projectId: string, conversationId: string, contextConfigId: string): Promise<void>;
+}
+//#endregion
+export { CacheEntry, ContextCache };

package/dist/context/contextCache.js

@@ -0,0 +1,175 @@
+import dbClient_default from "../data/db/dbClient.js";
+import { cleanupTenantCache, clearContextConfigCache, clearConversationCache, generateId, getCacheEntry, getLogger, invalidateHeadersCache, invalidateInvocationDefinitionsCache, setCacheEntry } from "@inkeep/agents-core";
+
+//#region src/context/contextCache.ts
+const logger = getLogger("context-cache");
+/**
+* Context cache with request hash-based invalidation and graceful error handling.
+*
+* Implements conversation-scoped caching with smart cache invalidation based on
+* request hash changes. All cache errors are treated as cache misses to ensure
+* system reliability.
+*/
+var ContextCache = class {
+	executionContext;
+	constructor(executionContext) {
+		this.executionContext = executionContext;
+		logger.info({ tenantId: this.executionContext.tenantId }, "ContextCache initialized");
+	}
+	/**
+	* Get cached context data for a conversation
+	*/
+	async get({ conversationId, contextConfigId, contextVariableKey, requestHash }) {
+		try {
+			let cacheEntry;
+			cacheEntry = await getCacheEntry(dbClient_default)({
+				conversationId,
+				contextConfigId,
+				contextVariableKey,
+				requestHash
+			});
+			if (!cacheEntry) return null;
+			return {
+				contextConfigId: cacheEntry.contextConfigId,
+				contextVariableKey: cacheEntry.contextVariableKey,
+				conversationId: cacheEntry.conversationId,
+				value: cacheEntry.value,
+				requestHash: cacheEntry.requestHash || void 0,
+				tenantId: this.executionContext.tenantId
+			};
+		} catch (error) {
+			logger.error({
+				conversationId,
+				contextConfigId,
+				contextVariableKey,
+				error: error instanceof Error ? error.message : "Unknown error"
+			}, "Failed to get cache entry");
+			return null;
+		}
+	}
+	/**
+	* Set cached context data for a conversation
+	*/
+	async set(entry) {
+		try {
+			const { tenantId, projectId } = this.executionContext;
+			const cacheData = {
+				id: generateId(),
+				tenantId,
+				projectId,
+				conversationId: entry.conversationId,
+				contextConfigId: entry.contextConfigId,
+				contextVariableKey: entry.contextVariableKey,
+				value: entry.value,
+				requestHash: entry.requestHash,
+				fetchedAt: (/* @__PURE__ */ new Date()).toISOString(),
+				fetchSource: `${entry.contextConfigId}:${entry.contextVariableKey}`,
+				createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+				updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+				ref: this.executionContext.resolvedRef
+			};
+			await setCacheEntry(dbClient_default)(cacheData);
+			logger.debug({
+				conversationId: entry.conversationId,
+				contextConfigId: entry.contextConfigId,
+				contextVariableKey: entry.contextVariableKey
+			}, "Cache entry set successfully");
+		} catch (error) {
+			logger.error({
+				conversationId: entry.conversationId,
+				contextConfigId: entry.contextConfigId,
+				contextVariableKey: entry.contextVariableKey,
+				error: error instanceof Error ? error.message : "Unknown error"
+			}, "Failed to set cache entry");
+		}
+	}
+	/**
+	* Clear cache entries for a specific conversation
+	*/
+	async clearConversation(tenantId, projectId, conversationId) {
+		try {
+			let result;
+			result = await clearConversationCache(dbClient_default)({
+				scopes: {
+					tenantId,
+					projectId
+				},
+				conversationId
+			});
+			logger.info({
+				conversationId,
+				rowsCleared: result
+			}, "Conversation cache cleared successfully");
+		} catch (error) {
+			logger.error({
+				conversationId,
+				error: error instanceof Error ? error.message : "Unknown error"
+			}, "Failed to clear conversation cache");
+			throw error;
+		}
+	}
+	/**
+	* Clear all cache entries for a specific context configuration
+	*/
+	async clearContextConfig(tenantId, projectId, contextConfigId) {
+		try {
+			const result = await clearContextConfigCache(dbClient_default)({
+				scopes: {
+					tenantId,
+					projectId
+				},
+				contextConfigId
+			});
+			logger.info({
+				contextConfigId,
+				rowsCleared: result
+			}, "Context config cache cleared successfully");
+		} catch (error) {
+			logger.error({
+				contextConfigId,
+				error: error instanceof Error ? error.message : "Unknown error"
+			}, "Failed to clear context config cache");
+			throw error;
+		}
+	}
+	/**
+	* Clean up expired or orphaned cache entries
+	*/
+	async cleanup() {
+		try {
+			const { tenantId, projectId } = this.executionContext;
+			const result = await cleanupTenantCache(dbClient_default)({ scopes: {
+				tenantId,
+				projectId
+			} });
+			logger.info({ rowsCleared: result }, "Cache cleanup completed");
+		} catch (error) {
+			logger.error({ error: error instanceof Error ? error.message : "Unknown error" }, "Failed to cleanup cache");
+			throw error;
+		}
+	}
+	async invalidateInvocationDefinitions(tenantId, projectId, conversationId, contextConfigId, definitionIds) {
+		await invalidateInvocationDefinitionsCache(dbClient_default)({
+			scopes: {
+				tenantId,
+				projectId
+			},
+			conversationId,
+			contextConfigId,
+			invocationDefinitionIds: definitionIds
+		});
+	}
+	async invalidateHeaders(tenantId, projectId, conversationId, contextConfigId) {
+		await invalidateHeadersCache(dbClient_default)({
+			scopes: {
+				tenantId,
+				projectId
+			},
+			conversationId,
+			contextConfigId
+		});
+	}
+};
+
+//#endregion
+export { ContextCache };

package/dist/context/index.d.ts

@@ -0,0 +1,6 @@
+import { ContextFetcher, FetchResult, MissingRequiredVariableError } from "./ContextFetcher.js";
+import { ContextResolutionOptions, ContextResolutionResult, ContextResolver, ResolvedContext } from "./ContextResolver.js";
+import { determineContextTrigger, handleContextConfigChange, handleContextResolution } from "./context.js";
+import { CacheEntry, ContextCache } from "./contextCache.js";
+import { ContextValidationError, ContextValidationResult, HTTP_REQUEST_PARTS, HttpRequestPart, ParsedHttpRequest, contextValidationMiddleware, getCachedValidator, isValidHttpRequest, validateAgainstJsonSchema, validateHeaders, validateHttpRequestHeaders, validationHelper } from "./validation.js";
+export { type CacheEntry, ContextCache, ContextFetcher, type ContextResolutionOptions, type ContextResolutionResult, ContextResolver, type ContextValidationError, type ContextValidationResult, type FetchResult, HTTP_REQUEST_PARTS, type HttpRequestPart, MissingRequiredVariableError, type ParsedHttpRequest, type ResolvedContext, contextValidationMiddleware, determineContextTrigger, getCachedValidator, handleContextConfigChange, handleContextResolution, isValidHttpRequest, validateAgainstJsonSchema, validateHeaders, validateHttpRequestHeaders, validationHelper };