@inkeep/agents-core 0.41.2 → 0.42.0

package/dist/data-access/{externalAgents.d.ts → manage/externalAgents.d.ts}

@@ -1,37 +1,37 @@
-import { ExternalAgentInsert, ExternalAgentSelect, ExternalAgentUpdate } from "../types/entities.js";
-import "../types/index.js";
-import { PaginationConfig, ProjectScopeConfig } from "../types/utility.js";
-import { DatabaseClient } from "../db/client.js";
+import { PaginationConfig, ProjectScopeConfig } from "../../types/utility.js";
+import "../../types/index.js";
+import { AgentsManageDatabaseClient } from "../../db/manage/manage-client.js";
+import { ExternalAgentInsert, ExternalAgentSelect, ExternalAgentUpdate } from "../../types/entities.js";
 
-//#region src/data-access/externalAgents.d.ts
+//#region src/data-access/manage/externalAgents.d.ts
 /**
  * Create a new external agent
  */
-declare const createExternalAgent: (db: DatabaseClient) => (params: ExternalAgentInsert) => Promise<ExternalAgentSelect>;
+declare const createExternalAgent: (db: AgentsManageDatabaseClient) => (params: ExternalAgentInsert) => Promise<ExternalAgentSelect>;
 /**
  * Get external agent by ID
  */
-declare const getExternalAgent: (db: DatabaseClient) => (params: {
+declare const getExternalAgent: (db: AgentsManageDatabaseClient) => (params: {
   scopes: ProjectScopeConfig;
   externalAgentId: string;
 }) => Promise<ExternalAgentSelect | null>;
 /**
  * Get external agent by base URL
  */
-declare const getExternalAgentByUrl: (db: DatabaseClient) => (params: {
+declare const getExternalAgentByUrl: (db: AgentsManageDatabaseClient) => (params: {
   scopes: ProjectScopeConfig;
   baseUrl: string;
 }) => Promise<ExternalAgentSelect | null>;
 /**
  * List external agents for a project
  */
-declare const listExternalAgents: (db: DatabaseClient) => (params: {
+declare const listExternalAgents: (db: AgentsManageDatabaseClient) => (params: {
   scopes: ProjectScopeConfig;
 }) => Promise<ExternalAgentSelect[]>;
 /**
  * List external agents with pagination
  */
-declare const listExternalAgentsPaginated: (db: DatabaseClient) => (params: {
+declare const listExternalAgentsPaginated: (db: AgentsManageDatabaseClient) => (params: {
   scopes: ProjectScopeConfig;
   pagination?: PaginationConfig;
 }) => Promise<{
@@ -46,7 +46,7 @@ declare const listExternalAgentsPaginated: (db: DatabaseClient) => (params: {
 /**
  * Update an existing external agent
  */
-declare const updateExternalAgent: (db: DatabaseClient) => (params: {
+declare const updateExternalAgent: (db: AgentsManageDatabaseClient) => (params: {
   scopes: ProjectScopeConfig;
   externalAgentId: string;
   data: Partial<ExternalAgentUpdate>;
@@ -54,34 +54,34 @@ declare const updateExternalAgent: (db: DatabaseClient) => (params: {
 /**
  * Upsert external agent (create if it doesn't exist, update if it does)
  */
-declare const upsertExternalAgent: (db: DatabaseClient) => (params: {
+declare const upsertExternalAgent: (db: AgentsManageDatabaseClient) => (params: {
   data: ExternalAgentInsert;
 }) => Promise<ExternalAgentSelect>;
 /**
  * Delete an external agent
  */
-declare const deleteExternalAgent: (db: DatabaseClient) => (params: {
+declare const deleteExternalAgent: (db: AgentsManageDatabaseClient) => (params: {
   scopes: ProjectScopeConfig;
   externalAgentId: string;
 }) => Promise<boolean>;
 /**
  * Check if an external agent exists
  */
-declare const externalAgentExists: (db: DatabaseClient) => (params: {
+declare const externalAgentExists: (db: AgentsManageDatabaseClient) => (params: {
   scopes: ProjectScopeConfig;
   externalAgentId: string;
 }) => Promise<boolean>;
 /**
  * Check if an external agent exists by URL
  */
-declare const externalAgentUrlExists: (db: DatabaseClient) => (params: {
+declare const externalAgentUrlExists: (db: AgentsManageDatabaseClient) => (params: {
   scopes: ProjectScopeConfig;
   baseUrl: string;
 }) => Promise<boolean>;
 /**
  * Count external agents for a project
  */
-declare const countExternalAgents: (db: DatabaseClient) => (params: {
+declare const countExternalAgents: (db: AgentsManageDatabaseClient) => (params: {
   scopes: ProjectScopeConfig;
 }) => Promise<number>;
 //#endregion

package/dist/data-access/{externalAgents.js → manage/externalAgents.js}

@@ -1,7 +1,7 @@
-import { externalAgents } from "../db/schema.js";
+import { externalAgents } from "../../db/manage/manage-schema.js";
 import { and, asc, count, desc, eq } from "drizzle-orm";
 
-//#region src/data-access/externalAgents.ts
+//#region src/data-access/manage/externalAgents.ts
 /**
 * Create a new external agent
 */

package/dist/data-access/{functionTools.d.ts → manage/functionTools.d.ts}

@@ -1,13 +1,13 @@
-import { FunctionToolApiInsert, FunctionToolApiUpdate } from "../types/entities.js";
-import { AgentScopeConfig, PaginationConfig } from "../types/utility.js";
-import { DatabaseClient } from "../db/client.js";
+import { AgentScopeConfig, PaginationConfig } from "../../types/utility.js";
+import { AgentsManageDatabaseClient } from "../../db/manage/manage-client.js";
+import { FunctionToolApiInsert, FunctionToolApiUpdate } from "../../types/entities.js";
 
-//#region src/data-access/functionTools.d.ts
+//#region src/data-access/manage/functionTools.d.ts
 
 /**
  * Get a function tool by ID (agent-scoped)
  */
-declare const getFunctionToolById: (db: DatabaseClient) => (params: {
+declare const getFunctionToolById: (db: AgentsManageDatabaseClient) => (params: {
   scopes: AgentScopeConfig;
   functionToolId: string;
 }) => Promise<{
@@ -24,7 +24,7 @@ declare const getFunctionToolById: (db: DatabaseClient) => (params: {
 /**
  * List function tools (agent-scoped)
  */
-declare const listFunctionTools: (db: DatabaseClient) => (params: {
+declare const listFunctionTools: (db: AgentsManageDatabaseClient) => (params: {
   scopes: AgentScopeConfig;
   pagination?: PaginationConfig;
 }) => Promise<{
@@ -49,7 +49,7 @@ declare const listFunctionTools: (db: DatabaseClient) => (params: {
 /**
  * Create a function tool (agent-scoped)
  */
-declare const createFunctionTool: (db: DatabaseClient) => (params: {
+declare const createFunctionTool: (db: AgentsManageDatabaseClient) => (params: {
   data: FunctionToolApiInsert;
   scopes: AgentScopeConfig;
 }) => Promise<{
@@ -66,7 +66,7 @@ declare const createFunctionTool: (db: DatabaseClient) => (params: {
 /**
  * Update a function tool (agent-scoped)
  */
-declare const updateFunctionTool: (db: DatabaseClient) => (params: {
+declare const updateFunctionTool: (db: AgentsManageDatabaseClient) => (params: {
   scopes: AgentScopeConfig;
   functionToolId: string;
   data: FunctionToolApiUpdate;
@@ -84,14 +84,14 @@ declare const updateFunctionTool: (db: DatabaseClient) => (params: {
 /**
  * Delete a function tool (agent-scoped)
  */
-declare const deleteFunctionTool: (db: DatabaseClient) => (params: {
+declare const deleteFunctionTool: (db: AgentsManageDatabaseClient) => (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: {
+declare const upsertFunctionTool: (db: AgentsManageDatabaseClient) => (params: {
   data: FunctionToolApiInsert;
   scopes: AgentScopeConfig;
 }) => Promise<{
@@ -105,7 +105,7 @@ declare const upsertFunctionTool: (db: DatabaseClient) => (params: {
   updatedAt: string;
   functionId: string;
 }>;
-declare const getFunctionToolsForSubAgent: (db: DatabaseClient) => (params: {
+declare const getFunctionToolsForSubAgent: (db: AgentsManageDatabaseClient) => (params: {
   scopes: {
     tenantId: string;
     projectId: string;
@@ -134,7 +134,7 @@ declare const getFunctionToolsForSubAgent: (db: DatabaseClient) => (params: {
 /**
  * Upsert a sub_agent-function tool relation (create if it doesn't exist, update if it does)
  */
-declare const upsertSubAgentFunctionToolRelation: (db: DatabaseClient) => (params: {
+declare const upsertSubAgentFunctionToolRelation: (db: AgentsManageDatabaseClient) => (params: {
   scopes: AgentScopeConfig;
   subAgentId: string;
   functionToolId: string;
@@ -145,17 +145,24 @@ declare const upsertSubAgentFunctionToolRelation: (db: DatabaseClient) => (param
 /**
  * Add a function tool to an agent
  */
-declare const addFunctionToolToSubAgent: (db: DatabaseClient) => (params: {
+declare const addFunctionToolToSubAgent: (db: AgentsManageDatabaseClient) => (params: {
   scopes: AgentScopeConfig;
   subAgentId: string;
   functionToolId: string;
 }) => Promise<{
+  tenantId: string;
+  projectId: string;
   id: string;
+  agentId: string;
+  createdAt: string;
+  updatedAt: string;
+  subAgentId: string;
+  functionToolId: string;
 }>;
 /**
  * Update an agent-function tool relation
  */
-declare const updateSubAgentFunctionToolRelation: (db: DatabaseClient) => (params: {
+declare const updateSubAgentFunctionToolRelation: (db: AgentsManageDatabaseClient) => (params: {
   scopes: AgentScopeConfig;
   relationId: string;
   data: {
@@ -165,5 +172,48 @@ declare const updateSubAgentFunctionToolRelation: (db: DatabaseClient) => (param
 }) => Promise<{
   id: string;
 }>;
+/**
+ * Get all sub-agents that use a specific function tool
+ */
+declare const getSubAgentsUsingFunctionTool: (db: AgentsManageDatabaseClient) => (params: {
+  scopes: AgentScopeConfig;
+  functionToolId: string;
+}) => Promise<{
+  subAgentId: string;
+  createdAt: string;
+}[]>;
+/**
+ * Remove a function tool from a sub-agent
+ */
+declare const removeFunctionToolFromSubAgent: (db: AgentsManageDatabaseClient) => (params: {
+  scopes: AgentScopeConfig;
+  subAgentId: string;
+  functionToolId: string;
+}) => Promise<boolean>;
+/**
+ * Check if a function tool is associated with a sub-agent
+ */
+declare const isFunctionToolAssociatedWithSubAgent: (db: AgentsManageDatabaseClient) => (params: {
+  scopes: AgentScopeConfig;
+  subAgentId: string;
+  functionToolId: string;
+}) => Promise<boolean>;
+/**
+ * Associate a function tool with a sub-agent (alias for addFunctionToolToSubAgent)
+ */
+declare const associateFunctionToolWithSubAgent: (db: AgentsManageDatabaseClient) => (params: {
+  scopes: AgentScopeConfig;
+  subAgentId: string;
+  functionToolId: string;
+}) => Promise<{
+  tenantId: string;
+  projectId: string;
+  id: string;
+  agentId: string;
+  createdAt: string;
+  updatedAt: string;
+  subAgentId: string;
+  functionToolId: string;
+}>;
 //#endregion
-export { addFunctionToolToSubAgent, createFunctionTool, deleteFunctionTool, getFunctionToolById, getFunctionToolsForSubAgent, listFunctionTools, updateFunctionTool, updateSubAgentFunctionToolRelation, upsertFunctionTool, upsertSubAgentFunctionToolRelation };
+export { addFunctionToolToSubAgent, associateFunctionToolWithSubAgent, createFunctionTool, deleteFunctionTool, getFunctionToolById, getFunctionToolsForSubAgent, getSubAgentsUsingFunctionTool, isFunctionToolAssociatedWithSubAgent, listFunctionTools, removeFunctionToolFromSubAgent, updateFunctionTool, updateSubAgentFunctionToolRelation, upsertFunctionTool, upsertSubAgentFunctionToolRelation };

package/dist/data-access/{functionTools.js → manage/functionTools.js}

@@ -1,9 +1,9 @@
-import { functionTools, subAgentFunctionToolRelations } from "../db/schema.js";
-import { getLogger } from "../utils/logger.js";
-import { generateId } from "../utils/conversations.js";
+import { functionTools, subAgentFunctionToolRelations } from "../../db/manage/manage-schema.js";
+import { getLogger } from "../../utils/logger.js";
+import { generateId } from "../../utils/conversations.js";
 import { and, count, desc, eq } from "drizzle-orm";
 
-//#region src/data-access/functionTools.ts
+//#region src/data-access/manage/functionTools.ts
 const logger = getLogger("functionTools");
 /**
 * Get a function tool by ID (agent-scoped)
@@ -177,14 +177,14 @@ const addFunctionToolToSubAgent = (db) => {
 		const { tenantId, projectId, agentId } = scopes;
 		try {
 			const relationId = generateId();
-			await db.insert(subAgentFunctionToolRelations).values({
+			const [result] = await db.insert(subAgentFunctionToolRelations).values({
 				id: relationId,
 				tenantId,
 				projectId,
 				agentId,
 				subAgentId,
 				functionToolId
-			});
+			}).returning();
 			logger.info({
 				tenantId,
 				projectId,
@@ -193,7 +193,7 @@ const addFunctionToolToSubAgent = (db) => {
 				functionToolId,
 				relationId
 			}, "Function tool added to sub_agent");
-			return { id: relationId };
+			return result;
 		} catch (error) {
 			logger.error({
 				tenantId,
@@ -240,6 +240,88 @@ const updateSubAgentFunctionToolRelation = (db) => {
 		}
 	};
 };
+/**
+* Get all sub-agents that use a specific function tool
+*/
+const getSubAgentsUsingFunctionTool = (db) => {
+	return async (params) => {
+		const { scopes, functionToolId } = params;
+		const { tenantId, projectId, agentId } = scopes;
+		try {
+			return await db.select({
+				subAgentId: subAgentFunctionToolRelations.subAgentId,
+				createdAt: subAgentFunctionToolRelations.createdAt
+			}).from(subAgentFunctionToolRelations).where(and(eq(subAgentFunctionToolRelations.tenantId, tenantId), eq(subAgentFunctionToolRelations.projectId, projectId), eq(subAgentFunctionToolRelations.agentId, agentId), eq(subAgentFunctionToolRelations.functionToolId, functionToolId)));
+		} catch (error) {
+			logger.error({
+				tenantId,
+				projectId,
+				agentId,
+				functionToolId,
+				error
+			}, "Failed to get sub-agents using function tool");
+			throw error;
+		}
+	};
+};
+/**
+* Remove a function tool from a sub-agent
+*/
+const removeFunctionToolFromSubAgent = (db) => {
+	return async (params) => {
+		const { scopes, subAgentId, functionToolId } = params;
+		const { tenantId, projectId, agentId } = scopes;
+		try {
+			const removed = (await db.delete(subAgentFunctionToolRelations).where(and(eq(subAgentFunctionToolRelations.tenantId, tenantId), eq(subAgentFunctionToolRelations.projectId, projectId), eq(subAgentFunctionToolRelations.agentId, agentId), eq(subAgentFunctionToolRelations.subAgentId, subAgentId), eq(subAgentFunctionToolRelations.functionToolId, functionToolId))).returning()).length > 0;
+			if (removed) logger.info({
+				tenantId,
+				projectId,
+				agentId,
+				subAgentId,
+				functionToolId
+			}, "Function tool removed from sub-agent");
+			return removed;
+		} catch (error) {
+			logger.error({
+				tenantId,
+				projectId,
+				agentId,
+				subAgentId,
+				functionToolId,
+				error
+			}, "Failed to remove function tool from sub-agent");
+			throw error;
+		}
+	};
+};
+/**
+* Check if a function tool is associated with a sub-agent
+*/
+const isFunctionToolAssociatedWithSubAgent = (db) => {
+	return async (params) => {
+		const { scopes, subAgentId, functionToolId } = params;
+		const { tenantId, projectId, agentId } = scopes;
+		try {
+			return (await db.select({ id: subAgentFunctionToolRelations.id }).from(subAgentFunctionToolRelations).where(and(eq(subAgentFunctionToolRelations.tenantId, tenantId), eq(subAgentFunctionToolRelations.projectId, projectId), eq(subAgentFunctionToolRelations.agentId, agentId), eq(subAgentFunctionToolRelations.subAgentId, subAgentId), eq(subAgentFunctionToolRelations.functionToolId, functionToolId))).limit(1)).length > 0;
+		} catch (error) {
+			logger.error({
+				tenantId,
+				projectId,
+				agentId,
+				subAgentId,
+				functionToolId,
+				error
+			}, "Failed to check function tool association with sub-agent");
+			throw error;
+		}
+	};
+};
+/**
+* Associate a function tool with a sub-agent (alias for addFunctionToolToSubAgent)
+*/
+const associateFunctionToolWithSubAgent = (db) => {
+	return addFunctionToolToSubAgent(db);
+};
 
 //#endregion
-export { addFunctionToolToSubAgent, createFunctionTool, deleteFunctionTool, getFunctionToolById, getFunctionToolsForSubAgent, listFunctionTools, updateFunctionTool, updateSubAgentFunctionToolRelation, upsertFunctionTool, upsertSubAgentFunctionToolRelation };
+export { addFunctionToolToSubAgent, associateFunctionToolWithSubAgent, createFunctionTool, deleteFunctionTool, getFunctionToolById, getFunctionToolsForSubAgent, getSubAgentsUsingFunctionTool, isFunctionToolAssociatedWithSubAgent, listFunctionTools, removeFunctionToolFromSubAgent, updateFunctionTool, updateSubAgentFunctionToolRelation, upsertFunctionTool, upsertSubAgentFunctionToolRelation };

package/dist/data-access/{functions.d.ts → manage/functions.d.ts}

@@ -1,33 +1,33 @@
-import { FunctionApiInsert } from "../types/entities.js";
-import { PaginationConfig, ProjectScopeConfig } from "../types/utility.js";
-import { DatabaseClient } from "../db/client.js";
+import { PaginationConfig, ProjectScopeConfig } from "../../types/utility.js";
+import { AgentsManageDatabaseClient } from "../../db/manage/manage-client.js";
+import { FunctionApiInsert } from "../../types/entities.js";
 
-//#region src/data-access/functions.d.ts
+//#region src/data-access/manage/functions.d.ts
 
 /**
  * Create or update a function (project-scoped)
  */
-declare const upsertFunction: (db: DatabaseClient) => (params: {
+declare const upsertFunction: (db: AgentsManageDatabaseClient) => (params: {
   data: FunctionApiInsert;
   scopes: ProjectScopeConfig;
 }) => Promise<void>;
 /**
  * Get a function by ID (project-scoped)
  */
-declare const getFunction: (db: DatabaseClient) => (params: {
+declare const getFunction: (db: AgentsManageDatabaseClient) => (params: {
   functionId: string;
   scopes: ProjectScopeConfig;
 }) => Promise<FunctionApiInsert | null>;
 /**
  * List all functions for a project
  */
-declare const listFunctions: (db: DatabaseClient) => (params: {
+declare const listFunctions: (db: AgentsManageDatabaseClient) => (params: {
   scopes: ProjectScopeConfig;
 }) => Promise<FunctionApiInsert[]>;
 /**
  * List all functions for a project with pagination
  */
-declare const listFunctionsPaginated: (db: DatabaseClient) => (params: {
+declare const listFunctionsPaginated: (db: AgentsManageDatabaseClient) => (params: {
   scopes: ProjectScopeConfig;
   pagination?: PaginationConfig;
 }) => Promise<{
@@ -51,7 +51,7 @@ declare const listFunctionsPaginated: (db: DatabaseClient) => (params: {
 /**
  * Delete a function (project-scoped)
  */
-declare const deleteFunction: (db: DatabaseClient) => (params: {
+declare const deleteFunction: (db: AgentsManageDatabaseClient) => (params: {
   functionId: string;
   scopes: ProjectScopeConfig;
 }) => Promise<void>;

package/dist/data-access/{functions.js → manage/functions.js}

@@ -1,7 +1,7 @@
-import { functions } from "../db/schema.js";
+import { functions } from "../../db/manage/manage-schema.js";
 import { and, count, desc, eq } from "drizzle-orm";
 
-//#region src/data-access/functions.ts
+//#region src/data-access/manage/functions.ts
 /**
 * Create or update a function (project-scoped)
 */
@@ -10,7 +10,7 @@ const upsertFunction = (db) => async (params) => {
 	const { tenantId, projectId } = scopes;
 	let dependencies = data.dependencies;
 	if (!dependencies || Object.keys(dependencies).length === 0) {
-		const { autoDetectDependencies } = await import("../utils/detectDependencies.js");
+		const { autoDetectDependencies } = await import("../../utils/detectDependencies.js");
 		dependencies = autoDetectDependencies(data.executeCode);
 	}
 	if ((await db.select().from(functions).where(and(eq(functions.tenantId, tenantId), eq(functions.projectId, projectId), eq(functions.id, data.id))).limit(1)).length > 0) await db.update(functions).set({

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

@@ -0,0 +1,38 @@
+import { ProjectScopeConfig } from "../../types/utility.js";
+import { getLogger } from "../../utils/logger.js";
+import { AgentsManageDatabaseClient } from "../../db/manage/manage-client.js";
+import { FullProjectDefinition, FullProjectSelect, FullProjectSelectWithRelationIds } from "../../types/entities.js";
+
+//#region src/data-access/manage/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: AgentsManageDatabaseClient, logger?: ProjectLogger) => (params: {
+  scopes: ProjectScopeConfig;
+  projectData: FullProjectDefinition;
+}) => Promise<FullProjectSelect>;
+/**
+ * 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: AgentsManageDatabaseClient, logger?: ProjectLogger) => (params: {
+  scopes: ProjectScopeConfig;
+  projectData: FullProjectDefinition;
+}) => Promise<FullProjectSelect>;
+declare const getFullProject: (db: AgentsManageDatabaseClient, logger?: ProjectLogger) => (params: {
+  scopes: ProjectScopeConfig;
+}) => Promise<FullProjectSelect | null>;
+declare const getFullProjectWithRelationIds: (db: AgentsManageDatabaseClient, logger?: ProjectLogger) => (params: {
+  scopes: ProjectScopeConfig;
+}) => Promise<FullProjectSelectWithRelationIds | null>;
+/**
+ * Delete a complete project and cascade to all related entities
+ */
+declare const deleteFullProject: (db: AgentsManageDatabaseClient, logger?: ProjectLogger) => (params: {
+  scopes: ProjectScopeConfig;
+}) => Promise<boolean>;
+//#endregion
+export { ProjectLogger, createFullProjectServerSide, deleteFullProject, getFullProject, getFullProjectWithRelationIds, updateFullProjectServerSide };