@inkeep/agents-api 0.0.1

package/dist/domains/run/context/context.js

@@ -0,0 +1,108 @@
+import runDbClient_default from "../../../data/db/runDbClient.js";
+import { ContextResolver } from "./ContextResolver.js";
+import { getConversation, getLogger, getTracer, setSpanWithError, updateConversation } from "@inkeep/agents-core";
+import { SpanStatusCode } from "@opentelemetry/api";
+
+//#region src/domains/run/context/context.ts
+const logger = getLogger("context");
+const tracer = getTracer("context");
+async function determineContextTrigger(tenantId, projectId, conversationId) {
+	const conversation = await getConversation(runDbClient_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(runDbClient_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(runDbClient_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/domains/run/context/contextCache.d.ts

@@ -0,0 +1,56 @@
+import { FullExecutionContext } from "@inkeep/agents-core";
+
+//#region src/domains/run/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/domains/run/context/contextCache.js

@@ -0,0 +1,174 @@
+import runDbClient_default from "../../../data/db/runDbClient.js";
+import { cleanupTenantCache, clearContextConfigCache, clearConversationCache, generateId, getCacheEntry, getLogger, invalidateHeadersCache, invalidateInvocationDefinitionsCache, setCacheEntry } from "@inkeep/agents-core";
+
+//#region src/domains/run/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 = null;
+			cacheEntry = await getCacheEntry(runDbClient_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(runDbClient_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 {
+			const result = await clearConversationCache(runDbClient_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(runDbClient_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(runDbClient_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(runDbClient_default)({
+			scopes: {
+				tenantId,
+				projectId
+			},
+			conversationId,
+			contextConfigId,
+			invocationDefinitionIds: definitionIds
+		});
+	}
+	async invalidateHeaders(tenantId, projectId, conversationId, contextConfigId) {
+		await invalidateHeadersCache(runDbClient_default)({
+			scopes: {
+				tenantId,
+				projectId
+			},
+			conversationId,
+			contextConfigId
+		});
+	}
+};
+
+//#endregion
+export { ContextCache };

package/dist/domains/run/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 };

package/dist/domains/run/context/index.js

@@ -0,0 +1,7 @@
+import { ContextCache } from "./contextCache.js";
+import { ContextResolver } from "./ContextResolver.js";
+import { HTTP_REQUEST_PARTS, contextValidationMiddleware, getCachedValidator, isValidHttpRequest, validateAgainstJsonSchema, validateHeaders, validateHttpRequestHeaders, validationHelper } from "./validation.js";
+import { ContextFetcher, MissingRequiredVariableError } from "./ContextFetcher.js";
+import { determineContextTrigger, handleContextConfigChange, handleContextResolution } from "./context.js";
+
+export { ContextCache, ContextFetcher, ContextResolver, HTTP_REQUEST_PARTS, MissingRequiredVariableError, contextValidationMiddleware, determineContextTrigger, getCachedValidator, handleContextConfigChange, handleContextResolution, isValidHttpRequest, validateAgainstJsonSchema, validateHeaders, validateHttpRequestHeaders, validationHelper };

package/dist/domains/run/context/validation.d.ts

@@ -0,0 +1,39 @@
+import { Context, Next } from "hono";
+import { CredentialStoreRegistry, FullExecutionContext } from "@inkeep/agents-core";
+import { ValidateFunction } from "ajv";
+
+//#region src/domains/run/context/validation.d.ts
+declare const HTTP_REQUEST_PARTS: readonly ["headers"];
+type HttpRequestPart = (typeof HTTP_REQUEST_PARTS)[number];
+interface ContextValidationError {
+  field: string;
+  message: string;
+  value?: unknown;
+}
+interface ContextValidationResult {
+  valid: boolean;
+  errors: ContextValidationError[];
+  validatedContext?: Record<string, unknown> | ParsedHttpRequest;
+}
+interface ParsedHttpRequest {
+  headers?: Record<string, string>;
+}
+declare function isValidHttpRequest(obj: any): obj is ParsedHttpRequest;
+declare function getCachedValidator(schema: Record<string, unknown>): ValidateFunction;
+declare function validationHelper(jsonSchema: Record<string, unknown>): ValidateFunction<unknown>;
+declare function validateAgainstJsonSchema(jsonSchema: Record<string, unknown>, context: unknown): boolean;
+declare function validateHttpRequestHeaders(headersSchema: any, httpRequest: ParsedHttpRequest): Promise<ContextValidationResult>;
+declare function validateHeaders({
+  executionContext,
+  conversationId,
+  parsedRequest,
+  credentialStores
+}: {
+  executionContext: FullExecutionContext;
+  conversationId: string;
+  parsedRequest: ParsedHttpRequest;
+  credentialStores?: CredentialStoreRegistry;
+}): Promise<ContextValidationResult>;
+declare function contextValidationMiddleware(c: Context, next: Next): Promise<void>;
+//#endregion
+export { ContextValidationError, ContextValidationResult, HTTP_REQUEST_PARTS, HttpRequestPart, ParsedHttpRequest, contextValidationMiddleware, getCachedValidator, isValidHttpRequest, validateAgainstJsonSchema, validateHeaders, validateHttpRequestHeaders, validationHelper };

package/dist/domains/run/context/validation.js

@@ -0,0 +1,255 @@
+import { ContextResolver } from "./ContextResolver.js";
+import { createApiError, getLogger } from "@inkeep/agents-core";
+import Ajv from "ajv";
+
+//#region src/domains/run/context/validation.ts
+const logger = getLogger("context-validation");
+const ajv = new Ajv({
+	allErrors: true,
+	strict: false
+});
+const HTTP_REQUEST_PARTS = ["headers"];
+const MAX_SCHEMA_CACHE_SIZE = 1e3;
+const schemaCache = /* @__PURE__ */ new Map();
+function isValidHttpRequest(obj) {
+	return obj != null && typeof obj === "object" && !Array.isArray(obj) && "headers" in obj;
+}
+function getCachedValidator(schema) {
+	const key = JSON.stringify(schema);
+	if (schemaCache.has(key)) {
+		const validator$1 = schemaCache.get(key);
+		if (!validator$1) throw new Error("Unexpected: validator not found in cache after has() check");
+		schemaCache.delete(key);
+		schemaCache.set(key, validator$1);
+		return validator$1;
+	}
+	if (schemaCache.size >= MAX_SCHEMA_CACHE_SIZE) {
+		const firstKey = schemaCache.keys().next().value;
+		if (firstKey) schemaCache.delete(firstKey);
+	}
+	const permissiveSchema = makeSchemaPermissive(schema);
+	const validator = ajv.compile(permissiveSchema);
+	schemaCache.set(key, validator);
+	return validator;
+}
+function makeSchemaPermissive(schema) {
+	if (!schema || typeof schema !== "object") return schema;
+	const permissiveSchema = { ...schema };
+	if (permissiveSchema.type === "object") {
+		permissiveSchema.additionalProperties = true;
+		if (permissiveSchema.properties && typeof permissiveSchema.properties === "object") {
+			const newProperties = {};
+			for (const [key, value] of Object.entries(permissiveSchema.properties)) newProperties[key] = makeSchemaPermissive(value);
+			permissiveSchema.properties = newProperties;
+		}
+	}
+	if (permissiveSchema.type === "array" && permissiveSchema.items) permissiveSchema.items = makeSchemaPermissive(permissiveSchema.items);
+	if (permissiveSchema.oneOf) permissiveSchema.oneOf = permissiveSchema.oneOf.map(makeSchemaPermissive);
+	if (permissiveSchema.anyOf) permissiveSchema.anyOf = permissiveSchema.anyOf.map(makeSchemaPermissive);
+	if (permissiveSchema.allOf) permissiveSchema.allOf = permissiveSchema.allOf.map(makeSchemaPermissive);
+	return permissiveSchema;
+}
+function validationHelper(jsonSchema) {
+	return getCachedValidator(jsonSchema);
+}
+function validateAgainstJsonSchema(jsonSchema, context) {
+	return validationHelper(jsonSchema)(context);
+}
+function filterByJsonSchema(data, schema) {
+	if (!schema || data === null || data === void 0) return data;
+	if (schema.type === "object" && schema.properties && typeof data === "object" && !Array.isArray(data)) {
+		const filtered = {};
+		for (const [key, propSchema] of Object.entries(schema.properties)) if (key in data) filtered[key] = filterByJsonSchema(data[key], propSchema);
+		return filtered;
+	}
+	if (schema.type === "array" && schema.items && Array.isArray(data)) return data.map((item) => filterByJsonSchema(item, schema.items));
+	if (schema.anyOf && Array.isArray(schema.anyOf)) {
+		for (const subSchema of schema.anyOf) if (subSchema.type && typeof data === subSchema.type) return filterByJsonSchema(data, subSchema);
+		return filterByJsonSchema(data, schema.anyOf[0]);
+	}
+	return data;
+}
+function filterContextToSchemaKeys(validatedContext, headersSchema) {
+	if (!headersSchema || !validatedContext) return validatedContext;
+	const filteredHeaders = filterByJsonSchema(validatedContext, headersSchema);
+	if (filteredHeaders !== null && filteredHeaders !== void 0) {
+		if (typeof filteredHeaders === "object" && Object.keys(filteredHeaders).length > 0) return filteredHeaders;
+		if (typeof filteredHeaders !== "object") return filteredHeaders;
+	}
+	return {};
+}
+async function validateHttpRequestHeaders(headersSchema, httpRequest) {
+	const errors = [];
+	let validatedContext = {};
+	if (!isValidHttpRequest(httpRequest)) return {
+		valid: false,
+		errors: [{
+			field: "httpRequest",
+			message: "Invalid HTTP request format - must contain headers"
+		}]
+	};
+	try {
+		if (headersSchema && httpRequest.headers !== void 0) try {
+			const validate = validationHelper(headersSchema);
+			if (validate(httpRequest.headers)) validatedContext = httpRequest.headers;
+			else if (validate.errors) for (const error of validate.errors) errors.push({
+				field: `headers.${error.instancePath || "root"}`,
+				message: `headers ${error.message}`,
+				value: error.data
+			});
+		} catch (validationError) {
+			errors.push({
+				field: "headers",
+				message: `Failed to validate headers: ${validationError instanceof Error ? validationError.message : "Unknown error"}`
+			});
+		}
+		const filteredContext = errors.length === 0 ? filterContextToSchemaKeys(validatedContext, headersSchema) : void 0;
+		return {
+			valid: errors.length === 0,
+			errors,
+			validatedContext: filteredContext
+		};
+	} catch (error) {
+		logger.error({ error: error instanceof Error ? error.message : "Unknown error" }, "Failed to validate headers schema");
+		return {
+			valid: false,
+			errors: [{
+				field: "schema",
+				message: "Failed to validate headers schema"
+			}]
+		};
+	}
+}
+async function fetchExistingHeaders({ executionContext, contextConfig, conversationId, credentialStores }) {
+	const headers$1 = await new ContextResolver(executionContext, credentialStores).resolveHeaders(conversationId, contextConfig.id);
+	if (Object.keys(headers$1).length > 0) return {
+		valid: true,
+		errors: [],
+		validatedContext: headers$1
+	};
+	throw new Error("No headers found in cache. Please provide headers in request.");
+}
+async function validateHeaders({ executionContext, conversationId, parsedRequest, credentialStores }) {
+	try {
+		const { tenantId, projectId, agentId, project } = executionContext;
+		logger.info({
+			tenantId,
+			projectId,
+			agentId
+		}, "Validating headers");
+		const contextConfig = project.agents[agentId].contextConfig;
+		logger.info({ contextConfig }, "Context config found");
+		if (!contextConfig) {
+			logger.info({ agentId }, "No context config found for agent, skipping validation");
+			return {
+				valid: true,
+				errors: [],
+				validatedContext: parsedRequest
+			};
+		}
+		if (!contextConfig.headersSchema) {
+			logger.debug({ contextConfigId: contextConfig.id }, "No headers schema defined, accepting any context");
+			return {
+				valid: true,
+				errors: [],
+				validatedContext: parsedRequest
+			};
+		}
+		try {
+			const schema = contextConfig.headersSchema;
+			logger.debug({ contextConfigId: contextConfig.id }, "Using headers schema validation");
+			const validationResult = await validateHttpRequestHeaders(schema, parsedRequest);
+			if (validationResult.valid) return validationResult;
+			try {
+				return await fetchExistingHeaders({
+					executionContext,
+					contextConfig,
+					conversationId,
+					credentialStores
+				});
+			} catch (_error) {
+				validationResult.errors.push({
+					field: "headers",
+					message: "Failed to fetch headers from cache"
+				});
+				return validationResult;
+			}
+		} catch (error) {
+			logger.error({
+				contextConfigId: contextConfig.id,
+				error: error instanceof Error ? error.message : "Unknown error"
+			}, "Failed to compile or validate schema");
+			return {
+				valid: false,
+				errors: [{
+					field: "schema",
+					message: "Invalid schema definition or validation error"
+				}]
+			};
+		}
+	} catch (error) {
+		logger.error({
+			tenantId: executionContext.tenantId,
+			agentId: executionContext.agentId,
+			error: error instanceof Error ? error.message : "Unknown error"
+		}, "Failed to validate headers");
+		return {
+			valid: false,
+			errors: [{
+				field: "validation",
+				message: "Context validation failed due to internal error"
+			}]
+		};
+	}
+}
+async function contextValidationMiddleware(c, next) {
+	try {
+		const executionContext = c.get("executionContext");
+		let { tenantId, projectId, agentId } = executionContext;
+		if (!tenantId || !projectId || !agentId) {
+			tenantId = c.req.param("tenantId");
+			projectId = c.req.param("projectId");
+			agentId = c.req.param("agentId");
+		}
+		if (!tenantId || !projectId || !agentId) return next();
+		const conversationId = (c.get("requestBody") || {}).conversationId || "";
+		const headers$1 = {};
+		c.req.raw.headers.forEach((value, key) => {
+			headers$1[key.toLowerCase()] = value;
+		});
+		const credentialStores = c.get("credentialStores");
+		const validationResult = await validateHeaders({
+			executionContext,
+			conversationId,
+			parsedRequest: { headers: headers$1 },
+			credentialStores
+		});
+		if (!validationResult.valid) {
+			logger.warn({
+				tenantId,
+				agentId,
+				errors: validationResult.errors
+			}, "Headers validation failed");
+			throw createApiError({
+				code: "bad_request",
+				message: `Invalid headers: ${validationResult.errors.map((e) => `${e.field}: ${e.message}`).join(", ")}`
+			});
+		}
+		c.set("validatedContext", validationResult.validatedContext);
+		logger.debug({
+			tenantId,
+			agentId,
+			contextKeys: Object.keys(validationResult.validatedContext || {})
+		}, "Request context validation successful");
+		return next();
+	} catch (error) {
+		logger.error({ error: error instanceof Error ? error.message : "Unknown error" }, "Context validation middleware error");
+		throw createApiError({
+			code: "internal_server_error",
+			message: "Context validation failed"
+		});
+	}
+}
+
+//#endregion
+export { HTTP_REQUEST_PARTS, contextValidationMiddleware, getCachedValidator, isValidHttpRequest, validateAgainstJsonSchema, validateHeaders, validateHttpRequestHeaders, validationHelper };

package/dist/domains/run/data/agent.d.ts

@@ -0,0 +1,7 @@
+import { RegisteredAgent } from "../a2a/types.js";
+import { FullExecutionContext } from "@inkeep/agents-core";
+
+//#region src/domains/run/data/agent.d.ts
+declare function getRegisteredAgent(executionContext: FullExecutionContext): Promise<RegisteredAgent | null>;
+//#endregion
+export { getRegisteredAgent };