@inkeep/agents-core 0.58.14 → 0.58.15

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

@@ -9,14 +9,14 @@ declare const getSubAgentTeamAgentRelationById: (db: AgentsManageDatabaseClient)
   scopes: SubAgentScopeConfig;
   relationId: string;
 }) => Promise<{
+  tenantId: string;
+  projectId: string;
+  agentId: string;
+  subAgentId: string;
   id: string;
   createdAt: string;
   updatedAt: string;
-  subAgentId: string;
-  projectId: string;
-  tenantId: string;
   headers: Record<string, string> | null;
-  agentId: string;
   targetAgentId: string;
 } | undefined>;
 declare const listSubAgentTeamAgentRelations: (db: AgentsManageDatabaseClient) => (params: {
@@ -44,27 +44,27 @@ declare const listSubAgentTeamAgentRelations: (db: AgentsManageDatabaseClient) =
 declare const getSubAgentTeamAgentRelations: (db: AgentsManageDatabaseClient) => (params: {
   scopes: SubAgentScopeConfig;
 }) => Promise<{
+  tenantId: string;
+  projectId: string;
+  agentId: string;
+  subAgentId: string;
   id: string;
   createdAt: string;
   updatedAt: string;
-  subAgentId: string;
-  projectId: string;
-  tenantId: string;
   headers: Record<string, string> | null;
-  agentId: string;
   targetAgentId: string;
 }[]>;
 declare const getSubAgentTeamAgentRelationsByAgent: (db: AgentsManageDatabaseClient) => (params: {
   scopes: AgentScopeConfig;
 }) => Promise<{
+  tenantId: string;
+  projectId: string;
+  agentId: string;
+  subAgentId: string;
   id: string;
   createdAt: string;
   updatedAt: string;
-  subAgentId: string;
-  projectId: string;
-  tenantId: string;
   headers: Record<string, string> | null;
-  agentId: string;
   targetAgentId: string;
 }[]>;
 declare const getSubAgentTeamAgentRelationsByTeamAgent: (db: AgentsManageDatabaseClient) => (params: {
@@ -210,14 +210,14 @@ declare const createSubAgentTeamAgentRelation: (db: AgentsManageDatabaseClient)
     headers?: Record<string, string> | null;
   };
 }) => Promise<{
+  tenantId: string;
+  projectId: string;
+  agentId: string;
+  subAgentId: string;
   id: string;
   createdAt: string;
   updatedAt: string;
-  subAgentId: string;
-  projectId: string;
-  tenantId: string;
   headers: Record<string, string> | null;
-  agentId: string;
   targetAgentId: string;
 }>;
 /**
@@ -227,14 +227,14 @@ declare const getSubAgentTeamAgentRelationByParams: (db: AgentsManageDatabaseCli
   scopes: SubAgentScopeConfig;
   targetAgentId: string;
 }) => Promise<{
+  tenantId: string;
+  projectId: string;
+  agentId: string;
+  subAgentId: string;
   id: string;
   createdAt: string;
   updatedAt: string;
-  subAgentId: string;
-  projectId: string;
-  tenantId: string;
   headers: Record<string, string> | null;
-  agentId: string;
   targetAgentId: string;
 } | undefined>;
 /**
@@ -248,14 +248,14 @@ declare const upsertSubAgentTeamAgentRelation: (db: AgentsManageDatabaseClient)
     headers?: Record<string, string> | null;
   };
 }) => Promise<{
+  tenantId: string;
+  projectId: string;
+  agentId: string;
+  subAgentId: string;
   id: string;
   createdAt: string;
   updatedAt: string;
-  subAgentId: string;
-  projectId: string;
-  tenantId: string;
   headers: Record<string, string> | null;
-  agentId: string;
   targetAgentId: string;
 }>;
 declare const updateSubAgentTeamAgentRelation: (db: AgentsManageDatabaseClient) => (params: {

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

@@ -1,16 +1,17 @@
 import { agents, subAgentTeamAgentRelations, subAgents } from "../../db/manage/manage-schema.js";
+import { agentScopedWhere, subAgentScopedWhere } from "./scope-helpers.js";
 import { and, count, desc, eq } from "drizzle-orm";
 import { nanoid } from "nanoid";
 
 //#region src/data-access/manage/subAgentTeamAgentRelations.ts
 const getSubAgentTeamAgentRelationById = (db) => async (params) => {
-	return db.query.subAgentTeamAgentRelations.findFirst({ where: and(eq(subAgentTeamAgentRelations.tenantId, params.scopes.tenantId), eq(subAgentTeamAgentRelations.projectId, params.scopes.projectId), eq(subAgentTeamAgentRelations.agentId, params.scopes.agentId), eq(subAgentTeamAgentRelations.subAgentId, params.scopes.subAgentId), eq(subAgentTeamAgentRelations.id, params.relationId)) });
+	return db.query.subAgentTeamAgentRelations.findFirst({ where: and(subAgentScopedWhere(subAgentTeamAgentRelations, params.scopes), eq(subAgentTeamAgentRelations.id, params.relationId)) });
 };
 const listSubAgentTeamAgentRelations = (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(subAgentTeamAgentRelations.tenantId, params.scopes.tenantId), eq(subAgentTeamAgentRelations.projectId, params.scopes.projectId), eq(subAgentTeamAgentRelations.agentId, params.scopes.agentId), eq(subAgentTeamAgentRelations.subAgentId, params.scopes.subAgentId));
+	const whereClause = subAgentScopedWhere(subAgentTeamAgentRelations, params.scopes);
 	const [data, totalResult] = await Promise.all([db.select().from(subAgentTeamAgentRelations).where(whereClause).limit(limit).offset(offset).orderBy(desc(subAgentTeamAgentRelations.createdAt)), db.select({ count: count() }).from(subAgentTeamAgentRelations).where(whereClause)]);
 	const total = totalResult[0]?.count || 0;
 	return {
@@ -24,16 +25,16 @@ const listSubAgentTeamAgentRelations = (db) => async (params) => {
 	};
 };
 const getSubAgentTeamAgentRelations = (db) => async (params) => {
-	return await db.query.subAgentTeamAgentRelations.findMany({ where: and(eq(subAgentTeamAgentRelations.tenantId, params.scopes.tenantId), eq(subAgentTeamAgentRelations.projectId, params.scopes.projectId), eq(subAgentTeamAgentRelations.agentId, params.scopes.agentId), eq(subAgentTeamAgentRelations.subAgentId, params.scopes.subAgentId)) });
+	return await db.query.subAgentTeamAgentRelations.findMany({ where: subAgentScopedWhere(subAgentTeamAgentRelations, params.scopes) });
 };
 const getSubAgentTeamAgentRelationsByAgent = (db) => async (params) => {
-	return await db.query.subAgentTeamAgentRelations.findMany({ where: and(eq(subAgentTeamAgentRelations.tenantId, params.scopes.tenantId), eq(subAgentTeamAgentRelations.projectId, params.scopes.projectId), eq(subAgentTeamAgentRelations.agentId, params.scopes.agentId)) });
+	return await db.query.subAgentTeamAgentRelations.findMany({ where: agentScopedWhere(subAgentTeamAgentRelations, params.scopes) });
 };
 const getSubAgentTeamAgentRelationsByTeamAgent = (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(subAgentTeamAgentRelations.tenantId, params.scopes.tenantId), eq(subAgentTeamAgentRelations.projectId, params.scopes.projectId), eq(subAgentTeamAgentRelations.agentId, params.scopes.agentId), eq(subAgentTeamAgentRelations.targetAgentId, params.targetAgentId));
+	const whereClause = and(agentScopedWhere(subAgentTeamAgentRelations, params.scopes), eq(subAgentTeamAgentRelations.targetAgentId, params.targetAgentId));
 	const [data, totalResult] = await Promise.all([db.select().from(subAgentTeamAgentRelations).where(whereClause).limit(limit).offset(offset).orderBy(desc(subAgentTeamAgentRelations.createdAt)), db.select({ count: count() }).from(subAgentTeamAgentRelations).where(whereClause)]);
 	const total = totalResult[0]?.count || 0;
 	return {
@@ -50,6 +51,7 @@ const getTeamAgentsForSubAgent = (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 = subAgentScopedWhere(subAgentTeamAgentRelations, params.scopes);
 	const [data, totalResult] = await Promise.all([db.select({
 		id: subAgentTeamAgentRelations.id,
 		tenantId: subAgentTeamAgentRelations.tenantId,
@@ -73,7 +75,7 @@ const getTeamAgentsForSubAgent = (db) => async (params) => {
 			createdAt: agents.createdAt,
 			updatedAt: agents.updatedAt
 		}
-	}).from(subAgentTeamAgentRelations).innerJoin(agents, and(eq(subAgentTeamAgentRelations.tenantId, agents.tenantId), eq(subAgentTeamAgentRelations.projectId, agents.projectId), eq(subAgentTeamAgentRelations.targetAgentId, agents.id))).where(and(eq(subAgentTeamAgentRelations.tenantId, params.scopes.tenantId), eq(subAgentTeamAgentRelations.projectId, params.scopes.projectId), eq(subAgentTeamAgentRelations.agentId, params.scopes.agentId), eq(subAgentTeamAgentRelations.subAgentId, params.scopes.subAgentId))).limit(limit).offset(offset).orderBy(desc(subAgentTeamAgentRelations.createdAt)), db.select({ count: count() }).from(subAgentTeamAgentRelations).where(and(eq(subAgentTeamAgentRelations.tenantId, params.scopes.tenantId), eq(subAgentTeamAgentRelations.projectId, params.scopes.projectId), eq(subAgentTeamAgentRelations.agentId, params.scopes.agentId), eq(subAgentTeamAgentRelations.subAgentId, params.scopes.subAgentId)))]);
+	}).from(subAgentTeamAgentRelations).innerJoin(agents, and(eq(subAgentTeamAgentRelations.tenantId, agents.tenantId), eq(subAgentTeamAgentRelations.projectId, agents.projectId), eq(subAgentTeamAgentRelations.targetAgentId, agents.id))).where(whereClause).limit(limit).offset(offset).orderBy(desc(subAgentTeamAgentRelations.createdAt)), db.select({ count: count() }).from(subAgentTeamAgentRelations).where(whereClause)]);
 	const total = totalResult[0]?.count || 0;
 	return {
 		data,
@@ -89,6 +91,7 @@ const getSubAgentsForTeamAgent = (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(agentScopedWhere(subAgentTeamAgentRelations, params.scopes), eq(subAgentTeamAgentRelations.targetAgentId, params.targetAgentId));
 	const [data, totalResult] = await Promise.all([db.select({
 		id: subAgentTeamAgentRelations.id,
 		tenantId: subAgentTeamAgentRelations.tenantId,
@@ -109,7 +112,7 @@ const getSubAgentsForTeamAgent = (db) => async (params) => {
 			createdAt: subAgents.createdAt,
 			updatedAt: subAgents.updatedAt
 		}
-	}).from(subAgentTeamAgentRelations).innerJoin(subAgents, and(eq(subAgentTeamAgentRelations.subAgentId, subAgents.id), eq(subAgentTeamAgentRelations.tenantId, subAgents.tenantId), eq(subAgentTeamAgentRelations.projectId, subAgents.projectId), eq(subAgentTeamAgentRelations.agentId, subAgents.agentId))).where(and(eq(subAgentTeamAgentRelations.tenantId, params.scopes.tenantId), eq(subAgentTeamAgentRelations.projectId, params.scopes.projectId), eq(subAgentTeamAgentRelations.agentId, params.scopes.agentId), eq(subAgentTeamAgentRelations.targetAgentId, params.targetAgentId))).limit(limit).offset(offset).orderBy(desc(subAgentTeamAgentRelations.createdAt)), db.select({ count: count() }).from(subAgentTeamAgentRelations).where(and(eq(subAgentTeamAgentRelations.tenantId, params.scopes.tenantId), eq(subAgentTeamAgentRelations.projectId, params.scopes.projectId), eq(subAgentTeamAgentRelations.agentId, params.scopes.agentId), eq(subAgentTeamAgentRelations.targetAgentId, params.targetAgentId)))]);
+	}).from(subAgentTeamAgentRelations).innerJoin(subAgents, and(eq(subAgentTeamAgentRelations.subAgentId, subAgents.id), eq(subAgentTeamAgentRelations.tenantId, subAgents.tenantId), eq(subAgentTeamAgentRelations.projectId, subAgents.projectId), eq(subAgentTeamAgentRelations.agentId, subAgents.agentId))).where(whereClause).limit(limit).offset(offset).orderBy(desc(subAgentTeamAgentRelations.createdAt)), db.select({ count: count() }).from(subAgentTeamAgentRelations).where(whereClause)]);
 	const total = totalResult[0]?.count || 0;
 	return {
 		data,
@@ -125,10 +128,7 @@ const createSubAgentTeamAgentRelation = (db) => async (params) => {
 	const finalRelationId = params.relationId ?? nanoid();
 	return (await db.insert(subAgentTeamAgentRelations).values({
 		id: finalRelationId,
-		tenantId: params.scopes.tenantId,
-		projectId: params.scopes.projectId,
-		agentId: params.scopes.agentId,
-		subAgentId: params.scopes.subAgentId,
+		...params.scopes,
 		targetAgentId: params.data.targetAgentId,
 		headers: params.data.headers
 	}).returning())[0];
@@ -137,7 +137,7 @@ const createSubAgentTeamAgentRelation = (db) => async (params) => {
 * Check if sub-agent team agent relation exists by params
 */
 const getSubAgentTeamAgentRelationByParams = (db) => async (params) => {
-	return db.query.subAgentTeamAgentRelations.findFirst({ where: and(eq(subAgentTeamAgentRelations.tenantId, params.scopes.tenantId), eq(subAgentTeamAgentRelations.projectId, params.scopes.projectId), eq(subAgentTeamAgentRelations.agentId, params.scopes.agentId), eq(subAgentTeamAgentRelations.subAgentId, params.scopes.subAgentId), eq(subAgentTeamAgentRelations.targetAgentId, params.targetAgentId)) });
+	return db.query.subAgentTeamAgentRelations.findFirst({ where: and(subAgentScopedWhere(subAgentTeamAgentRelations, params.scopes), eq(subAgentTeamAgentRelations.targetAgentId, params.targetAgentId)) });
 };
 /**
 * Upsert sub-agent team agent relation (create if it doesn't exist, update if it does)
@@ -164,16 +164,16 @@ const updateSubAgentTeamAgentRelation = (db) => async (params) => {
 		...params.data,
 		updatedAt: (/* @__PURE__ */ new Date()).toISOString()
 	};
-	return (await db.update(subAgentTeamAgentRelations).set(updateData).where(and(eq(subAgentTeamAgentRelations.tenantId, params.scopes.tenantId), eq(subAgentTeamAgentRelations.projectId, params.scopes.projectId), eq(subAgentTeamAgentRelations.agentId, params.scopes.agentId), eq(subAgentTeamAgentRelations.subAgentId, params.scopes.subAgentId), eq(subAgentTeamAgentRelations.id, params.relationId))).returning())[0];
+	return (await db.update(subAgentTeamAgentRelations).set(updateData).where(and(subAgentScopedWhere(subAgentTeamAgentRelations, params.scopes), eq(subAgentTeamAgentRelations.id, params.relationId))).returning())[0];
 };
 const deleteSubAgentTeamAgentRelation = (db) => async (params) => {
-	return (await db.delete(subAgentTeamAgentRelations).where(and(eq(subAgentTeamAgentRelations.tenantId, params.scopes.tenantId), eq(subAgentTeamAgentRelations.projectId, params.scopes.projectId), eq(subAgentTeamAgentRelations.agentId, params.scopes.agentId), eq(subAgentTeamAgentRelations.subAgentId, params.scopes.subAgentId), eq(subAgentTeamAgentRelations.id, params.relationId))).returning()).length > 0;
+	return (await db.delete(subAgentTeamAgentRelations).where(and(subAgentScopedWhere(subAgentTeamAgentRelations, params.scopes), eq(subAgentTeamAgentRelations.id, params.relationId))).returning()).length > 0;
 };
 const deleteSubAgentTeamAgentRelationsBySubAgent = (db) => async (params) => {
-	return (await db.delete(subAgentTeamAgentRelations).where(and(eq(subAgentTeamAgentRelations.tenantId, params.scopes.tenantId), eq(subAgentTeamAgentRelations.projectId, params.scopes.projectId), eq(subAgentTeamAgentRelations.agentId, params.scopes.agentId), eq(subAgentTeamAgentRelations.subAgentId, params.scopes.subAgentId))).returning()).length > 0;
+	return (await db.delete(subAgentTeamAgentRelations).where(subAgentScopedWhere(subAgentTeamAgentRelations, params.scopes)).returning()).length > 0;
 };
 const deleteSubAgentTeamAgentRelationsByAgent = (db) => async (params) => {
-	return (await db.delete(subAgentTeamAgentRelations).where(and(eq(subAgentTeamAgentRelations.tenantId, params.scopes.tenantId), eq(subAgentTeamAgentRelations.projectId, params.scopes.projectId), eq(subAgentTeamAgentRelations.agentId, params.scopes.agentId))).returning()).length > 0;
+	return (await db.delete(subAgentTeamAgentRelations).where(agentScopedWhere(subAgentTeamAgentRelations, params.scopes)).returning()).length > 0;
 };
 
 //#endregion

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

@@ -9,13 +9,14 @@ declare const getSubAgentById: (db: AgentsManageDatabaseClient) => (params: {
   scopes: AgentScopeConfig;
   subAgentId: string;
 }) => 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;
   models: {
     base?: {
       model?: string | undefined;
@@ -35,18 +36,18 @@ declare const getSubAgentById: (db: AgentsManageDatabaseClient) => (params: {
   } | null;
   prompt: string | null;
   conversationHistoryConfig: ConversationHistoryConfig | null;
-  agentId: string;
 } | undefined>;
 declare const listSubAgents: (db: AgentsManageDatabaseClient) => (params: {
   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;
   models: {
     base?: {
       model?: string | undefined;
@@ -66,7 +67,6 @@ declare const listSubAgents: (db: AgentsManageDatabaseClient) => (params: {
   } | null;
   prompt: string | null;
   conversationHistoryConfig: ConversationHistoryConfig | null;
-  agentId: string;
 }[]>;
 declare const listSubAgentsPaginated: (db: AgentsManageDatabaseClient) => (params: {
   scopes: AgentScopeConfig;
@@ -109,13 +109,14 @@ declare const listSubAgentsPaginated: (db: AgentsManageDatabaseClient) => (param
   };
 }>;
 declare const createSubAgent: (db: AgentsManageDatabaseClient) => (params: SubAgentInsert) => 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;
   models: {
     base?: {
       model?: string | undefined;
@@ -135,7 +136,6 @@ declare const createSubAgent: (db: AgentsManageDatabaseClient) => (params: SubAg
   } | null;
   prompt: string | null;
   conversationHistoryConfig: ConversationHistoryConfig | null;
-  agentId: string;
 }>;
 declare const updateSubAgent: (db: AgentsManageDatabaseClient) => (params: {
   scopes: AgentScopeConfig;

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

@@ -1,18 +1,19 @@
 import { agents, subAgents } from "../../db/manage/manage-schema.js";
+import { agentScopedWhere, projectScopedWhere } from "./scope-helpers.js";
 import { and, count, desc, eq, inArray } from "drizzle-orm";
 
 //#region src/data-access/manage/subAgents.ts
 const getSubAgentById = (db) => async (params) => {
-	return await db.query.subAgents.findFirst({ where: and(eq(subAgents.tenantId, params.scopes.tenantId), eq(subAgents.projectId, params.scopes.projectId), eq(subAgents.agentId, params.scopes.agentId), eq(subAgents.id, params.subAgentId)) });
+	return await db.query.subAgents.findFirst({ where: and(agentScopedWhere(subAgents, params.scopes), eq(subAgents.id, params.subAgentId)) });
 };
 const listSubAgents = (db) => async (params) => {
-	return await db.query.subAgents.findMany({ where: and(eq(subAgents.tenantId, params.scopes.tenantId), eq(subAgents.projectId, params.scopes.projectId), eq(subAgents.agentId, params.scopes.agentId)) });
+	return await db.query.subAgents.findMany({ where: agentScopedWhere(subAgents, params.scopes) });
 };
 const listSubAgentsPaginated = (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(subAgents.tenantId, params.scopes.tenantId), eq(subAgents.projectId, params.scopes.projectId), eq(subAgents.agentId, params.scopes.agentId));
+	const whereClause = agentScopedWhere(subAgents, params.scopes);
 	const [data, totalResult] = await Promise.all([db.select().from(subAgents).where(whereClause).limit(limit).offset(offset).orderBy(desc(subAgents.createdAt)), db.select({ count: count() }).from(subAgents).where(whereClause)]);
 	const total = totalResult[0]?.count || 0;
 	return {
@@ -37,7 +38,7 @@ const updateSubAgent = (db) => async (params) => {
 		...data,
 		updatedAt: (/* @__PURE__ */ new Date()).toISOString()
 	};
-	return (await db.update(subAgents).set(updateData).where(and(eq(subAgents.tenantId, params.scopes.tenantId), eq(subAgents.projectId, params.scopes.projectId), eq(subAgents.agentId, params.scopes.agentId), inArray(subAgents.id, [params.subAgentId]))).returning())[0] ?? null;
+	return (await db.update(subAgents).set(updateData).where(and(agentScopedWhere(subAgents, params.scopes), inArray(subAgents.id, [params.subAgentId]))).returning())[0] ?? null;
 };
 /**
 * Upsert agent (create if it doesn't exist, update if it does)
@@ -78,8 +79,8 @@ var SubAgentIsDefaultError = class extends Error {
 	}
 };
 const deleteSubAgent = (db) => async (params) => {
-	if ((await db.select().from(agents).where(and(eq(agents.tenantId, params.scopes.tenantId), eq(agents.projectId, params.scopes.projectId), eq(agents.id, params.scopes.agentId), eq(agents.defaultSubAgentId, params.subAgentId))).limit(1)).length > 0) throw new SubAgentIsDefaultError(params.subAgentId, params.scopes.agentId);
-	await db.delete(subAgents).where(and(eq(subAgents.tenantId, params.scopes.tenantId), eq(subAgents.projectId, params.scopes.projectId), eq(subAgents.agentId, params.scopes.agentId), inArray(subAgents.id, [params.subAgentId])));
+	if ((await db.select().from(agents).where(and(projectScopedWhere(agents, params.scopes), eq(agents.id, params.scopes.agentId), eq(agents.defaultSubAgentId, params.subAgentId))).limit(1)).length > 0) throw new SubAgentIsDefaultError(params.subAgentId, params.scopes.agentId);
+	await db.delete(subAgents).where(and(agentScopedWhere(subAgents, params.scopes), inArray(subAgents.id, [params.subAgentId])));
 	return await getSubAgentById(db)({
 		scopes: params.scopes,
 		subAgentId: params.subAgentId
@@ -87,7 +88,7 @@ const deleteSubAgent = (db) => async (params) => {
 };
 const getSubAgentsByIds = (db) => async (params) => {
 	if (params.subAgentIds.length === 0) return [];
-	return await db.select().from(subAgents).where(and(eq(subAgents.tenantId, params.scopes.tenantId), eq(subAgents.projectId, params.scopes.projectId), eq(subAgents.agentId, params.scopes.agentId), inArray(subAgents.id, params.subAgentIds)));
+	return await db.select().from(subAgents).where(and(agentScopedWhere(subAgents, params.scopes), inArray(subAgents.id, params.subAgentIds)));
 };
 
 //#endregion

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

@@ -20,13 +20,13 @@ declare const getToolById: (db: AgentsManageDatabaseClient) => (params: {
   scopes: ProjectScopeConfig;
   toolId: string;
 }) => Promise<{
+  tenantId: string;
+  projectId: string;
   id: string;
   name: string;
+  description: string | null;
   createdAt: string;
   updatedAt: string;
-  description: string | null;
-  projectId: string;
-  tenantId: string;
   headers: Record<string, string> | null;
   config: {
     type: "mcp";
@@ -78,13 +78,13 @@ declare const listTools: (db: AgentsManageDatabaseClient) => (params: {
   };
 }>;
 declare const createTool: (db: AgentsManageDatabaseClient) => (params: ToolInsert) => Promise<{
+  tenantId: string;
+  projectId: string;
   id: string;
   name: string;
+  description: string | null;
   createdAt: string;
   updatedAt: string;
-  description: string | null;
-  projectId: string;
-  tenantId: string;
   headers: Record<string, string> | null;
   config: {
     type: "mcp";
@@ -135,15 +135,15 @@ declare const addToolToAgent: (db: AgentsManageDatabaseClient) => (params: {
     needsApproval?: boolean;
   }> | null;
 }) => Promise<{
+  tenantId: string;
+  projectId: string;
+  agentId: string;
+  subAgentId: string;
+  toolId: string;
   id: string;
   createdAt: string;
   updatedAt: string;
-  subAgentId: string;
-  projectId: string;
-  tenantId: string;
   headers: Record<string, string> | null;
-  agentId: string;
-  toolId: string;
   toolPolicies: Record<string, {
     needsApproval?: boolean;
   }> | null;
@@ -154,15 +154,15 @@ declare const removeToolFromAgent: (db: AgentsManageDatabaseClient) => (params:
   subAgentId: string;
   toolId: string;
 }) => Promise<{
+  tenantId: string;
+  projectId: string;
+  agentId: string;
+  subAgentId: string;
+  toolId: string;
   id: string;
   createdAt: string;
   updatedAt: string;
-  subAgentId: string;
-  projectId: string;
-  tenantId: string;
   headers: Record<string, string> | null;
-  agentId: string;
-  toolId: string;
   toolPolicies: Record<string, {
     needsApproval?: boolean;
   }> | null;
@@ -182,15 +182,15 @@ declare const upsertSubAgentToolRelation: (db: AgentsManageDatabaseClient) => (p
   }> | null;
   relationId?: string;
 }) => Promise<{
+  tenantId: string;
+  projectId: string;
+  agentId: string;
+  subAgentId: string;
+  toolId: string;
   id: string;
   createdAt: string;
   updatedAt: string;
-  subAgentId: string;
-  projectId: string;
-  tenantId: string;
   headers: Record<string, string> | null;
-  agentId: string;
-  toolId: string;
   toolPolicies: Record<string, {
     needsApproval?: boolean;
   }> | null;
@@ -202,13 +202,13 @@ declare const upsertSubAgentToolRelation: (db: AgentsManageDatabaseClient) => (p
 declare const upsertTool: (db: AgentsManageDatabaseClient) => (params: {
   data: ToolInsert;
 }) => Promise<{
+  tenantId: string;
+  projectId: string;
   id: string;
   name: string;
+  description: string | null;
   createdAt: string;
   updatedAt: string;
-  description: string | null;
-  projectId: string;
-  tenantId: string;
   headers: Record<string, string> | null;
   config: {
     type: "mcp";

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

@@ -9,9 +9,11 @@ import "../../credential-stuffer/index.js";
 import { createAgentsRunDatabaseClient } from "../../db/runtime/runtime-client.js";
 import { generateId } from "../../utils/conversations.js";
 import { getActiveBranch } from "../../dolt/schema-sync.js";
+import { agentScopedWhere, projectScopedWhere } from "./scope-helpers.js";
 import { isSlackWorkAppTool } from "../runtime/slack-work-app-mcp.js";
 import { cascadeDeleteByTool } from "../runtime/cascade-delete.js";
 import { updateAgentToolRelation } from "./subAgentRelations.js";
+import { isSerializationError } from "../../retry/retryable-errors.js";
 import { toISODateString } from "../../utils/date.js";
 import { McpClient } from "../../utils/mcp-client.js";
 import { configureComposioMCPServer } from "../../utils/third-party-mcp-servers/composio-client.js";
@@ -270,7 +272,7 @@ const dbResultToMcpTool = async (dbResult, dbClient, credentialStoreRegistry, re
 			}
 		});
 	} catch (updateError) {
-		if (updateError instanceof Error && (updateError.message.includes("serialization failure") || updateError.message.includes("40001") || updateError.cause?.code === "XX000")) logger.debug({ toolId: dbResult.id }, "Skipping tool metadata update due to serialization conflict (concurrent request)");
+		if (isSerializationError(updateError)) logger.debug({ toolId: dbResult.id }, "Skipping tool metadata update due to serialization conflict (concurrent request)");
 		else logger.warn({
 			toolId: dbResult.id,
 			error: updateError
@@ -293,7 +295,7 @@ const dbResultToMcpTool = async (dbResult, dbClient, credentialStoreRegistry, re
 	};
 };
 const getToolById = (db) => async (params) => {
-	return await db.query.tools.findFirst({ where: and(eq(tools.tenantId, params.scopes.tenantId), eq(tools.projectId, params.scopes.projectId), eq(tools.id, params.toolId)) }) ?? null;
+	return await db.query.tools.findFirst({ where: and(projectScopedWhere(tools, params.scopes), eq(tools.id, params.toolId)) }) ?? null;
 };
 const getMcpToolById = (db) => async (params) => {
 	const tool = await getToolById(db)({
@@ -307,7 +309,7 @@ const listTools = (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(tools.tenantId, params.scopes.tenantId), eq(tools.projectId, params.scopes.projectId));
+	const whereClause = projectScopedWhere(tools, params.scopes);
 	const [toolsDbResults, totalResult] = await Promise.all([db.select().from(tools).where(whereClause).limit(limit).offset(offset).orderBy(desc(tools.createdAt)), db.select({ count: count() }).from(tools).where(whereClause)]);
 	const total = totalResult[0]?.count || 0;
 	return {
@@ -334,11 +336,11 @@ const updateTool = (db) => async (params) => {
 	const [updated] = await db.update(tools).set({
 		...params.data,
 		updatedAt: now
-	}).where(and(eq(tools.tenantId, params.scopes.tenantId), eq(tools.projectId, params.scopes.projectId), eq(tools.id, params.toolId))).returning();
+	}).where(and(projectScopedWhere(tools, params.scopes), eq(tools.id, params.toolId))).returning();
 	return updated ?? null;
 };
 const deleteTool = (db) => async (params) => {
-	const [deleted] = await db.delete(tools).where(and(eq(tools.tenantId, params.scopes.tenantId), eq(tools.projectId, params.scopes.projectId), eq(tools.id, params.toolId))).returning();
+	const [deleted] = await db.delete(tools).where(and(projectScopedWhere(tools, params.scopes), eq(tools.id, params.toolId))).returning();
 	if (!deleted) return false;
 	if (deleted.isWorkApp && deleted.config.mcp.server.url.includes("/github/mcp") || isSlackWorkAppTool(deleted)) try {
 		if (await getActiveBranch(db)() === `${params.scopes.tenantId}_${params.scopes.projectId}_main`) await cascadeDeleteByTool(createAgentsRunDatabaseClient())({
@@ -373,7 +375,7 @@ const addToolToAgent = (db) => async (params) => {
 	return created;
 };
 const removeToolFromAgent = (db) => async (params) => {
-	const [deleted] = await db.delete(subAgentToolRelations).where(and(eq(subAgentToolRelations.tenantId, params.scopes.tenantId), eq(subAgentToolRelations.projectId, params.scopes.projectId), eq(subAgentToolRelations.agentId, params.scopes.agentId), eq(subAgentToolRelations.subAgentId, params.subAgentId), eq(subAgentToolRelations.toolId, params.toolId))).returning();
+	const [deleted] = await db.delete(subAgentToolRelations).where(and(agentScopedWhere(subAgentToolRelations, params.scopes), eq(subAgentToolRelations.subAgentId, params.subAgentId), eq(subAgentToolRelations.toolId, params.toolId))).returning();
 	return deleted;
 };
 /**

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

@@ -1,4 +1,5 @@
 import { triggers } 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/triggers.ts
@@ -7,13 +8,13 @@ import { and, count, desc, eq } from "drizzle-orm";
 */
 const getTriggerById = (db) => async (params) => {
 	const { scopes, triggerId } = params;
-	return await db.query.triggers.findFirst({ where: and(eq(triggers.tenantId, scopes.tenantId), eq(triggers.projectId, scopes.projectId), eq(triggers.agentId, scopes.agentId), eq(triggers.id, triggerId)) });
+	return await db.query.triggers.findFirst({ where: and(agentScopedWhere(triggers, scopes), eq(triggers.id, triggerId)) });
 };
 /**
 * List all triggers for an agent
 */
 const listTriggers = (db) => async (params) => {
-	return await db.query.triggers.findMany({ where: and(eq(triggers.tenantId, params.scopes.tenantId), eq(triggers.projectId, params.scopes.projectId), eq(triggers.agentId, params.scopes.agentId)) });
+	return await db.query.triggers.findMany({ where: agentScopedWhere(triggers, params.scopes) });
 };
 /**
 * List triggers for an agent with pagination
@@ -22,7 +23,7 @@ const listTriggersPaginated = (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(triggers.tenantId, params.scopes.tenantId), eq(triggers.projectId, params.scopes.projectId), eq(triggers.agentId, params.scopes.agentId));
+	const whereClause = agentScopedWhere(triggers, params.scopes);
 	const [data, totalResult] = await Promise.all([db.select().from(triggers).where(whereClause).limit(limit).offset(offset).orderBy(desc(triggers.createdAt)), db.select({ count: count() }).from(triggers).where(whereClause)]);
 	const total = totalResult[0]?.count || 0;
 	return {
@@ -49,32 +50,35 @@ const updateTrigger = (db) => async (params) => {
 		...params.data,
 		updatedAt: (/* @__PURE__ */ new Date()).toISOString()
 	};
-	return (await db.update(triggers).set(updateData).where(and(eq(triggers.tenantId, params.scopes.tenantId), eq(triggers.projectId, params.scopes.projectId), eq(triggers.agentId, params.scopes.agentId), eq(triggers.id, params.triggerId))).returning())[0];
+	return (await db.update(triggers).set(updateData).where(and(agentScopedWhere(triggers, params.scopes), eq(triggers.id, params.triggerId))).returning())[0];
 };
 /**
 * Delete a trigger (agent-scoped)
 */
 const deleteTrigger = (db) => async (params) => {
-	await db.delete(triggers).where(and(eq(triggers.tenantId, params.scopes.tenantId), eq(triggers.projectId, params.scopes.projectId), eq(triggers.agentId, params.scopes.agentId), eq(triggers.id, params.triggerId)));
+	await db.delete(triggers).where(and(agentScopedWhere(triggers, params.scopes), eq(triggers.id, params.triggerId)));
 };
 /**
 * Delete all webhook triggers for a given runAsUserId within a tenant+project scope.
 * Operates across all agents in the project (not agent-scoped).
 */
 const deleteTriggersByRunAsUserId = (db) => async (params) => {
-	await db.delete(triggers).where(and(eq(triggers.tenantId, params.tenantId), eq(triggers.projectId, params.projectId), eq(triggers.runAsUserId, params.runAsUserId)));
+	await db.delete(triggers).where(and(projectScopedWhere(triggers, {
+		tenantId: params.tenantId,
+		projectId: params.projectId
+	}), eq(triggers.runAsUserId, params.runAsUserId)));
 };
 /**
 * Upsert a trigger (create or update based on existence)
 */
 const upsertTrigger = (db) => async (params) => {
 	const { scopes, data } = params;
-	if (await db.query.triggers.findFirst({ where: and(eq(triggers.tenantId, scopes.tenantId), eq(triggers.projectId, scopes.projectId), eq(triggers.agentId, scopes.agentId), eq(triggers.id, data.id)) })) {
+	if (await db.query.triggers.findFirst({ where: and(agentScopedWhere(triggers, scopes), eq(triggers.id, data.id)) })) {
 		const updateData = {
 			...data,
 			updatedAt: (/* @__PURE__ */ new Date()).toISOString()
 		};
-		return (await db.update(triggers).set(updateData).where(and(eq(triggers.tenantId, scopes.tenantId), eq(triggers.projectId, scopes.projectId), eq(triggers.agentId, scopes.agentId), eq(triggers.id, data.id))).returning())[0];
+		return (await db.update(triggers).set(updateData).where(and(agentScopedWhere(triggers, scopes), eq(triggers.id, data.id))).returning())[0];
 	}
 	return (await db.insert(triggers).values({
 		...data,