@inkeep/agents-core 0.41.2 → 0.43.0

package/dist/context/contextCache.js

@@ -1,177 +0,0 @@
-import { getLogger } from "../utils/logger.js";
-import { generateId } from "../utils/conversations.js";
-import { cleanupTenantCache, clearContextConfigCache, clearConversationCache, getCacheEntry, invalidateHeadersCache, invalidateInvocationDefinitionsCache, setCacheEntry } from "../data-access/contextCache.js";
-import "../data-access/index.js";
-
-//#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 {
-	tenantId;
-	projectId;
-	dbClient;
-	constructor(tenantId, projectId, dbClient) {
-		this.tenantId = tenantId;
-		this.projectId = projectId;
-		this.dbClient = dbClient;
-		logger.info({ tenantId: this.tenantId }, "ContextCache initialized");
-	}
-	/**
-	* Get cached context data for a conversation
-	*/
-	async get({ conversationId, contextConfigId, contextVariableKey, requestHash }) {
-		try {
-			const cacheEntry = await getCacheEntry(this.dbClient)({
-				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.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 cacheData = {
-				id: generateId(),
-				tenantId: this.tenantId,
-				projectId: this.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}`,
-				fetchDurationMs: 0,
-				createdAt: (/* @__PURE__ */ new Date()).toISOString(),
-				updatedAt: (/* @__PURE__ */ new Date()).toISOString()
-			};
-			await setCacheEntry(this.dbClient)(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(this.dbClient)({
-				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(this.dbClient)({
-				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 result = await cleanupTenantCache(this.dbClient)({ scopes: {
-				tenantId: this.tenantId,
-				projectId: this.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(this.dbClient)({
-			scopes: {
-				tenantId,
-				projectId
-			},
-			conversationId,
-			contextConfigId,
-			invocationDefinitionIds: definitionIds
-		});
-	}
-	async invalidateHeaders(tenantId, projectId, conversationId, contextConfigId) {
-		await invalidateHeadersCache(this.dbClient)({
-			scopes: {
-				tenantId,
-				projectId
-			},
-			conversationId,
-			contextConfigId
-		});
-	}
-};
-
-//#endregion
-export { ContextCache };

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/functionTools.d.ts

@@ -1,169 +0,0 @@
-import { FunctionToolApiInsert, FunctionToolApiUpdate } from "../types/entities.js";
-import { AgentScopeConfig, PaginationConfig } from "../types/utility.js";
-import { DatabaseClient } from "../db/client.js";
-
-//#region src/data-access/functionTools.d.ts
-
-/**
- * Get a function tool by ID (agent-scoped)
- */
-declare const getFunctionToolById: (db: DatabaseClient) => (params: {
-  scopes: AgentScopeConfig;
-  functionToolId: string;
-}) => Promise<{
-  createdAt: string;
-  updatedAt: string;
-  name: string;
-  description: string | null;
-  functionId: string;
-  agentId: string;
-  projectId: string;
-  tenantId: string;
-  id: string;
-}>;
-/**
- * List function tools (agent-scoped)
- */
-declare const listFunctionTools: (db: DatabaseClient) => (params: {
-  scopes: AgentScopeConfig;
-  pagination?: PaginationConfig;
-}) => Promise<{
-  data: {
-    createdAt: string;
-    updatedAt: string;
-    name: string;
-    description: string | null;
-    functionId: string;
-    agentId: string;
-    projectId: string;
-    tenantId: string;
-    id: string;
-  }[];
-  pagination: {
-    page: number;
-    limit: number;
-    total: number;
-    pages: number;
-  };
-}>;
-/**
- * Create a function tool (agent-scoped)
- */
-declare const createFunctionTool: (db: DatabaseClient) => (params: {
-  data: FunctionToolApiInsert;
-  scopes: AgentScopeConfig;
-}) => Promise<{
-  tenantId: string;
-  projectId: string;
-  id: string;
-  name: string;
-  description: string | null;
-  agentId: string;
-  createdAt: string;
-  updatedAt: string;
-  functionId: string;
-}>;
-/**
- * Update a function tool (agent-scoped)
- */
-declare const updateFunctionTool: (db: DatabaseClient) => (params: {
-  scopes: AgentScopeConfig;
-  functionToolId: string;
-  data: FunctionToolApiUpdate;
-}) => Promise<{
-  createdAt: string;
-  updatedAt: string;
-  name: string;
-  description: string | null;
-  functionId: string;
-  agentId: string;
-  projectId: string;
-  tenantId: string;
-  id: string;
-}>;
-/**
- * Delete a function tool (agent-scoped)
- */
-declare const deleteFunctionTool: (db: DatabaseClient) => (params: {
-  scopes: AgentScopeConfig;
-  functionToolId: string;
-}) => Promise<boolean>;
-/**
- * Upsert a function tool (create if it doesn't exist, update if it does)
- */
-declare const upsertFunctionTool: (db: DatabaseClient) => (params: {
-  data: FunctionToolApiInsert;
-  scopes: AgentScopeConfig;
-}) => Promise<{
-  tenantId: string;
-  projectId: string;
-  id: string;
-  name: string;
-  description: string | null;
-  agentId: string;
-  createdAt: string;
-  updatedAt: string;
-  functionId: string;
-}>;
-declare const getFunctionToolsForSubAgent: (db: DatabaseClient) => (params: {
-  scopes: {
-    tenantId: string;
-    projectId: string;
-    agentId: string;
-  };
-  subAgentId: string;
-}) => Promise<{
-  data: {
-    createdAt: string;
-    updatedAt: string;
-    name: string;
-    description: string | null;
-    functionId: string;
-    agentId: string;
-    projectId: string;
-    tenantId: string;
-    id: string;
-  }[];
-  pagination: {
-    page: number;
-    limit: number;
-    total: number;
-    pages: number;
-  };
-}>;
-/**
- * Upsert a sub_agent-function tool relation (create if it doesn't exist, update if it does)
- */
-declare const upsertSubAgentFunctionToolRelation: (db: DatabaseClient) => (params: {
-  scopes: AgentScopeConfig;
-  subAgentId: string;
-  functionToolId: string;
-  relationId?: string;
-}) => Promise<{
-  id: string;
-}>;
-/**
- * Add a function tool to an agent
- */
-declare const addFunctionToolToSubAgent: (db: DatabaseClient) => (params: {
-  scopes: AgentScopeConfig;
-  subAgentId: string;
-  functionToolId: string;
-}) => Promise<{
-  id: string;
-}>;
-/**
- * Update an agent-function tool relation
- */
-declare const updateSubAgentFunctionToolRelation: (db: DatabaseClient) => (params: {
-  scopes: AgentScopeConfig;
-  relationId: string;
-  data: {
-    subAgentId: string;
-    functionToolId: string;
-  };
-}) => Promise<{
-  id: string;
-}>;
-//#endregion
-export { addFunctionToolToSubAgent, createFunctionTool, deleteFunctionTool, getFunctionToolById, getFunctionToolsForSubAgent, listFunctionTools, updateFunctionTool, updateSubAgentFunctionToolRelation, upsertFunctionTool, upsertSubAgentFunctionToolRelation };

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 };