@inkeep/agents-core 0.58.14 → 0.58.15

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

@@ -53,14 +53,14 @@ declare const createFunctionTool: (db: AgentsManageDatabaseClient) => (params: {
   data: FunctionToolApiInsert;
   scopes: AgentScopeConfig;
 }) => Promise<{
+  tenantId: string;
+  projectId: string;
+  agentId: string;
   id: string;
   name: string;
+  description: string | null;
   createdAt: string;
   updatedAt: string;
-  description: string | null;
-  projectId: string;
-  tenantId: string;
-  agentId: string;
   functionId: string;
 }>;
 /**
@@ -95,22 +95,18 @@ declare const upsertFunctionTool: (db: AgentsManageDatabaseClient) => (params: {
   data: FunctionToolApiInsert;
   scopes: AgentScopeConfig;
 }) => Promise<{
+  tenantId: string;
+  projectId: string;
+  agentId: string;
   id: string;
   name: string;
+  description: string | null;
   createdAt: string;
   updatedAt: string;
-  description: string | null;
-  projectId: string;
-  tenantId: string;
-  agentId: string;
   functionId: string;
 }>;
 declare const getFunctionToolsForSubAgent: (db: AgentsManageDatabaseClient) => (params: {
-  scopes: {
-    tenantId: string;
-    projectId: string;
-    agentId: string;
-  };
+  scopes: AgentScopeConfig;
   subAgentId: string;
   pagination?: PaginationConfig;
 }) => Promise<{
@@ -161,17 +157,17 @@ declare const addFunctionToolToSubAgent: (db: AgentsManageDatabaseClient) => (pa
     needsApproval?: boolean;
   }> | null;
 }) => Promise<{
+  tenantId: string;
+  projectId: string;
+  agentId: string;
+  subAgentId: string;
   id: string;
   createdAt: string;
   updatedAt: string;
-  subAgentId: string;
-  projectId: string;
-  tenantId: string;
-  agentId: string;
-  functionToolId: string;
   toolPolicies: Record<string, {
     needsApproval?: boolean;
   }> | null;
+  functionToolId: string;
 }>;
 /**
  * Update an agent-function tool relation
@@ -226,17 +222,17 @@ declare const associateFunctionToolWithSubAgent: (db: AgentsManageDatabaseClient
     needsApproval?: boolean;
   }> | null;
 }) => Promise<{
+  tenantId: string;
+  projectId: string;
+  agentId: string;
+  subAgentId: string;
   id: string;
   createdAt: string;
   updatedAt: string;
-  subAgentId: string;
-  projectId: string;
-  tenantId: string;
-  agentId: string;
-  functionToolId: string;
   toolPolicies: Record<string, {
     needsApproval?: boolean;
   }> | null;
+  functionToolId: string;
 }>;
 //#endregion
 export { addFunctionToolToSubAgent, associateFunctionToolWithSubAgent, createFunctionTool, deleteFunctionTool, getFunctionToolById, getFunctionToolsForSubAgent, getSubAgentsUsingFunctionTool, isFunctionToolAssociatedWithSubAgent, listFunctionTools, removeFunctionToolFromSubAgent, updateFunctionTool, updateSubAgentFunctionToolRelation, upsertFunctionTool, upsertSubAgentFunctionToolRelation };

package/dist/data-access/manage/functionTools.js

@@ -1,6 +1,7 @@
 import { functionTools, subAgentFunctionToolRelations } from "../../db/manage/manage-schema.js";
 import { getLogger } from "../../utils/logger.js";
 import { generateId } from "../../utils/conversations.js";
+import { agentScopedWhere } from "./scope-helpers.js";
 import { and, count, desc, eq } from "drizzle-orm";
 
 //#region src/data-access/manage/functionTools.ts
@@ -9,7 +10,7 @@ const logger = getLogger("functionTools");
 * Get a function tool by ID (agent-scoped)
 */
 const getFunctionToolById = (db) => async (params) => {
-	return (await db.select().from(functionTools).where(and(eq(functionTools.tenantId, params.scopes.tenantId), eq(functionTools.projectId, params.scopes.projectId), eq(functionTools.agentId, params.scopes.agentId), eq(functionTools.id, params.functionToolId))).limit(1))[0] ?? null;
+	return (await db.select().from(functionTools).where(and(agentScopedWhere(functionTools, params.scopes), eq(functionTools.id, params.functionToolId))).limit(1))[0] ?? null;
 };
 /**
 * List function tools (agent-scoped)
@@ -18,7 +19,7 @@ const listFunctionTools = (db) => async (params) => {
 	const page = params.pagination?.page || 1;
 	const limit = Math.min(params.pagination?.limit || 10, 100);
 	const offset = (page - 1) * limit;
-	const whereClause = and(eq(functionTools.tenantId, params.scopes.tenantId), eq(functionTools.projectId, params.scopes.projectId), eq(functionTools.agentId, params.scopes.agentId));
+	const whereClause = agentScopedWhere(functionTools, params.scopes);
 	const [functionToolsDbResults, totalResult] = await Promise.all([db.select().from(functionTools).where(whereClause).limit(limit).offset(offset).orderBy(desc(functionTools.createdAt)), db.select({ count: count() }).from(functionTools).where(whereClause)]);
 	const total = totalResult[0]?.count || 0;
 	return {
@@ -36,11 +37,8 @@ const listFunctionTools = (db) => async (params) => {
 */
 const createFunctionTool = (db) => async (params) => {
 	const { data, scopes } = params;
-	const { tenantId, projectId, agentId } = scopes;
 	const [created] = await db.insert(functionTools).values({
-		tenantId,
-		projectId,
-		agentId,
+		...scopes,
 		id: data.id,
 		name: data.name,
 		description: data.description,
@@ -58,30 +56,25 @@ const updateFunctionTool = (db) => async (params) => {
 	const [updated] = await db.update(functionTools).set({
 		...params.data,
 		updatedAt: now
-	}).where(and(eq(functionTools.tenantId, params.scopes.tenantId), eq(functionTools.projectId, params.scopes.projectId), eq(functionTools.agentId, params.scopes.agentId), eq(functionTools.id, params.functionToolId))).returning();
+	}).where(and(agentScopedWhere(functionTools, params.scopes), eq(functionTools.id, params.functionToolId))).returning();
 	return updated ?? null;
 };
 /**
 * Delete a function tool (agent-scoped)
 */
 const deleteFunctionTool = (db) => async (params) => {
-	const [deleted] = await db.delete(functionTools).where(and(eq(functionTools.tenantId, params.scopes.tenantId), eq(functionTools.projectId, params.scopes.projectId), eq(functionTools.agentId, params.scopes.agentId), eq(functionTools.id, params.functionToolId))).returning();
+	const [deleted] = await db.delete(functionTools).where(and(agentScopedWhere(functionTools, params.scopes), eq(functionTools.id, params.functionToolId))).returning();
 	return !!deleted;
 };
 /**
 * Upsert a function tool (create if it doesn't exist, update if it does)
 */
 const upsertFunctionTool = (db) => async (params) => {
-	const scopes = {
-		tenantId: params.scopes.tenantId,
-		projectId: params.scopes.projectId,
-		agentId: params.scopes.agentId
-	};
 	if (await getFunctionToolById(db)({
-		scopes,
+		scopes: params.scopes,
 		functionToolId: params.data.id
 	})) return await updateFunctionTool(db)({
-		scopes,
+		scopes: params.scopes,
 		functionToolId: params.data.id,
 		data: {
 			name: params.data.name,
@@ -91,7 +84,7 @@ const upsertFunctionTool = (db) => async (params) => {
 	});
 	return await createFunctionTool(db)({
 		data: params.data,
-		scopes
+		scopes: params.scopes
 	});
 };
 const getFunctionToolsForSubAgent = (db) => {
@@ -99,9 +92,8 @@ const getFunctionToolsForSubAgent = (db) => {
 		const page = params.pagination?.page || 1;
 		const limit = Math.min(params.pagination?.limit || 1e3, 1e3);
 		const offset = (page - 1) * limit;
-		const { tenantId, projectId, agentId } = params.scopes;
 		try {
-			const whereClause = and(eq(subAgentFunctionToolRelations.tenantId, tenantId), eq(subAgentFunctionToolRelations.projectId, projectId), eq(subAgentFunctionToolRelations.agentId, agentId), eq(subAgentFunctionToolRelations.subAgentId, params.subAgentId));
+			const whereClause = and(agentScopedWhere(subAgentFunctionToolRelations, params.scopes), eq(subAgentFunctionToolRelations.subAgentId, params.subAgentId));
 			const [data, totalResult] = await Promise.all([db.select({
 				id: functionTools.id,
 				name: functionTools.name,
@@ -127,9 +119,7 @@ const getFunctionToolsForSubAgent = (db) => {
 			};
 		} catch (error) {
 			logger.error({
-				tenantId,
-				projectId,
-				agentId,
+				...params.scopes,
 				subAgentId: params.subAgentId,
 				error
 			}, "Failed to get function tools for agent");
@@ -142,7 +132,6 @@ const getFunctionToolsForSubAgent = (db) => {
 */
 const upsertSubAgentFunctionToolRelation = (db) => async (params) => {
 	const { scopes, subAgentId, functionToolId, toolPolicies, relationId } = params;
-	const { tenantId, projectId, agentId } = scopes;
 	if (relationId) return await updateSubAgentFunctionToolRelation(db)({
 		scopes,
 		relationId,
@@ -153,12 +142,10 @@ const upsertSubAgentFunctionToolRelation = (db) => async (params) => {
 		}
 	});
 	try {
-		const existingRelations = await db.select().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);
+		const existingRelations = await db.select().from(subAgentFunctionToolRelations).where(and(agentScopedWhere(subAgentFunctionToolRelations, scopes), eq(subAgentFunctionToolRelations.subAgentId, subAgentId), eq(subAgentFunctionToolRelations.functionToolId, functionToolId))).limit(1);
 		if (existingRelations.length > 0) {
 			logger.info({
-				tenantId,
-				projectId,
-				agentId,
+				...scopes,
 				subAgentId,
 				functionToolId,
 				relationId: existingRelations[0].id
@@ -168,9 +155,7 @@ const upsertSubAgentFunctionToolRelation = (db) => async (params) => {
 		return await addFunctionToolToSubAgent(db)(params);
 	} catch (error) {
 		logger.error({
-			tenantId,
-			projectId,
-			agentId,
+			...scopes,
 			subAgentId,
 			functionToolId,
 			error
@@ -184,22 +169,17 @@ const upsertSubAgentFunctionToolRelation = (db) => async (params) => {
 const addFunctionToolToSubAgent = (db) => {
 	return async (params) => {
 		const { scopes, subAgentId, functionToolId, toolPolicies } = params;
-		const { tenantId, projectId, agentId } = scopes;
 		try {
 			const relationId = generateId();
 			const [result] = await db.insert(subAgentFunctionToolRelations).values({
 				id: relationId,
-				tenantId,
-				projectId,
-				agentId,
+				...scopes,
 				subAgentId,
 				functionToolId,
 				...toolPolicies !== void 0 ? { toolPolicies } : {}
 			}).returning();
 			logger.info({
-				tenantId,
-				projectId,
-				agentId,
+				...scopes,
 				subAgentId,
 				functionToolId,
 				relationId
@@ -207,9 +187,7 @@ const addFunctionToolToSubAgent = (db) => {
 			return result;
 		} catch (error) {
 			logger.error({
-				tenantId,
-				projectId,
-				agentId,
+				...scopes,
 				subAgentId,
 				functionToolId,
 				error
@@ -224,26 +202,21 @@ const addFunctionToolToSubAgent = (db) => {
 const updateSubAgentFunctionToolRelation = (db) => {
 	return async (params) => {
 		const { scopes, relationId, data } = params;
-		const { tenantId, projectId, agentId } = scopes;
 		try {
 			await db.update(subAgentFunctionToolRelations).set({
 				subAgentId: data.subAgentId,
 				functionToolId: data.functionToolId,
 				...data.toolPolicies !== void 0 ? { toolPolicies: data.toolPolicies } : {}
-			}).where(and(eq(subAgentFunctionToolRelations.id, relationId), eq(subAgentFunctionToolRelations.tenantId, tenantId), eq(subAgentFunctionToolRelations.projectId, projectId), eq(subAgentFunctionToolRelations.agentId, agentId)));
+			}).where(and(agentScopedWhere(subAgentFunctionToolRelations, scopes), eq(subAgentFunctionToolRelations.id, relationId)));
 			logger.info({
-				tenantId,
-				projectId,
-				agentId,
+				...scopes,
 				relationId,
 				data
 			}, "SubAgent-function tool relation updated");
 			return { id: relationId };
 		} catch (error) {
 			logger.error({
-				tenantId,
-				projectId,
-				agentId,
+				...scopes,
 				relationId,
 				data,
 				error
@@ -258,17 +231,14 @@ const updateSubAgentFunctionToolRelation = (db) => {
 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)));
+			}).from(subAgentFunctionToolRelations).where(and(agentScopedWhere(subAgentFunctionToolRelations, scopes), eq(subAgentFunctionToolRelations.functionToolId, functionToolId)));
 		} catch (error) {
 			logger.error({
-				tenantId,
-				projectId,
-				agentId,
+				...scopes,
 				functionToolId,
 				error
 			}, "Failed to get sub-agents using function tool");
@@ -282,22 +252,17 @@ const getSubAgentsUsingFunctionTool = (db) => {
 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;
+			const removed = (await db.delete(subAgentFunctionToolRelations).where(and(agentScopedWhere(subAgentFunctionToolRelations, scopes), eq(subAgentFunctionToolRelations.subAgentId, subAgentId), eq(subAgentFunctionToolRelations.functionToolId, functionToolId))).returning()).length > 0;
 			if (removed) logger.info({
-				tenantId,
-				projectId,
-				agentId,
+				...scopes,
 				subAgentId,
 				functionToolId
 			}, "Function tool removed from sub-agent");
 			return removed;
 		} catch (error) {
 			logger.error({
-				tenantId,
-				projectId,
-				agentId,
+				...scopes,
 				subAgentId,
 				functionToolId,
 				error
@@ -312,14 +277,11 @@ const removeFunctionToolFromSubAgent = (db) => {
 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;
+			return (await db.select({ id: subAgentFunctionToolRelations.id }).from(subAgentFunctionToolRelations).where(and(agentScopedWhere(subAgentFunctionToolRelations, scopes), eq(subAgentFunctionToolRelations.subAgentId, subAgentId), eq(subAgentFunctionToolRelations.functionToolId, functionToolId))).limit(1)).length > 0;
 		} catch (error) {
 			logger.error({
-				tenantId,
-				projectId,
-				agentId,
+				...scopes,
 				subAgentId,
 				functionToolId,
 				error

package/dist/data-access/manage/functions.js

@@ -1,4 +1,5 @@
 import { functions } from "../../db/manage/manage-schema.js";
+import { projectScopedWhere } from "./scope-helpers.js";
 import { and, count, desc, eq } from "drizzle-orm";
 
 //#region src/data-access/manage/functions.ts
@@ -13,12 +14,12 @@ const upsertFunction = (db) => async (params) => {
 		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({
+	if ((await db.select().from(functions).where(and(projectScopedWhere(functions, scopes), eq(functions.id, data.id))).limit(1)).length > 0) await db.update(functions).set({
 		inputSchema: data.inputSchema,
 		executeCode: data.executeCode,
 		dependencies,
 		updatedAt: (/* @__PURE__ */ new Date()).toISOString()
-	}).where(and(eq(functions.tenantId, tenantId), eq(functions.projectId, projectId), eq(functions.id, data.id)));
+	}).where(and(projectScopedWhere(functions, scopes), eq(functions.id, data.id)));
 	else await db.insert(functions).values({
 		tenantId,
 		projectId,
@@ -35,27 +36,24 @@ const upsertFunction = (db) => async (params) => {
 */
 const getFunction = (db) => async (params) => {
 	const { functionId, scopes } = params;
-	const { tenantId, projectId } = scopes;
-	return (await db.select().from(functions).where(and(eq(functions.tenantId, tenantId), eq(functions.projectId, projectId), eq(functions.id, functionId))).limit(1))[0] || null;
+	return (await db.select().from(functions).where(and(projectScopedWhere(functions, scopes), eq(functions.id, functionId))).limit(1))[0] || null;
 };
 /**
 * List all functions for a project
 */
 const listFunctions = (db) => async (params) => {
 	const { scopes } = params;
-	const { tenantId, projectId } = scopes;
-	return await db.select().from(functions).where(and(eq(functions.tenantId, tenantId), eq(functions.projectId, projectId)));
+	return await db.select().from(functions).where(projectScopedWhere(functions, scopes));
 };
 /**
 * List all functions for a project with pagination
 */
 const listFunctionsPaginated = (db) => async (params) => {
 	const { scopes, pagination } = params;
-	const { tenantId, projectId } = scopes;
 	const page = pagination?.page || 1;
 	const limit = Math.min(pagination?.limit || 10, 100);
 	const offset = (page - 1) * limit;
-	const whereClause = and(eq(functions.tenantId, tenantId), eq(functions.projectId, projectId));
+	const whereClause = projectScopedWhere(functions, scopes);
 	const [data, totalResult] = await Promise.all([db.select().from(functions).where(whereClause).limit(limit).offset(offset).orderBy(desc(functions.createdAt)), db.select({ count: count() }).from(functions).where(whereClause)]);
 	const total = totalResult[0]?.count || 0;
 	return {
@@ -73,8 +71,7 @@ const listFunctionsPaginated = (db) => async (params) => {
 */
 const deleteFunction = (db) => async (params) => {
 	const { functionId, scopes } = params;
-	const { tenantId, projectId } = scopes;
-	await db.delete(functions).where(and(eq(functions.tenantId, tenantId), eq(functions.projectId, projectId), eq(functions.id, functionId)));
+	await db.delete(functions).where(and(projectScopedWhere(functions, scopes), eq(functions.id, functionId)));
 };
 
 //#endregion

package/dist/data-access/manage/projects.js

@@ -1,4 +1,5 @@
 import { agents, artifactComponents, contextConfigs, credentialReferences, dataComponents, externalAgents, projects, subAgentArtifactComponents, subAgentDataComponents, subAgentRelations, subAgentToolRelations, subAgents, tools } from "../../db/manage/manage-schema.js";
+import { projectScopedWhere, tenantScopedWhere } from "./scope-helpers.js";
 import { and, count, desc, eq, inArray } from "drizzle-orm";
 
 //#region src/data-access/manage/projects.ts
@@ -8,22 +9,23 @@ import { and, count, desc, eq, inArray } from "drizzle-orm";
 */
 const listProjects = (db) => async (params) => {
 	if (params.projectIds !== void 0 && params.projectIds.length === 0) return [];
-	const whereClause = params.projectIds ? and(eq(projects.tenantId, params.tenantId), inArray(projects.id, params.projectIds)) : eq(projects.tenantId, params.tenantId);
+	const tenantScope = { tenantId: params.tenantId };
+	const whereClause = params.projectIds ? and(tenantScopedWhere(projects, tenantScope), inArray(projects.id, params.projectIds)) : tenantScopedWhere(projects, tenantScope);
 	const projectsFromTable = await db.select({ projectId: projects.id }).from(projects).where(whereClause);
 	if (projectsFromTable.length > 0) return projectsFromTable.map((p) => ({ projectId: p.projectId }));
 	const projectIdSets = await Promise.all([
-		db.selectDistinct({ projectId: subAgents.projectId }).from(subAgents).where(eq(subAgents.tenantId, params.tenantId)),
-		db.selectDistinct({ projectId: agents.projectId }).from(agents).where(eq(agents.tenantId, params.tenantId)),
-		db.selectDistinct({ projectId: tools.projectId }).from(tools).where(eq(tools.tenantId, params.tenantId)),
-		db.selectDistinct({ projectId: contextConfigs.projectId }).from(contextConfigs).where(eq(contextConfigs.tenantId, params.tenantId)),
-		db.selectDistinct({ projectId: externalAgents.projectId }).from(externalAgents).where(eq(externalAgents.tenantId, params.tenantId)),
-		db.selectDistinct({ projectId: subAgentRelations.projectId }).from(subAgentRelations).where(eq(subAgentRelations.tenantId, params.tenantId)),
-		db.selectDistinct({ projectId: subAgentToolRelations.projectId }).from(subAgentToolRelations).where(eq(subAgentToolRelations.tenantId, params.tenantId)),
-		db.selectDistinct({ projectId: subAgentDataComponents.projectId }).from(subAgentDataComponents).where(eq(subAgentDataComponents.tenantId, params.tenantId)),
-		db.selectDistinct({ projectId: subAgentArtifactComponents.projectId }).from(subAgentArtifactComponents).where(eq(subAgentArtifactComponents.tenantId, params.tenantId)),
-		db.selectDistinct({ projectId: dataComponents.projectId }).from(dataComponents).where(eq(dataComponents.tenantId, params.tenantId)),
-		db.selectDistinct({ projectId: artifactComponents.projectId }).from(artifactComponents).where(eq(artifactComponents.tenantId, params.tenantId)),
-		db.selectDistinct({ projectId: credentialReferences.projectId }).from(credentialReferences).where(eq(credentialReferences.tenantId, params.tenantId))
+		db.selectDistinct({ projectId: subAgents.projectId }).from(subAgents).where(tenantScopedWhere(subAgents, tenantScope)),
+		db.selectDistinct({ projectId: agents.projectId }).from(agents).where(tenantScopedWhere(agents, tenantScope)),
+		db.selectDistinct({ projectId: tools.projectId }).from(tools).where(tenantScopedWhere(tools, tenantScope)),
+		db.selectDistinct({ projectId: contextConfigs.projectId }).from(contextConfigs).where(tenantScopedWhere(contextConfigs, tenantScope)),
+		db.selectDistinct({ projectId: externalAgents.projectId }).from(externalAgents).where(tenantScopedWhere(externalAgents, tenantScope)),
+		db.selectDistinct({ projectId: subAgentRelations.projectId }).from(subAgentRelations).where(tenantScopedWhere(subAgentRelations, tenantScope)),
+		db.selectDistinct({ projectId: subAgentToolRelations.projectId }).from(subAgentToolRelations).where(tenantScopedWhere(subAgentToolRelations, tenantScope)),
+		db.selectDistinct({ projectId: subAgentDataComponents.projectId }).from(subAgentDataComponents).where(tenantScopedWhere(subAgentDataComponents, tenantScope)),
+		db.selectDistinct({ projectId: subAgentArtifactComponents.projectId }).from(subAgentArtifactComponents).where(tenantScopedWhere(subAgentArtifactComponents, tenantScope)),
+		db.selectDistinct({ projectId: dataComponents.projectId }).from(dataComponents).where(tenantScopedWhere(dataComponents, tenantScope)),
+		db.selectDistinct({ projectId: artifactComponents.projectId }).from(artifactComponents).where(tenantScopedWhere(artifactComponents, tenantScope)),
+		db.selectDistinct({ projectId: credentialReferences.projectId }).from(credentialReferences).where(tenantScopedWhere(credentialReferences, tenantScope))
 	]);
 	const allProjectIds = /* @__PURE__ */ new Set();
 	projectIdSets.forEach((results) => {
@@ -43,7 +45,8 @@ const listProjectsPaginated = (db) => async (params) => {
 	const page = params.pagination?.page || 1;
 	const limit = params.pagination?.limit || 10;
 	const offset = (page - 1) * limit;
-	const whereClause = params.projectIds ? and(eq(projects.tenantId, params.tenantId), inArray(projects.id, params.projectIds)) : eq(projects.tenantId, params.tenantId);
+	const tenantScope = { tenantId: params.tenantId };
+	const whereClause = params.projectIds ? and(tenantScopedWhere(projects, tenantScope), inArray(projects.id, params.projectIds)) : tenantScopedWhere(projects, tenantScope);
 	const [data, totalResult] = await Promise.all([db.select().from(projects).where(whereClause).limit(limit).offset(offset).orderBy(desc(projects.createdAt)), db.select({ count: count() }).from(projects).where(whereClause)]);
 	const total = totalResult[0]?.count || 0;
 	return {
@@ -60,13 +63,12 @@ const listProjectsPaginated = (db) => async (params) => {
 * Get resource counts for a specific project
 */
 const getProjectResourceCounts = (db) => async (params) => {
-	const whereClause = (table) => and(eq(table.tenantId, params.tenantId), eq(table.projectId, params.projectId));
 	const [subAgentResults, agentResults, toolResults, contextConfigResults, externalAgentResults] = await Promise.all([
-		db.select({ count: subAgents.id }).from(subAgents).where(whereClause(subAgents)),
-		db.select({ count: agents.id }).from(agents).where(whereClause(agents)),
-		db.select({ count: tools.id }).from(tools).where(whereClause(tools)),
-		db.select({ count: contextConfigs.id }).from(contextConfigs).where(whereClause(contextConfigs)),
-		db.select({ count: externalAgents.id }).from(externalAgents).where(whereClause(externalAgents))
+		db.select({ count: subAgents.id }).from(subAgents).where(projectScopedWhere(subAgents, params)),
+		db.select({ count: agents.id }).from(agents).where(projectScopedWhere(agents, params)),
+		db.select({ count: tools.id }).from(tools).where(projectScopedWhere(tools, params)),
+		db.select({ count: contextConfigs.id }).from(contextConfigs).where(projectScopedWhere(contextConfigs, params)),
+		db.select({ count: externalAgents.id }).from(externalAgents).where(projectScopedWhere(externalAgents, params))
 	]);
 	return {
 		subAgents: subAgentResults.length,
@@ -80,13 +82,12 @@ const getProjectResourceCounts = (db) => async (params) => {
 * Check if a project exists (has any resources)
 */
 const projectExists = (db) => async (params) => {
-	const whereClause = (table) => and(eq(table.tenantId, params.tenantId), eq(table.projectId, params.projectId));
 	const checks = [
-		db.select({ id: subAgents.id }).from(subAgents).where(whereClause(subAgents)).limit(1),
-		db.select({ id: agents.id }).from(agents).where(whereClause(agents)).limit(1),
-		db.select({ id: tools.id }).from(tools).where(whereClause(tools)).limit(1),
-		db.select({ id: contextConfigs.id }).from(contextConfigs).where(whereClause(contextConfigs)).limit(1),
-		db.select({ id: externalAgents.id }).from(externalAgents).where(whereClause(externalAgents)).limit(1)
+		db.select({ id: subAgents.id }).from(subAgents).where(projectScopedWhere(subAgents, params)).limit(1),
+		db.select({ id: agents.id }).from(agents).where(projectScopedWhere(agents, params)).limit(1),
+		db.select({ id: tools.id }).from(tools).where(projectScopedWhere(tools, params)).limit(1),
+		db.select({ id: contextConfigs.id }).from(contextConfigs).where(projectScopedWhere(contextConfigs, params)).limit(1),
+		db.select({ id: externalAgents.id }).from(externalAgents).where(projectScopedWhere(externalAgents, params)).limit(1)
 	];
 	return (await Promise.all(checks)).some((result) => result.length > 0);
 };
@@ -100,7 +101,7 @@ const countProjects = (db) => async (params) => {
 * Get a single project by ID
 */
 const getProject = (db) => async (params) => {
-	return await db.query.projects.findFirst({ where: and(eq(projects.tenantId, params.scopes.tenantId), eq(projects.id, params.scopes.projectId)) }) || null;
+	return await db.query.projects.findFirst({ where: and(tenantScopedWhere(projects, params.scopes), eq(projects.id, params.scopes.projectId)) }) || null;
 };
 /**
 * Create a new project
@@ -119,11 +120,12 @@ const createProject = (db) => async (params) => {
 */
 const updateProject = (db) => async (params) => {
 	const now = (/* @__PURE__ */ new Date()).toISOString();
-	const currentProject = await db.query.projects.findFirst({ where: and(eq(projects.tenantId, params.scopes.tenantId), eq(projects.id, params.scopes.projectId)) });
+	const projectWhere = and(tenantScopedWhere(projects, params.scopes), eq(projects.id, params.scopes.projectId));
+	const currentProject = await db.query.projects.findFirst({ where: projectWhere });
 	const [updated] = await db.update(projects).set({
 		...params.data,
 		updatedAt: now
-	}).where(and(eq(projects.tenantId, params.scopes.tenantId), eq(projects.id, params.scopes.projectId))).returning();
+	}).where(projectWhere).returning();
 	if (updated && params.data.stopWhen !== void 0) try {
 		await cascadeStopWhenUpdates(db, params.scopes, currentProject?.stopWhen, params.data.stopWhen);
 	} catch (error) {
@@ -135,7 +137,7 @@ const updateProject = (db) => async (params) => {
 * Check if a project exists in the projects table
 */
 const projectExistsInTable = (db) => async (params) => {
-	return (await db.select({ id: projects.id }).from(projects).where(and(eq(projects.tenantId, params.scopes.tenantId), eq(projects.id, params.scopes.projectId))).limit(1)).length > 0;
+	return (await db.select({ id: projects.id }).from(projects).where(and(tenantScopedWhere(projects, params.scopes), eq(projects.id, params.scopes.projectId))).limit(1)).length > 0;
 };
 /**
 * Check if a project has any resources (used before deletion)
@@ -148,16 +150,15 @@ const projectHasResources = (db) => async (params) => {
 */
 const deleteProject = (db) => async (params) => {
 	if (!await projectExistsInTable(db)({ scopes: params.scopes })) return false;
-	await db.delete(projects).where(and(eq(projects.tenantId, params.scopes.tenantId), eq(projects.id, params.scopes.projectId)));
+	await db.delete(projects).where(and(tenantScopedWhere(projects, params.scopes), eq(projects.id, params.scopes.projectId)));
 	return true;
 };
 /**
 * Cascade stopWhen updates from project to Agents and Sub Agents
 */
 async function cascadeStopWhenUpdates(db, scopes, oldStopWhen, newStopWhen) {
-	const { tenantId, projectId } = scopes;
 	if (oldStopWhen?.transferCountIs !== newStopWhen?.transferCountIs) {
-		const agentsToUpdate = await db.query.agents.findMany({ where: and(eq(agents.tenantId, tenantId), eq(agents.projectId, projectId)) });
+		const agentsToUpdate = await db.query.agents.findMany({ where: projectScopedWhere(agents, scopes) });
 		for (const agent of agentsToUpdate) {
 			const agentStopWhen = agent.stopWhen;
 			if (!agentStopWhen?.transferCountIs || agentStopWhen.transferCountIs === oldStopWhen?.transferCountIs) {
@@ -168,12 +169,12 @@ async function cascadeStopWhenUpdates(db, scopes, oldStopWhen, newStopWhen) {
 				await db.update(agents).set({
 					stopWhen: updatedStopWhen,
 					updatedAt: (/* @__PURE__ */ new Date()).toISOString()
-				}).where(and(eq(agents.tenantId, tenantId), eq(agents.projectId, projectId), eq(agents.id, agent.id)));
+				}).where(and(projectScopedWhere(agents, scopes), eq(agents.id, agent.id)));
 			}
 		}
 	}
 	if (oldStopWhen?.stepCountIs !== newStopWhen?.stepCountIs) {
-		const agentsToUpdate = await db.query.subAgents.findMany({ where: and(eq(subAgents.tenantId, tenantId), eq(subAgents.projectId, projectId)) });
+		const agentsToUpdate = await db.query.subAgents.findMany({ where: projectScopedWhere(subAgents, scopes) });
 		for (const agent of agentsToUpdate) {
 			const agentStopWhen = agent.stopWhen;
 			if (!agentStopWhen?.stepCountIs || agentStopWhen.stepCountIs === oldStopWhen?.stepCountIs) {
@@ -184,7 +185,7 @@ async function cascadeStopWhenUpdates(db, scopes, oldStopWhen, newStopWhen) {
 				await db.update(subAgents).set({
 					stopWhen: updatedStopWhen,
 					updatedAt: (/* @__PURE__ */ new Date()).toISOString()
-				}).where(and(eq(subAgents.tenantId, tenantId), eq(subAgents.projectId, projectId), eq(subAgents.id, agent.id)));
+				}).where(and(projectScopedWhere(subAgents, scopes), eq(subAgents.id, agent.id)));
 			}
 		}
 	}

package/dist/data-access/manage/scheduledTriggers.js

@@ -1,4 +1,5 @@
 import { scheduledTriggers } from "../../db/manage/manage-schema.js";
+import { agentScopedWhere, projectScopedWhere } from "./scope-helpers.js";
 import { and, count, desc, eq } from "drizzle-orm";
 
 //#region src/data-access/manage/scheduledTriggers.ts
@@ -7,7 +8,7 @@ import { and, count, desc, eq } from "drizzle-orm";
 */
 const getScheduledTriggerById = (db) => async (params) => {
 	const { scopes, scheduledTriggerId } = params;
-	return await db.query.scheduledTriggers.findFirst({ where: and(eq(scheduledTriggers.tenantId, scopes.tenantId), eq(scheduledTriggers.projectId, scopes.projectId), eq(scheduledTriggers.agentId, scopes.agentId), eq(scheduledTriggers.id, scheduledTriggerId)) });
+	return await db.query.scheduledTriggers.findFirst({ where: and(agentScopedWhere(scheduledTriggers, scopes), eq(scheduledTriggers.id, scheduledTriggerId)) });
 };
 /**
 * List scheduled triggers for an agent with pagination
@@ -16,7 +17,7 @@ const listScheduledTriggersPaginated = (db) => async (params) => {
 	const page = params.pagination?.page || 1;
 	const limit = Math.min(params.pagination?.limit || 10, 100);
 	const offset = (page - 1) * limit;
-	const whereClause = and(eq(scheduledTriggers.tenantId, params.scopes.tenantId), eq(scheduledTriggers.projectId, params.scopes.projectId), eq(scheduledTriggers.agentId, params.scopes.agentId));
+	const whereClause = agentScopedWhere(scheduledTriggers, params.scopes);
 	const [data, totalResult] = await Promise.all([db.select().from(scheduledTriggers).where(whereClause).limit(limit).offset(offset).orderBy(desc(scheduledTriggers.createdAt)), db.select({ count: count() }).from(scheduledTriggers).where(whereClause)]);
 	const total = totalResult[0]?.count || 0;
 	return {
@@ -43,13 +44,13 @@ const updateScheduledTrigger = (db) => async (params) => {
 		...params.data,
 		updatedAt: (/* @__PURE__ */ new Date()).toISOString()
 	};
-	return (await db.update(scheduledTriggers).set(updateData).where(and(eq(scheduledTriggers.tenantId, params.scopes.tenantId), eq(scheduledTriggers.projectId, params.scopes.projectId), eq(scheduledTriggers.agentId, params.scopes.agentId), eq(scheduledTriggers.id, params.scheduledTriggerId))).returning())[0];
+	return (await db.update(scheduledTriggers).set(updateData).where(and(agentScopedWhere(scheduledTriggers, params.scopes), eq(scheduledTriggers.id, params.scheduledTriggerId))).returning())[0];
 };
 /**
 * Delete a scheduled trigger (agent-scoped)
 */
 const deleteScheduledTrigger = (db) => async (params) => {
-	await db.delete(scheduledTriggers).where(and(eq(scheduledTriggers.tenantId, params.scopes.tenantId), eq(scheduledTriggers.projectId, params.scopes.projectId), eq(scheduledTriggers.agentId, params.scopes.agentId), eq(scheduledTriggers.id, params.scheduledTriggerId)));
+	await db.delete(scheduledTriggers).where(and(agentScopedWhere(scheduledTriggers, params.scopes), eq(scheduledTriggers.id, params.scheduledTriggerId)));
 };
 /**
 * Upsert a scheduled trigger (create if it doesn't exist, update if it does)
@@ -70,13 +71,16 @@ const upsertScheduledTrigger = (db) => async (params) => {
 * Operates across all agents in the project (not agent-scoped).
 */
 const deleteScheduledTriggersByRunAsUserId = (db) => async (params) => {
-	await db.delete(scheduledTriggers).where(and(eq(scheduledTriggers.tenantId, params.tenantId), eq(scheduledTriggers.projectId, params.projectId), eq(scheduledTriggers.runAsUserId, params.runAsUserId)));
+	await db.delete(scheduledTriggers).where(and(projectScopedWhere(scheduledTriggers, {
+		tenantId: params.tenantId,
+		projectId: params.projectId
+	}), eq(scheduledTriggers.runAsUserId, params.runAsUserId)));
 };
 /**
 * List all scheduled triggers for an agent (non-paginated, used by agentFull)
 */
 const listScheduledTriggers = (db) => async (params) => {
-	return await db.select().from(scheduledTriggers).where(and(eq(scheduledTriggers.tenantId, params.scopes.tenantId), eq(scheduledTriggers.projectId, params.scopes.projectId), eq(scheduledTriggers.agentId, params.scopes.agentId)));
+	return await db.select().from(scheduledTriggers).where(agentScopedWhere(scheduledTriggers, params.scopes));
 };
 
 //#endregion