@inkeep/agents-core 0.58.13 → 0.58.15

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

@@ -1,4 +1,5 @@
 import { scheduledWorkflows } from "../../db/manage/manage-schema.js";
+import { agentScopedWhere } from "./scope-helpers.js";
 import { and, eq } from "drizzle-orm";
 
 //#region src/data-access/manage/scheduledWorkflows.ts
@@ -7,7 +8,7 @@ import { and, eq } from "drizzle-orm";
 */
 const getScheduledWorkflowByTriggerId = (db) => async (params) => {
 	const { scopes, scheduledTriggerId } = params;
-	return await db.query.scheduledWorkflows.findFirst({ where: and(eq(scheduledWorkflows.tenantId, scopes.tenantId), eq(scheduledWorkflows.projectId, scopes.projectId), eq(scheduledWorkflows.agentId, scopes.agentId), eq(scheduledWorkflows.scheduledTriggerId, scheduledTriggerId)) });
+	return await db.query.scheduledWorkflows.findFirst({ where: and(agentScopedWhere(scheduledWorkflows, scopes), eq(scheduledWorkflows.scheduledTriggerId, scheduledTriggerId)) });
 };
 /**
 * Create a new scheduled workflow (agent-scoped)
@@ -25,7 +26,7 @@ const updateScheduledWorkflowRunId = (db) => async (params) => {
 		updatedAt: (/* @__PURE__ */ new Date()).toISOString()
 	};
 	if (params.status) updateData.status = params.status;
-	return (await db.update(scheduledWorkflows).set(updateData).where(and(eq(scheduledWorkflows.tenantId, params.scopes.tenantId), eq(scheduledWorkflows.projectId, params.scopes.projectId), eq(scheduledWorkflows.agentId, params.scopes.agentId), eq(scheduledWorkflows.id, params.scheduledWorkflowId))).returning())[0];
+	return (await db.update(scheduledWorkflows).set(updateData).where(and(agentScopedWhere(scheduledWorkflows, params.scopes), eq(scheduledWorkflows.id, params.scheduledWorkflowId))).returning())[0];
 };
 
 //#endregion

package/dist/data-access/manage/scope-helpers.d.ts

@@ -14,5 +14,6 @@ declare const tenantScopedWhere: <T extends ScopedTable<"tenant">>(table: T, sco
 declare const projectScopedWhere: <T extends ScopedTable<"project">>(table: T, scopes: ScopeConfig<"project">) => SQL<unknown> | undefined;
 declare const agentScopedWhere: <T extends ScopedTable<"agent">>(table: T, scopes: ScopeConfig<"agent">) => SQL<unknown> | undefined;
 declare const subAgentScopedWhere: <T extends ScopedTable<"subAgent">>(table: T, scopes: ScopeConfig<"subAgent">) => SQL<unknown> | undefined;
+declare const toolScopedWhere: <T extends ScopedTable<"tool">>(table: T, scopes: ScopeConfig<"tool">) => SQL<unknown> | undefined;
 //#endregion
-export { agentScopedWhere, projectScopedWhere, scopedWhere, subAgentScopedWhere, tenantScopedWhere };
+export { agentScopedWhere, projectScopedWhere, scopedWhere, subAgentScopedWhere, tenantScopedWhere, toolScopedWhere };

package/dist/data-access/manage/scope-helpers.js

@@ -16,6 +16,7 @@ const tenantScopedWhere = (table, scopes) => scopedWhere("tenant", table, scopes
 const projectScopedWhere = (table, scopes) => scopedWhere("project", table, scopes);
 const agentScopedWhere = (table, scopes) => scopedWhere("agent", table, scopes);
 const subAgentScopedWhere = (table, scopes) => scopedWhere("subAgent", table, scopes);
+const toolScopedWhere = (table, scopes) => scopedWhere("tool", table, scopes);
 
 //#endregion
-export { agentScopedWhere, projectScopedWhere, scopedWhere, subAgentScopedWhere, tenantScopedWhere };
+export { agentScopedWhere, projectScopedWhere, scopedWhere, subAgentScopedWhere, tenantScopedWhere, toolScopedWhere };

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

@@ -8,14 +8,14 @@ declare const getSkillById: (db: AgentsManageDatabaseClient) => (params: {
   scopes: ProjectScopeConfig;
   skillId: string;
 }) => Promise<{
+  tenantId: string;
+  projectId: string;
   id: string;
   name: string;
   description: string;
-  tenantId: string;
-  projectId: string;
+  metadata: Record<string, string> | null;
   createdAt: string;
   updatedAt: string;
-  metadata: Record<string, string> | null;
   content: string;
 } | null>;
 declare const listSkills: (db: AgentsManageDatabaseClient) => (params: {
@@ -41,25 +41,25 @@ declare const listSkills: (db: AgentsManageDatabaseClient) => (params: {
   };
 }>;
 declare const createSkill: (db: AgentsManageDatabaseClient) => (data: SkillInsert) => Promise<{
+  tenantId: string;
+  projectId: string;
   id: string;
   name: string;
   description: string;
-  tenantId: string;
-  projectId: string;
+  metadata: Record<string, string> | null;
   createdAt: string;
   updatedAt: string;
-  metadata: Record<string, string> | null;
   content: string;
 }>;
 declare const upsertSkill: (db: AgentsManageDatabaseClient) => (data: SkillInsert) => Promise<{
+  tenantId: string;
+  projectId: string;
   id: string;
   name: string;
   description: string;
-  tenantId: string;
-  projectId: string;
+  metadata: Record<string, string> | null;
   createdAt: string;
   updatedAt: string;
-  metadata: Record<string, string> | null;
   content: string;
 }>;
 declare const updateSkill: (db: AgentsManageDatabaseClient) => (params: {
@@ -91,15 +91,15 @@ declare const upsertSubAgentSkill: (db: AgentsManageDatabaseClient) => (params:
   index: number;
   alwaysLoaded?: boolean;
 }) => Promise<{
-  id: string;
   tenantId: string;
   projectId: string;
   agentId: string;
+  subAgentId: string;
+  id: string;
   createdAt: string;
   updatedAt: string;
   index: number;
   alwaysLoaded: boolean;
-  subAgentId: string;
   skillId: string;
 }>;
 declare const deleteSubAgentSkill: (db: AgentsManageDatabaseClient) => (params: {

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

@@ -1,19 +1,20 @@
 import { skills, subAgentSkills } from "../../db/manage/manage-schema.js";
 import { getLogger } from "../../utils/logger.js";
 import { generateId } from "../../utils/conversations.js";
+import { agentScopedWhere, projectScopedWhere, subAgentScopedWhere } from "./scope-helpers.js";
 import "../../index.js";
 import { and, asc, count, desc, eq, inArray } from "drizzle-orm";
 
 //#region src/data-access/manage/skills.ts
 const logger = getLogger("skills-dal");
 const getSkillById = (db) => async (params) => {
-	return await db.query.skills.findFirst({ where: and(eq(skills.tenantId, params.scopes.tenantId), eq(skills.projectId, params.scopes.projectId), eq(skills.id, params.skillId)) }) ?? null;
+	return await db.query.skills.findFirst({ where: and(projectScopedWhere(skills, params.scopes), eq(skills.id, params.skillId)) }) ?? null;
 };
 const listSkills = (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(skills.tenantId, params.scopes.tenantId), eq(skills.projectId, params.scopes.projectId));
+	const whereClause = projectScopedWhere(skills, params.scopes);
 	const [data, totalResult] = await Promise.all([db.select().from(skills).where(whereClause).limit(limit).offset(offset).orderBy(desc(skills.createdAt)), db.select({ count: count() }).from(skills).where(whereClause)]);
 	const total = totalResult[0]?.count || 0;
 	return {
@@ -43,14 +44,18 @@ const upsertSkill = (db) => async (data) => {
 		...data,
 		id: data.name
 	};
-	if (await db.query.skills.findFirst({ where: and(eq(skills.tenantId, baseData.tenantId), eq(skills.projectId, baseData.projectId), eq(skills.id, baseData.id)) })) {
+	const scopes = {
+		tenantId: baseData.tenantId,
+		projectId: baseData.projectId
+	};
+	if (await db.query.skills.findFirst({ where: and(projectScopedWhere(skills, scopes), eq(skills.id, baseData.id)) })) {
 		const [result$1] = await db.update(skills).set({
 			name: baseData.name,
 			description: baseData.description,
 			content: baseData.content,
 			metadata: baseData.metadata,
 			updatedAt: now
-		}).where(and(eq(skills.tenantId, baseData.tenantId), eq(skills.projectId, baseData.projectId), eq(skills.id, baseData.id))).returning();
+		}).where(and(projectScopedWhere(skills, scopes), eq(skills.id, baseData.id))).returning();
 		logger.info({ skillId: baseData.id }, "Updated skill");
 		return result$1;
 	}
@@ -69,11 +74,11 @@ const updateSkill = (db) => async (params) => {
 		...data,
 		updatedAt: (/* @__PURE__ */ new Date()).toISOString()
 	};
-	const [result] = await db.update(skills).set(updateData).where(and(eq(skills.tenantId, params.scopes.tenantId), eq(skills.projectId, params.scopes.projectId), eq(skills.id, params.skillId))).returning();
+	const [result] = await db.update(skills).set(updateData).where(and(projectScopedWhere(skills, params.scopes), eq(skills.id, params.skillId))).returning();
 	return result ?? null;
 };
 const deleteSkill = (db) => async (params) => {
-	return (await db.delete(skills).where(and(eq(skills.tenantId, params.scopes.tenantId), eq(skills.projectId, params.scopes.projectId), eq(skills.id, params.skillId))).returning()).length > 0;
+	return (await db.delete(skills).where(and(projectScopedWhere(skills, params.scopes), eq(skills.id, params.skillId))).returning()).length > 0;
 };
 const getSkillsForSubAgents = (db) => async (params) => {
 	if (!params.subAgentIds.length) return [];
@@ -89,11 +94,11 @@ const getSkillsForSubAgents = (db) => async (params) => {
 		metadata: skills.metadata,
 		createdAt: skills.createdAt,
 		updatedAt: skills.updatedAt
-	}).from(subAgentSkills).innerJoin(skills, and(eq(subAgentSkills.skillId, skills.id), eq(subAgentSkills.tenantId, skills.tenantId), eq(subAgentSkills.projectId, skills.projectId))).where(and(eq(subAgentSkills.tenantId, params.scopes.tenantId), eq(subAgentSkills.projectId, params.scopes.projectId), eq(subAgentSkills.agentId, params.scopes.agentId), inArray(subAgentSkills.subAgentId, params.subAgentIds))).orderBy(asc(subAgentSkills.index), asc(subAgentSkills.createdAt));
+	}).from(subAgentSkills).innerJoin(skills, and(eq(subAgentSkills.skillId, skills.id), eq(subAgentSkills.tenantId, skills.tenantId), eq(subAgentSkills.projectId, skills.projectId))).where(and(agentScopedWhere(subAgentSkills, params.scopes), inArray(subAgentSkills.subAgentId, params.subAgentIds))).orderBy(asc(subAgentSkills.index), asc(subAgentSkills.createdAt));
 };
 const upsertSubAgentSkill = (db) => async (params) => {
 	const now = (/* @__PURE__ */ new Date()).toISOString();
-	const existing = await db.query.subAgentSkills.findFirst({ where: and(eq(subAgentSkills.tenantId, params.scopes.tenantId), eq(subAgentSkills.projectId, params.scopes.projectId), eq(subAgentSkills.agentId, params.scopes.agentId), eq(subAgentSkills.subAgentId, params.scopes.subAgentId), eq(subAgentSkills.skillId, params.skillId)) });
+	const existing = await db.query.subAgentSkills.findFirst({ where: and(subAgentScopedWhere(subAgentSkills, params.scopes), eq(subAgentSkills.skillId, params.skillId)) });
 	if (existing) {
 		const [result$1] = await db.update(subAgentSkills).set({
 			index: params.index,
@@ -115,7 +120,7 @@ const upsertSubAgentSkill = (db) => async (params) => {
 	return result;
 };
 const deleteSubAgentSkill = (db) => async (params) => {
-	return (await db.delete(subAgentSkills).where(and(eq(subAgentSkills.tenantId, params.scopes.tenantId), eq(subAgentSkills.projectId, params.scopes.projectId), eq(subAgentSkills.agentId, params.scopes.agentId), eq(subAgentSkills.id, params.subAgentSkillId))).returning()).length > 0;
+	return (await db.delete(subAgentSkills).where(and(agentScopedWhere(subAgentSkills, params.scopes), eq(subAgentSkills.id, params.subAgentSkillId))).returning()).length > 0;
 };
 
 //#endregion

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

@@ -9,15 +9,15 @@ declare const getSubAgentExternalAgentRelationById: (db: AgentsManageDatabaseCli
   scopes: SubAgentScopeConfig;
   relationId: string;
 }) => Promise<{
-  id: string;
   tenantId: string;
   projectId: string;
   agentId: string;
+  subAgentId: string;
+  id: string;
   createdAt: string;
   updatedAt: string;
   headers: Record<string, string> | null;
   externalAgentId: string;
-  subAgentId: string;
 } | undefined>;
 declare const listSubAgentExternalAgentRelations: (db: AgentsManageDatabaseClient) => (params: {
   scopes: SubAgentScopeConfig;
@@ -44,28 +44,28 @@ declare const listSubAgentExternalAgentRelations: (db: AgentsManageDatabaseClien
 declare const getSubAgentExternalAgentRelations: (db: AgentsManageDatabaseClient) => (params: {
   scopes: SubAgentScopeConfig;
 }) => Promise<{
-  id: string;
   tenantId: string;
   projectId: string;
   agentId: string;
+  subAgentId: string;
+  id: string;
   createdAt: string;
   updatedAt: string;
   headers: Record<string, string> | null;
   externalAgentId: string;
-  subAgentId: string;
 }[]>;
 declare const getSubAgentExternalAgentRelationsByAgent: (db: AgentsManageDatabaseClient) => (params: {
   scopes: AgentScopeConfig;
 }) => Promise<{
-  id: string;
   tenantId: string;
   projectId: string;
   agentId: string;
+  subAgentId: string;
+  id: string;
   createdAt: string;
   updatedAt: string;
   headers: Record<string, string> | null;
   externalAgentId: string;
-  subAgentId: string;
 }[]>;
 declare const getSubAgentExternalAgentRelationsByExternalAgent: (db: AgentsManageDatabaseClient) => (params: {
   scopes: AgentScopeConfig;
@@ -180,15 +180,15 @@ declare const createSubAgentExternalAgentRelation: (db: AgentsManageDatabaseClie
     headers?: Record<string, string> | null;
   };
 }) => Promise<{
-  id: string;
   tenantId: string;
   projectId: string;
   agentId: string;
+  subAgentId: string;
+  id: string;
   createdAt: string;
   updatedAt: string;
   headers: Record<string, string> | null;
   externalAgentId: string;
-  subAgentId: string;
 }>;
 /**
  * Check if sub-agent external agent relation exists by params
@@ -197,15 +197,15 @@ declare const getSubAgentExternalAgentRelationByParams: (db: AgentsManageDatabas
   scopes: SubAgentScopeConfig;
   externalAgentId: string;
 }) => Promise<{
-  id: string;
   tenantId: string;
   projectId: string;
   agentId: string;
+  subAgentId: string;
+  id: string;
   createdAt: string;
   updatedAt: string;
   headers: Record<string, string> | null;
   externalAgentId: string;
-  subAgentId: string;
 } | undefined>;
 /**
  * Upsert sub-agent external agent relation (create if it doesn't exist, update if it does)
@@ -218,15 +218,15 @@ declare const upsertSubAgentExternalAgentRelation: (db: AgentsManageDatabaseClie
     headers?: Record<string, string> | null;
   };
 }) => Promise<{
-  id: string;
   tenantId: string;
   projectId: string;
   agentId: string;
+  subAgentId: string;
+  id: string;
   createdAt: string;
   updatedAt: string;
   headers: Record<string, string> | null;
   externalAgentId: string;
-  subAgentId: string;
 }>;
 declare const updateSubAgentExternalAgentRelation: (db: AgentsManageDatabaseClient) => (params: {
   scopes: SubAgentScopeConfig;

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

@@ -9,15 +9,15 @@ declare const getAgentRelationById: (db: AgentsManageDatabaseClient) => (params:
   scopes: AgentScopeConfig;
   relationId: string;
 }) => Promise<{
-  id: string;
   tenantId: string;
   projectId: string;
   agentId: string;
+  id: string;
   createdAt: string;
   updatedAt: string;
+  relationType: string | null;
   sourceSubAgentId: string;
   targetSubAgentId: string | null;
-  relationType: string | null;
 } | undefined>;
 declare const listAgentRelations: (db: AgentsManageDatabaseClient) => (params: {
   scopes: AgentScopeConfig;
@@ -44,28 +44,28 @@ declare const listAgentRelations: (db: AgentsManageDatabaseClient) => (params: {
 declare const getAgentRelations: (db: AgentsManageDatabaseClient) => (params: {
   scopes: SubAgentScopeConfig;
 }) => Promise<{
-  id: string;
   tenantId: string;
   projectId: string;
   agentId: string;
+  id: string;
   createdAt: string;
   updatedAt: string;
+  relationType: string | null;
   sourceSubAgentId: string;
   targetSubAgentId: string | null;
-  relationType: string | null;
 }[]>;
 declare const getAgentRelationsByAgent: (db: AgentsManageDatabaseClient) => (params: {
   scopes: AgentScopeConfig;
 }) => Promise<{
-  id: string;
   tenantId: string;
   projectId: string;
   agentId: string;
+  id: string;
   createdAt: string;
   updatedAt: string;
+  relationType: string | null;
   sourceSubAgentId: string;
   targetSubAgentId: string | null;
-  relationType: string | null;
 }[]>;
 declare const getAgentRelationsBySource: (db: AgentsManageDatabaseClient) => (params: {
   scopes: AgentScopeConfig;
@@ -126,15 +126,15 @@ declare const getRelatedAgentsForAgent: (db: AgentsManageDatabaseClient) => (par
   }[];
 }>;
 declare const createSubAgentRelation: (db: AgentsManageDatabaseClient) => (params: SubAgentRelationInsert) => Promise<{
-  id: string;
   tenantId: string;
   projectId: string;
   agentId: string;
+  id: string;
   createdAt: string;
   updatedAt: string;
+  relationType: string | null;
   sourceSubAgentId: string;
   targetSubAgentId: string | null;
-  relationType: string | null;
 }>;
 /**
  * Check if sub-agent relation exists by agent, source, target, and relation type
@@ -145,29 +145,29 @@ declare const getAgentRelationByParams: (db: AgentsManageDatabaseClient) => (par
   targetSubAgentId?: string;
   relationType: string;
 }) => Promise<{
-  id: string;
   tenantId: string;
   projectId: string;
   agentId: string;
+  id: string;
   createdAt: string;
   updatedAt: string;
+  relationType: string | null;
   sourceSubAgentId: string;
   targetSubAgentId: string | null;
-  relationType: string | null;
 } | undefined>;
 /**
  * Upsert agent relation (create if it doesn't exist, no-op if it does)
  */
 declare const upsertSubAgentRelation: (db: AgentsManageDatabaseClient) => (params: SubAgentRelationInsert) => Promise<{
-  id: string;
   tenantId: string;
   projectId: string;
   agentId: string;
+  id: string;
   createdAt: string;
   updatedAt: string;
+  relationType: string | null;
   sourceSubAgentId: string;
   targetSubAgentId: string | null;
-  relationType: string | null;
 }>;
 declare const updateAgentRelation: (db: AgentsManageDatabaseClient) => (params: {
   scopes: AgentScopeConfig;
@@ -204,18 +204,18 @@ declare const createAgentToolRelation: (db: AgentsManageDatabaseClient) => (para
     }> | null;
   };
 }) => Promise<{
-  id: string;
   tenantId: string;
   projectId: string;
   agentId: string;
+  subAgentId: string;
+  toolId: string;
+  id: string;
   createdAt: string;
   updatedAt: string;
-  toolId: string;
   headers: Record<string, string> | null;
   toolPolicies: Record<string, {
     needsApproval?: boolean;
   }> | null;
-  subAgentId: string;
   selectedTools: string[] | null;
 }>;
 declare const updateAgentToolRelation: (db: AgentsManageDatabaseClient) => (params: {
@@ -248,18 +248,18 @@ declare const getAgentToolRelationById: (db: AgentsManageDatabaseClient) => (par
   scopes: SubAgentScopeConfig;
   relationId: string;
 }) => Promise<{
-  id: string;
   tenantId: string;
   projectId: string;
   agentId: string;
+  subAgentId: string;
+  toolId: string;
+  id: string;
   createdAt: string;
   updatedAt: string;
-  toolId: string;
   headers: Record<string, string> | null;
   toolPolicies: Record<string, {
     needsApproval?: boolean;
   }> | null;
-  subAgentId: string;
   selectedTools: string[] | null;
 } | undefined>;
 declare const getAgentToolRelationByAgent: (db: AgentsManageDatabaseClient) => (params: {

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

@@ -1,16 +1,17 @@
 import { subAgentRelations, subAgentToolRelations, subAgents, tools } from "../../db/manage/manage-schema.js";
 import { generateId } from "../../utils/conversations.js";
+import { agentScopedWhere, subAgentScopedWhere } from "./scope-helpers.js";
 import { and, count, desc, eq, isNotNull } from "drizzle-orm";
 
 //#region src/data-access/manage/subAgentRelations.ts
 const getAgentRelationById = (db) => async (params) => {
-	return db.query.subAgentRelations.findFirst({ where: and(eq(subAgentRelations.tenantId, params.scopes.tenantId), eq(subAgentRelations.projectId, params.scopes.projectId), eq(subAgentRelations.agentId, params.scopes.agentId), eq(subAgentRelations.id, params.relationId)) });
+	return db.query.subAgentRelations.findFirst({ where: and(agentScopedWhere(subAgentRelations, params.scopes), eq(subAgentRelations.id, params.relationId)) });
 };
 const listAgentRelations = (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(subAgentRelations.tenantId, params.scopes.tenantId), eq(subAgentRelations.projectId, params.scopes.projectId), eq(subAgentRelations.agentId, params.scopes.agentId));
+	const whereClause = agentScopedWhere(subAgentRelations, params.scopes);
 	const [data, totalResult] = await Promise.all([db.select().from(subAgentRelations).where(whereClause).limit(limit).offset(offset).orderBy(desc(subAgentRelations.createdAt)), db.select({ count: count() }).from(subAgentRelations).where(whereClause)]);
 	const total = totalResult[0]?.count || 0;
 	return {
@@ -24,16 +25,16 @@ const listAgentRelations = (db) => async (params) => {
 	};
 };
 const getAgentRelations = (db) => async (params) => {
-	return await db.query.subAgentRelations.findMany({ where: and(eq(subAgentRelations.tenantId, params.scopes.tenantId), eq(subAgentRelations.projectId, params.scopes.projectId), eq(subAgentRelations.agentId, params.scopes.agentId), eq(subAgentRelations.sourceSubAgentId, params.scopes.subAgentId)) });
+	return await db.query.subAgentRelations.findMany({ where: and(agentScopedWhere(subAgentRelations, params.scopes), eq(subAgentRelations.sourceSubAgentId, params.scopes.subAgentId)) });
 };
 const getAgentRelationsByAgent = (db) => async (params) => {
-	return await db.query.subAgentRelations.findMany({ where: and(eq(subAgentRelations.tenantId, params.scopes.tenantId), eq(subAgentRelations.projectId, params.scopes.projectId), eq(subAgentRelations.agentId, params.scopes.agentId)) });
+	return await db.query.subAgentRelations.findMany({ where: agentScopedWhere(subAgentRelations, params.scopes) });
 };
 const getAgentRelationsBySource = (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(subAgentRelations.tenantId, params.scopes.tenantId), eq(subAgentRelations.projectId, params.scopes.projectId), eq(subAgentRelations.agentId, params.scopes.agentId), eq(subAgentRelations.sourceSubAgentId, params.sourceSubAgentId));
+	const whereClause = and(agentScopedWhere(subAgentRelations, params.scopes), eq(subAgentRelations.sourceSubAgentId, params.sourceSubAgentId));
 	const [data, totalResult] = await Promise.all([db.select().from(subAgentRelations).where(whereClause).limit(limit).offset(offset).orderBy(desc(subAgentRelations.createdAt)), db.select({ count: count() }).from(subAgentRelations).where(whereClause)]);
 	const total = totalResult[0]?.count || 0;
 	return {
@@ -50,7 +51,7 @@ const getSubAgentRelationsByTarget = (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(subAgentRelations.tenantId, params.scopes.tenantId), eq(subAgentRelations.projectId, params.scopes.projectId), eq(subAgentRelations.agentId, params.scopes.agentId), eq(subAgentRelations.targetSubAgentId, params.targetSubAgentId));
+	const whereClause = and(agentScopedWhere(subAgentRelations, params.scopes), eq(subAgentRelations.targetSubAgentId, params.targetSubAgentId));
 	const [data, totalResult] = await Promise.all([db.select().from(subAgentRelations).where(whereClause).limit(limit).offset(offset).orderBy(desc(subAgentRelations.createdAt)), db.select({ count: count() }).from(subAgentRelations).where(whereClause)]);
 	const total = totalResult[0]?.count || 0;
 	return {
@@ -70,7 +71,7 @@ const getRelatedAgentsForAgent = (db) => async (params) => {
 		description: subAgents.description,
 		relationType: subAgentRelations.relationType,
 		relationId: subAgentRelations.id
-	}).from(subAgentRelations).innerJoin(subAgents, and(eq(subAgentRelations.targetSubAgentId, subAgents.id), eq(subAgentRelations.tenantId, subAgents.tenantId), eq(subAgentRelations.projectId, subAgents.projectId), eq(subAgentRelations.agentId, subAgents.agentId))).where(and(eq(subAgentRelations.tenantId, params.scopes.tenantId), eq(subAgentRelations.projectId, params.scopes.projectId), eq(subAgentRelations.agentId, params.scopes.agentId), eq(subAgentRelations.sourceSubAgentId, params.subAgentId), isNotNull(subAgentRelations.targetSubAgentId))) };
+	}).from(subAgentRelations).innerJoin(subAgents, and(eq(subAgentRelations.targetSubAgentId, subAgents.id), eq(subAgentRelations.tenantId, subAgents.tenantId), eq(subAgentRelations.projectId, subAgents.projectId), eq(subAgentRelations.agentId, subAgents.agentId))).where(and(agentScopedWhere(subAgentRelations, params.scopes), eq(subAgentRelations.sourceSubAgentId, params.subAgentId), isNotNull(subAgentRelations.targetSubAgentId))) };
 };
 const createSubAgentRelation = (db) => async (params) => {
 	const count$1 = [
@@ -87,9 +88,7 @@ const createSubAgentRelation = (db) => async (params) => {
 */
 const getAgentRelationByParams = (db) => async (params) => {
 	const whereConditions = [
-		eq(subAgentRelations.tenantId, params.scopes.tenantId),
-		eq(subAgentRelations.projectId, params.scopes.projectId),
-		eq(subAgentRelations.agentId, params.scopes.agentId),
+		agentScopedWhere(subAgentRelations, params.scopes),
 		eq(subAgentRelations.sourceSubAgentId, params.sourceSubAgentId),
 		eq(subAgentRelations.relationType, params.relationType)
 	];
@@ -118,21 +117,19 @@ const updateAgentRelation = (db) => async (params) => {
 		...params.data,
 		updatedAt: (/* @__PURE__ */ new Date()).toISOString()
 	};
-	return (await db.update(subAgentRelations).set(updateData).where(and(eq(subAgentRelations.tenantId, params.scopes.tenantId), eq(subAgentRelations.projectId, params.scopes.projectId), eq(subAgentRelations.agentId, params.scopes.agentId), eq(subAgentRelations.id, params.relationId))).returning())[0];
+	return (await db.update(subAgentRelations).set(updateData).where(and(agentScopedWhere(subAgentRelations, params.scopes), eq(subAgentRelations.id, params.relationId))).returning())[0];
 };
 const deleteSubAgentRelation = (db) => async (params) => {
-	return (await db.delete(subAgentRelations).where(and(eq(subAgentRelations.tenantId, params.scopes.tenantId), eq(subAgentRelations.projectId, params.scopes.projectId), eq(subAgentRelations.agentId, params.scopes.agentId), eq(subAgentRelations.id, params.relationId))).returning()).length > 0;
+	return (await db.delete(subAgentRelations).where(and(agentScopedWhere(subAgentRelations, params.scopes), eq(subAgentRelations.id, params.relationId))).returning()).length > 0;
 };
 const deleteAgentRelationsByAgent = (db) => async (params) => {
-	return (await db.delete(subAgentRelations).where(and(eq(subAgentRelations.tenantId, params.scopes.tenantId), eq(subAgentRelations.projectId, params.scopes.projectId), eq(subAgentRelations.agentId, params.scopes.agentId))).returning()).length > 0;
+	return (await db.delete(subAgentRelations).where(agentScopedWhere(subAgentRelations, params.scopes)).returning()).length > 0;
 };
 const createAgentToolRelation = (db) => async (params) => {
 	const finalRelationId = params.relationId ?? generateId();
 	return (await db.insert(subAgentToolRelations).values({
 		id: finalRelationId,
-		tenantId: params.scopes.tenantId,
-		projectId: params.scopes.projectId,
-		agentId: params.scopes.agentId,
+		...params.scopes,
 		subAgentId: params.data.subAgentId,
 		toolId: params.data.toolId,
 		selectedTools: params.data.selectedTools,
@@ -145,22 +142,23 @@ const updateAgentToolRelation = (db) => async (params) => {
 		...params.data,
 		updatedAt: (/* @__PURE__ */ new Date()).toISOString()
 	};
-	return (await db.update(subAgentToolRelations).set(updateData).where(and(eq(subAgentToolRelations.tenantId, params.scopes.tenantId), eq(subAgentToolRelations.projectId, params.scopes.projectId), eq(subAgentToolRelations.agentId, params.scopes.agentId), eq(subAgentToolRelations.id, params.relationId))).returning())[0];
+	return (await db.update(subAgentToolRelations).set(updateData).where(and(agentScopedWhere(subAgentToolRelations, params.scopes), eq(subAgentToolRelations.id, params.relationId))).returning())[0];
 };
 const deleteAgentToolRelation = (db) => async (params) => {
-	return (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.id, params.relationId))).returning()).length > 0;
+	return (await db.delete(subAgentToolRelations).where(and(agentScopedWhere(subAgentToolRelations, params.scopes), eq(subAgentToolRelations.id, params.relationId))).returning()).length > 0;
 };
 const deleteAgentToolRelationByAgent = (db) => async (params) => {
-	return (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.scopes.subAgentId))).returning()).length > 0;
+	return (await db.delete(subAgentToolRelations).where(subAgentScopedWhere(subAgentToolRelations, params.scopes)).returning()).length > 0;
 };
 const getAgentToolRelationById = (db) => async (params) => {
-	return await db.query.subAgentToolRelations.findFirst({ where: and(eq(subAgentToolRelations.tenantId, params.scopes.tenantId), eq(subAgentToolRelations.projectId, params.scopes.projectId), eq(subAgentToolRelations.agentId, params.scopes.agentId), eq(subAgentToolRelations.id, params.relationId)) });
+	return await db.query.subAgentToolRelations.findFirst({ where: and(agentScopedWhere(subAgentToolRelations, params.scopes), eq(subAgentToolRelations.id, params.relationId)) });
 };
 const getAgentToolRelationByAgent = (db) => async (params) => {
 	const page = params.pagination?.page || 1;
 	const limit = Math.min(params.pagination?.limit || 10, 100);
 	const offset = (page - 1) * limit;
-	const [data, totalResult] = await Promise.all([db.select().from(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.scopes.subAgentId))).limit(limit).offset(offset).orderBy(desc(subAgentToolRelations.createdAt)), db.select({ count: count() }).from(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.scopes.subAgentId)))]);
+	const whereClause = subAgentScopedWhere(subAgentToolRelations, params.scopes);
+	const [data, totalResult] = await Promise.all([db.select().from(subAgentToolRelations).where(whereClause).limit(limit).offset(offset).orderBy(desc(subAgentToolRelations.createdAt)), db.select({ count: count() }).from(subAgentToolRelations).where(whereClause)]);
 	const total = totalResult[0]?.count || 0;
 	return {
 		data,
@@ -176,7 +174,8 @@ const getAgentToolRelationByTool = (db) => async (params) => {
 	const page = params.pagination?.page || 1;
 	const limit = Math.min(params.pagination?.limit || 10, 100);
 	const offset = (page - 1) * limit;
-	const [data, totalResult] = await Promise.all([db.select().from(subAgentToolRelations).where(and(eq(subAgentToolRelations.tenantId, params.scopes.tenantId), eq(subAgentToolRelations.projectId, params.scopes.projectId), eq(subAgentToolRelations.agentId, params.scopes.agentId), eq(subAgentToolRelations.toolId, params.toolId))).limit(limit).offset(offset).orderBy(desc(subAgentToolRelations.createdAt)), db.select({ count: count() }).from(subAgentToolRelations).where(and(eq(subAgentToolRelations.tenantId, params.scopes.tenantId), eq(subAgentToolRelations.projectId, params.scopes.projectId), eq(subAgentToolRelations.agentId, params.scopes.agentId), eq(subAgentToolRelations.toolId, params.toolId)))]);
+	const whereClause = and(agentScopedWhere(subAgentToolRelations, params.scopes), eq(subAgentToolRelations.toolId, params.toolId));
+	const [data, totalResult] = await Promise.all([db.select().from(subAgentToolRelations).where(whereClause).limit(limit).offset(offset).orderBy(desc(subAgentToolRelations.createdAt)), db.select({ count: count() }).from(subAgentToolRelations).where(whereClause)]);
 	const total = totalResult[0]?.count || 0;
 	return {
 		data,
@@ -192,7 +191,8 @@ const listAgentToolRelations = (db) => async (params) => {
 	const page = params.pagination?.page || 1;
 	const limit = Math.min(params.pagination?.limit || 10, 100);
 	const offset = (page - 1) * limit;
-	const [data, totalResult] = await Promise.all([db.select().from(subAgentToolRelations).where(and(eq(subAgentToolRelations.tenantId, params.scopes.tenantId), eq(subAgentToolRelations.projectId, params.scopes.projectId), eq(subAgentToolRelations.agentId, params.scopes.agentId))).limit(limit).offset(offset).orderBy(desc(subAgentToolRelations.createdAt)), db.select({ count: count() }).from(subAgentToolRelations).where(and(eq(subAgentToolRelations.tenantId, params.scopes.tenantId), eq(subAgentToolRelations.projectId, params.scopes.projectId), eq(subAgentToolRelations.agentId, params.scopes.agentId)))]);
+	const whereClause = agentScopedWhere(subAgentToolRelations, params.scopes);
+	const [data, totalResult] = await Promise.all([db.select().from(subAgentToolRelations).where(whereClause).limit(limit).offset(offset).orderBy(desc(subAgentToolRelations.createdAt)), db.select({ count: count() }).from(subAgentToolRelations).where(whereClause)]);
 	const total = totalResult[0]?.count || 0;
 	return {
 		data,
@@ -208,6 +208,7 @@ const getToolsForAgent = (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(subAgentToolRelations, params.scopes);
 	const [data, totalResult] = await Promise.all([db.select({
 		id: subAgentToolRelations.id,
 		tenantId: subAgentToolRelations.tenantId,
@@ -234,7 +235,7 @@ const getToolsForAgent = (db) => async (params) => {
 			headers: tools.headers,
 			imageUrl: tools.imageUrl
 		}
-	}).from(subAgentToolRelations).innerJoin(tools, and(eq(subAgentToolRelations.tenantId, tools.tenantId), eq(subAgentToolRelations.projectId, tools.projectId), eq(subAgentToolRelations.toolId, tools.id))).where(and(eq(subAgentToolRelations.tenantId, params.scopes.tenantId), eq(subAgentToolRelations.projectId, params.scopes.projectId), eq(subAgentToolRelations.agentId, params.scopes.agentId), eq(subAgentToolRelations.subAgentId, params.scopes.subAgentId))).limit(limit).offset(offset).orderBy(desc(subAgentToolRelations.createdAt)), db.select({ count: count() }).from(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.scopes.subAgentId)))]);
+	}).from(subAgentToolRelations).innerJoin(tools, and(eq(subAgentToolRelations.tenantId, tools.tenantId), eq(subAgentToolRelations.projectId, tools.projectId), eq(subAgentToolRelations.toolId, tools.id))).where(whereClause).limit(limit).offset(offset).orderBy(desc(subAgentToolRelations.createdAt)), db.select({ count: count() }).from(subAgentToolRelations).where(whereClause)]);
 	const total = totalResult[0]?.count || 0;
 	return {
 		data,
@@ -250,6 +251,7 @@ const getAgentsForTool = (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(subAgentToolRelations, params.scopes), eq(subAgentToolRelations.toolId, params.toolId));
 	const [data, totalResult] = await Promise.all([db.select({
 		id: subAgentToolRelations.id,
 		tenantId: subAgentToolRelations.tenantId,
@@ -271,7 +273,7 @@ const getAgentsForTool = (db) => async (params) => {
 			createdAt: subAgents.createdAt,
 			updatedAt: subAgents.updatedAt
 		}
-	}).from(subAgentToolRelations).innerJoin(subAgents, and(eq(subAgentToolRelations.subAgentId, subAgents.id), eq(subAgentToolRelations.tenantId, subAgents.tenantId), eq(subAgentToolRelations.projectId, subAgents.projectId), eq(subAgentToolRelations.agentId, subAgents.agentId))).where(and(eq(subAgentToolRelations.tenantId, params.scopes.tenantId), eq(subAgentToolRelations.projectId, params.scopes.projectId), eq(subAgentToolRelations.agentId, params.scopes.agentId), eq(subAgentToolRelations.toolId, params.toolId))).limit(limit).offset(offset).orderBy(desc(subAgentToolRelations.createdAt)), db.select({ count: count() }).from(subAgentToolRelations).where(and(eq(subAgentToolRelations.tenantId, params.scopes.tenantId), eq(subAgentToolRelations.projectId, params.scopes.projectId), eq(subAgentToolRelations.agentId, params.scopes.agentId), eq(subAgentToolRelations.toolId, params.toolId)))]);
+	}).from(subAgentToolRelations).innerJoin(subAgents, and(eq(subAgentToolRelations.subAgentId, subAgents.id), eq(subAgentToolRelations.tenantId, subAgents.tenantId), eq(subAgentToolRelations.projectId, subAgents.projectId), eq(subAgentToolRelations.agentId, subAgents.agentId))).where(whereClause).limit(limit).offset(offset).orderBy(desc(subAgentToolRelations.createdAt)), db.select({ count: count() }).from(subAgentToolRelations).where(whereClause)]);
 	const total = totalResult[0]?.count || 0;
 	return {
 		data,
@@ -284,7 +286,7 @@ const getAgentsForTool = (db) => async (params) => {
 	};
 };
 const validateSubAgent = (db) => async (params) => {
-	return (await db.select({ id: subAgents.id }).from(subAgents).where(and(eq(subAgents.tenantId, params.scopes.tenantId), eq(subAgents.projectId, params.scopes.projectId), eq(subAgents.agentId, params.scopes.agentId), eq(subAgents.id, params.scopes.subAgentId))).limit(1)).length > 0;
+	return (await db.select({ id: subAgents.id }).from(subAgents).where(and(agentScopedWhere(subAgents, params.scopes), eq(subAgents.id, params.scopes.subAgentId))).limit(1)).length > 0;
 };
 
 //#endregion