@inkeep/agents-core 0.41.2 → 0.42.0

package/dist/data-access/agentFull.d.ts

@@ -1,33 +0,0 @@
-import { FullAgentDefinition } from "../types/entities.js";
-import { AgentScopeConfig, ProjectScopeConfig } from "../types/utility.js";
-import { DatabaseClient } from "../db/client.js";
-
-//#region src/data-access/agentFull.d.ts
-interface AgentLogger {
-  info(obj: Record<string, any>, msg?: string): void;
-  error(obj: Record<string, any>, msg?: string): void;
-}
-/**
- * Server-side implementation of createFullAgent that performs actual database operations.
- * This function creates a complete agent with all agents, tools, and relationships.
- */
-declare const createFullAgentServerSide: (db: DatabaseClient, logger?: AgentLogger) => (scopes: ProjectScopeConfig, agentData: FullAgentDefinition) => Promise<FullAgentDefinition>;
-/**
- * Server-side implementation of updateFullAgent that performs actual database operations.
- * This function updates a complete agent with all agents, tools, and relationships.
- */
-declare const updateFullAgentServerSide: (db: DatabaseClient, logger?: AgentLogger) => (scopes: ProjectScopeConfig, agentData: FullAgentDefinition) => Promise<FullAgentDefinition>;
-/**
- * Get a complete agent definition by ID
- */
-declare const getFullAgent: (db: DatabaseClient, logger?: AgentLogger) => (params: {
-  scopes: AgentScopeConfig;
-}) => Promise<FullAgentDefinition | null>;
-/**
- * Delete a complete agent and cascade to all related entities
- */
-declare const deleteFullAgent: (db: DatabaseClient, logger?: AgentLogger) => (params: {
-  scopes: AgentScopeConfig;
-}) => Promise<boolean>;
-//#endregion
-export { AgentLogger, createFullAgentServerSide, deleteFullAgent, getFullAgent, updateFullAgentServerSide };

package/dist/data-access/projectFull.d.ts

@@ -1,32 +0,0 @@
-import { FullProjectDefinition } from "../types/entities.js";
-import { getLogger } from "../utils/logger.js";
-import { ProjectScopeConfig } from "../types/utility.js";
-import { DatabaseClient } from "../db/client.js";
-
-//#region src/data-access/projectFull.d.ts
-
-type ProjectLogger = ReturnType<typeof getLogger>;
-/**
- * Server-side implementation of createFullProject that performs actual database operations.
- * This function creates a complete project with all agent and their nested resources.
- */
-declare const createFullProjectServerSide: (db: DatabaseClient, logger?: ProjectLogger) => (scopes: ProjectScopeConfig, projectData: FullProjectDefinition) => Promise<FullProjectDefinition>;
-/**
- * Server-side implementation of updateFullProject that performs actual database operations.
- * This function updates a complete project with all agent and their nested resources.
- */
-declare const updateFullProjectServerSide: (db: DatabaseClient, logger?: ProjectLogger) => (scopes: ProjectScopeConfig, projectData: FullProjectDefinition) => Promise<FullProjectDefinition>;
-/**
- * Get a complete project definition with all nested resources
- */
-declare const getFullProject: (db: DatabaseClient, logger?: ProjectLogger) => (params: {
-  scopes: ProjectScopeConfig;
-}) => Promise<FullProjectDefinition | null>;
-/**
- * Delete a complete project and cascade to all related entities
- */
-declare const deleteFullProject: (db: DatabaseClient, logger?: ProjectLogger) => (params: {
-  scopes: ProjectScopeConfig;
-}) => Promise<boolean>;
-//#endregion
-export { ProjectLogger, createFullProjectServerSide, deleteFullProject, getFullProject, updateFullProjectServerSide };

package/dist/data-access/projects.d.ts

@@ -1,71 +0,0 @@
-import { ProjectInsert, ProjectSelect, ProjectUpdate } from "../types/entities.js";
-import { PaginationConfig, PaginationResult, ProjectInfo, ProjectResourceCounts, ProjectScopeConfig } from "../types/utility.js";
-import { DatabaseClient } from "../db/client.js";
-
-//#region src/data-access/projects.d.ts
-
-/**
- * List all unique project IDs within a tenant by scanning all resource tables
- */
-declare const listProjects: (db: DatabaseClient) => (params: {
-  tenantId: string;
-}) => Promise<ProjectInfo[]>;
-/**
- * List all unique project IDs within a tenant with pagination
- */
-declare const listProjectsPaginated: (db: DatabaseClient) => (params: {
-  tenantId: string;
-  pagination?: PaginationConfig;
-}) => Promise<{
-  data: ProjectSelect[];
-  pagination: PaginationResult;
-}>;
-/**
- * Get resource counts for a specific project
- */
-declare const getProjectResourceCounts: (db: DatabaseClient) => (params: ProjectScopeConfig) => Promise<ProjectResourceCounts>;
-/**
- * Check if a project exists (has any resources)
- */
-declare const projectExists: (db: DatabaseClient) => (params: ProjectScopeConfig) => Promise<boolean>;
-/**
- * Count total projects for a tenant
- */
-declare const countProjects: (db: DatabaseClient) => (params: {
-  tenantId: string;
-}) => Promise<number>;
-/**
- * Get a single project by ID
- */
-declare const getProject: (db: DatabaseClient) => (params: {
-  scopes: ProjectScopeConfig;
-}) => Promise<ProjectSelect | null>;
-/**
- * Create a new project
- */
-declare const createProject: (db: DatabaseClient) => (params: ProjectInsert) => Promise<ProjectSelect>;
-/**
- * Update an existing project
- */
-declare const updateProject: (db: DatabaseClient) => (params: {
-  scopes: ProjectScopeConfig;
-  data: ProjectUpdate;
-}) => Promise<ProjectSelect | null>;
-/**
- * Check if a project exists in the projects table
- */
-declare const projectExistsInTable: (db: DatabaseClient) => (params: {
-  scopes: ProjectScopeConfig;
-}) => Promise<boolean>;
-/**
- * Check if a project has any resources (used before deletion)
- */
-declare const projectHasResources: (db: DatabaseClient) => (params: ProjectScopeConfig) => Promise<boolean>;
-/**
- * Delete a project (with validation for existing resources)
- */
-declare const deleteProject: (db: DatabaseClient) => (params: {
-  scopes: ProjectScopeConfig;
-}) => Promise<boolean>;
-//#endregion
-export { countProjects, createProject, deleteProject, getProject, getProjectResourceCounts, listProjects, listProjectsPaginated, projectExists, projectExistsInTable, projectHasResources, updateProject };

package/dist/data-access/tasks.d.ts

@@ -1,45 +0,0 @@
-import { TaskInsert, TaskSelect } from "../types/entities.js";
-import "../types/index.js";
-import "../index.js";
-import { TaskMetadataConfig } from "../types/utility.js";
-import { DatabaseClient } from "../db/client.js";
-
-//#region src/data-access/tasks.d.ts
-declare const createTask: (db: DatabaseClient) => (params: TaskInsert) => Promise<{
-  tenantId: string;
-  projectId: string;
-  id: string;
-  agentId: string;
-  createdAt: string;
-  updatedAt: string;
-  metadata: TaskMetadataConfig | null;
-  status: string;
-  subAgentId: string;
-  contextId: string;
-}>;
-declare const getTask: (db: DatabaseClient) => (params: {
-  id: string;
-}) => Promise<TaskSelect | null>;
-declare const updateTask: (db: DatabaseClient) => (params: {
-  taskId: string;
-  data: {
-    status?: string;
-    metadata?: any;
-  };
-}) => Promise<{
-  createdAt: string;
-  updatedAt: string;
-  contextId: string;
-  status: string;
-  metadata: TaskMetadataConfig | null;
-  subAgentId: string;
-  agentId: string;
-  projectId: string;
-  tenantId: string;
-  id: string;
-}>;
-declare const listTaskIdsByContextId: (db: DatabaseClient) => (params: {
-  contextId: string;
-}) => Promise<string[]>;
-//#endregion
-export { createTask, getTask, listTaskIdsByContextId, updateTask };

package/dist/data-access/users.d.ts

@@ -1,19 +0,0 @@
-import { User } from "../auth/auth-validation-schemas.js";
-import { DatabaseClient } from "../db/client.js";
-
-//#region src/data-access/users.d.ts
-
-/**
- * User data access layer
- * All database queries for Better Auth's user table
- */
-/**
- * Get user by ID
- */
-declare const getUserById: (db: DatabaseClient) => (userId: string) => Promise<User | null>;
-/**
- * Get user by email
- */
-declare const getUserByEmail: (db: DatabaseClient) => (email: string) => Promise<User | null>;
-//#endregion
-export { getUserByEmail, getUserById };

package/dist/db/client.d.ts

@@ -1,20 +0,0 @@
-import { schema_d_exports } from "./schema.js";
-import { NodePgDatabase } from "drizzle-orm/node-postgres";
-import { PgliteDatabase } from "drizzle-orm/pglite";
-
-//#region src/db/client.d.ts
-type DatabaseClient = NodePgDatabase<typeof schema_d_exports> | PgliteDatabase<typeof schema_d_exports>;
-interface DatabaseConfig {
-  connectionString?: string;
-  poolSize?: number;
-  ssl?: boolean;
-  logger?: {
-    logQuery: (query: string, params: unknown[]) => void;
-  };
-}
-/**
- * Creates a PostgreSQL database client with connection pooling
- */
-declare function createDatabaseClient(config?: DatabaseConfig): DatabaseClient;
-//#endregion
-export { DatabaseClient, DatabaseConfig, createDatabaseClient };

package/dist/db/client.js

@@ -1,28 +0,0 @@
-import { schema_exports } from "./schema.js";
-import { env, loadEnvironmentFiles } from "../env.js";
-import { drizzle } from "drizzle-orm/node-postgres";
-import { Pool } from "pg";
-
-//#region src/db/client.ts
-loadEnvironmentFiles();
-/**
-* Creates a PostgreSQL database client with connection pooling
-*/
-function createDatabaseClient(config = {}) {
-	const connectionString = config.connectionString || process.env.DATABASE_URL;
-	if (!connectionString) throw new Error("DATABASE_URL environment variable is required. Please set it to your PostgreSQL connection string.");
-	const pool = new Pool({
-		connectionString,
-		max: config.poolSize || Number(env.POSTGRES_POOL_SIZE) || 10
-	});
-	pool.on("error", (err) => {
-		console.error("Unexpected PostgreSQL pool error:", err);
-	});
-	return drizzle(pool, {
-		schema: schema_exports,
-		logger: config.logger
-	});
-}
-
-//#endregion
-export { createDatabaseClient };

package/dist/db/test-client.d.ts

@@ -1,31 +0,0 @@
-import { DatabaseClient } from "./client.js";
-
-//#region src/db/test-client.d.ts
-
-/**
- * Creates a test database client using an in-memory PostgreSQL database (PGlite)
- * This provides real database operations for integration testing with perfect isolation
- * Each call creates a fresh database with all migrations applied
- */
-declare function createTestDatabaseClient(drizzleDir?: string): Promise<DatabaseClient>;
-/**
- * Cleans up test database by removing all data but keeping schema
- * Dynamically gets all tables from the public schema and truncates them
- */
-declare function cleanupTestDatabase(db: DatabaseClient): Promise<void>;
-/**
- * Closes the test database and removes the file
- */
-declare function closeTestDatabase(db: DatabaseClient): Promise<void>;
-/**
- * Creates a test organization in the database
- * This is a helper for tests that need organization records before creating projects/agents
- */
-declare function createTestOrganization(db: DatabaseClient, tenantId: string): Promise<void>;
-/**
- * Creates a test project in the database
- * Ensures the organization exists first
- */
-declare function createTestProject(db: DatabaseClient, tenantId: string, projectId?: string): Promise<void>;
-//#endregion
-export { cleanupTestDatabase, closeTestDatabase, createTestDatabaseClient, createTestOrganization, createTestProject };

package/dist/middleware/contextValidation.d.ts

@@ -1,46 +0,0 @@
-import { CredentialStoreRegistry } from "../credential-stores/CredentialStoreRegistry.js";
-import { DatabaseClient } from "../db/client.js";
-import { ValidateFunction } from "ajv";
-import { Context, Next } from "hono";
-
-//#region src/middleware/contextValidation.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({
-  tenantId,
-  projectId,
-  agentId,
-  conversationId,
-  parsedRequest,
-  dbClient,
-  credentialStores
-}: {
-  tenantId: string;
-  projectId: string;
-  agentId: string;
-  conversationId: string;
-  parsedRequest: ParsedHttpRequest;
-  dbClient: DatabaseClient;
-  credentialStores?: CredentialStoreRegistry;
-}): Promise<ContextValidationResult>;
-declare function contextValidationMiddleware(dbClient: DatabaseClient): (c: Context, next: Next) => Promise<void>;
-//#endregion
-export { ContextValidationError, ContextValidationResult, HTTP_REQUEST_PARTS, HttpRequestPart, ParsedHttpRequest, contextValidationMiddleware, getCachedValidator, isValidHttpRequest, validateAgainstJsonSchema, validateHeaders, validateHttpRequestHeaders, validationHelper };

package/dist/middleware/contextValidation.js

@@ -1,280 +0,0 @@
-import { getLogger } from "../utils/logger.js";
-import { getContextConfigById } from "../data-access/contextConfigs.js";
-import { createApiError } from "../utils/error.js";
-import { getRequestExecutionContext } from "../utils/execution.js";
-import { getAgentWithDefaultSubAgent } from "../data-access/agents.js";
-import { ContextResolver } from "../context/ContextResolver.js";
-import Ajv from "ajv";
-
-//#region src/middleware/contextValidation.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({ tenantId, projectId, contextConfig, conversationId, dbClient, credentialStores }) {
-	const headers = await new ContextResolver(tenantId, projectId, dbClient, credentialStores).resolveHeaders(conversationId, contextConfig.id);
-	if (Object.keys(headers).length > 0) return {
-		valid: true,
-		errors: [],
-		validatedContext: headers
-	};
-	throw new Error("No headers found in cache. Please provide headers in request.");
-}
-async function validateHeaders({ tenantId, projectId, agentId, conversationId, parsedRequest, dbClient, credentialStores }) {
-	try {
-		const agent = await getAgentWithDefaultSubAgent(dbClient)({ scopes: {
-			tenantId,
-			projectId,
-			agentId
-		} });
-		if (!agent?.contextConfigId) {
-			logger.debug({ agentId }, "No context config found for agent, skipping validation");
-			return {
-				valid: true,
-				errors: [],
-				validatedContext: parsedRequest
-			};
-		}
-		const contextConfig = await getContextConfigById(dbClient)({
-			scopes: {
-				tenantId,
-				projectId,
-				agentId
-			},
-			id: agent.contextConfigId
-		});
-		if (!contextConfig) {
-			logger.warn({ contextConfigId: agent.contextConfigId }, "Context config not found");
-			return {
-				valid: false,
-				errors: [{
-					field: "contextConfig",
-					message: "Context configuration not found"
-				}]
-			};
-		}
-		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({
-					tenantId,
-					projectId,
-					contextConfig,
-					conversationId,
-					dbClient,
-					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,
-			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"
-			}]
-		};
-	}
-}
-function contextValidationMiddleware(dbClient) {
-	return async (c, next) => {
-		try {
-			let { tenantId, projectId, agentId } = getRequestExecutionContext(c);
-			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 = {};
-			c.req.raw.headers.forEach((value, key) => {
-				headers[key.toLowerCase()] = value;
-			});
-			const credentialStores = c.get("credentialStores");
-			const validationResult = await validateHeaders({
-				tenantId,
-				projectId,
-				agentId,
-				conversationId,
-				parsedRequest: { headers },
-				dbClient,
-				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/middleware/index.d.ts

@@ -1,2 +0,0 @@
-import { ContextValidationError, ContextValidationResult, HTTP_REQUEST_PARTS, HttpRequestPart, ParsedHttpRequest, contextValidationMiddleware, getCachedValidator, isValidHttpRequest, validateAgainstJsonSchema, validateHeaders, validateHttpRequestHeaders, validationHelper } from "./contextValidation.js";
-export { ContextValidationError, ContextValidationResult, HTTP_REQUEST_PARTS, HttpRequestPart, ParsedHttpRequest, contextValidationMiddleware, getCachedValidator, isValidHttpRequest, validateAgainstJsonSchema, validateHeaders, validateHttpRequestHeaders, validationHelper };

package/dist/middleware/index.js

@@ -1,3 +0,0 @@
-import { HTTP_REQUEST_PARTS, contextValidationMiddleware, getCachedValidator, isValidHttpRequest, validateAgainstJsonSchema, validateHeaders, validateHttpRequestHeaders, validationHelper } from "./contextValidation.js";
-
-export { HTTP_REQUEST_PARTS, contextValidationMiddleware, getCachedValidator, isValidHttpRequest, validateAgainstJsonSchema, validateHeaders, validateHttpRequestHeaders, validationHelper };

package/dist/utils/execution.d.ts

@@ -1,22 +0,0 @@
-import { ExecutionContext } from "../types/utility.js";
-import { Context } from "hono";
-
-//#region src/utils/execution.d.ts
-
-/**
- * Create execution context from middleware values
- */
-declare function createExecutionContext(params: {
-  apiKey: string;
-  tenantId: string;
-  projectId: string;
-  agentId: string;
-  apiKeyId: string;
-  baseUrl?: string;
-}): ExecutionContext;
-/**
- * Get execution context from API key authentication
- */
-declare function getRequestExecutionContext(c: Context): ExecutionContext;
-//#endregion
-export { createExecutionContext, getRequestExecutionContext };

package/dist/utils/execution.js

@@ -1,25 +0,0 @@
-//#region src/utils/execution.ts
-/**
-* Create execution context from middleware values
-*/
-function createExecutionContext(params) {
-	return {
-		apiKey: params.apiKey,
-		tenantId: params.tenantId,
-		projectId: params.projectId,
-		agentId: params.agentId,
-		baseUrl: params.baseUrl || process.env.API_URL || "http://localhost:3003",
-		apiKeyId: params.apiKeyId
-	};
-}
-/**
-* Get execution context from API key authentication
-*/
-function getRequestExecutionContext(c) {
-	const executionContext = c.get("executionContext");
-	if (!executionContext) throw new Error("No execution context available. API key authentication is required.");
-	return executionContext;
-}
-
-//#endregion
-export { createExecutionContext, getRequestExecutionContext };