@inkeep/agents-core 0.58.14 → 0.58.15

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

@@ -1,4 +1,5 @@
 import { credentialReferences, externalAgents, tools } from "../../db/manage/manage-schema.js";
+import { projectScopedWhere } from "./scope-helpers.js";
 import { isUniqueConstraintError } from "../../utils/error.js";
 import { and, count, desc, eq, sql } from "drizzle-orm";
 
@@ -7,22 +8,22 @@ import { and, count, desc, eq, sql } from "drizzle-orm";
 * Get a credential reference by ID
 */
 const getCredentialReference = (db) => async (params) => {
-	return await db.query.credentialReferences.findFirst({ where: and(eq(credentialReferences.tenantId, params.scopes.tenantId), eq(credentialReferences.projectId, params.scopes.projectId), eq(credentialReferences.id, params.id)) });
+	return await db.query.credentialReferences.findFirst({ where: and(projectScopedWhere(credentialReferences, params.scopes), eq(credentialReferences.id, params.id)) });
 };
 /**
 * Get a user-scoped credential reference by toolId and userId
 */
 const getUserScopedCredentialReference = (db) => async (params) => {
-	return await db.query.credentialReferences.findFirst({ where: and(eq(credentialReferences.tenantId, params.scopes.tenantId), eq(credentialReferences.projectId, params.scopes.projectId), eq(credentialReferences.toolId, params.toolId), eq(credentialReferences.userId, params.userId)) });
+	return await db.query.credentialReferences.findFirst({ where: and(projectScopedWhere(credentialReferences, params.scopes), eq(credentialReferences.toolId, params.toolId), eq(credentialReferences.userId, params.userId)) });
 };
 /**
 * Get a credential reference by ID with its related tools
 */
 const getCredentialReferenceWithResources = (db) => async (params) => {
 	const [credential, relatedTools, relatedExternalAgents] = await Promise.all([
-		db.query.credentialReferences.findFirst({ where: and(eq(credentialReferences.tenantId, params.scopes.tenantId), eq(credentialReferences.projectId, params.scopes.projectId), eq(credentialReferences.id, params.id)) }),
-		db.select().from(tools).where(and(eq(tools.tenantId, params.scopes.tenantId), eq(tools.projectId, params.scopes.projectId), eq(tools.credentialReferenceId, params.id))),
-		db.select().from(externalAgents).where(and(eq(externalAgents.tenantId, params.scopes.tenantId), eq(externalAgents.projectId, params.scopes.projectId), eq(externalAgents.credentialReferenceId, params.id)))
+		db.query.credentialReferences.findFirst({ where: and(projectScopedWhere(credentialReferences, params.scopes), eq(credentialReferences.id, params.id)) }),
+		db.select().from(tools).where(and(projectScopedWhere(tools, params.scopes), eq(tools.credentialReferenceId, params.id))),
+		db.select().from(externalAgents).where(and(projectScopedWhere(externalAgents, params.scopes), eq(externalAgents.credentialReferenceId, params.id)))
 	]);
 	if (!credential) return;
 	return {
@@ -36,7 +37,7 @@ const getCredentialReferenceWithResources = (db) => async (params) => {
 */
 const listCredentialReferences = (db) => async (params) => {
 	return await db.query.credentialReferences.findMany({
-		where: and(eq(credentialReferences.tenantId, params.scopes.tenantId), eq(credentialReferences.projectId, params.scopes.projectId)),
+		where: projectScopedWhere(credentialReferences, params.scopes),
 		orderBy: [desc(credentialReferences.createdAt)]
 	});
 };
@@ -47,7 +48,7 @@ const listCredentialReferencesPaginated = (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(credentialReferences.tenantId, params.scopes.tenantId), eq(credentialReferences.projectId, params.scopes.projectId));
+	const whereClause = projectScopedWhere(credentialReferences, params.scopes);
 	const [data, totalResult] = await Promise.all([db.select().from(credentialReferences).where(whereClause).limit(limit).offset(offset).orderBy(desc(credentialReferences.createdAt)), db.select({ count: sql`COUNT(*)` }).from(credentialReferences).where(whereClause)]);
 	const total = Number(totalResult[0]?.count || 0);
 	return {
@@ -80,7 +81,7 @@ const updateCredentialReference = (db) => async (params) => {
 	await db.update(credentialReferences).set({
 		...params.data,
 		updatedAt: now
-	}).where(and(eq(credentialReferences.tenantId, params.scopes.tenantId), eq(credentialReferences.projectId, params.scopes.projectId), eq(credentialReferences.id, params.id)));
+	}).where(and(projectScopedWhere(credentialReferences, params.scopes), eq(credentialReferences.id, params.id)));
 	return await getCredentialReferenceWithResources(db)({
 		scopes: params.scopes,
 		id: params.id
@@ -94,7 +95,7 @@ const deleteCredentialReference = (db) => async (params) => {
 		scopes: params.scopes,
 		id: params.id
 	})) return false;
-	await db.delete(credentialReferences).where(and(eq(credentialReferences.tenantId, params.scopes.tenantId), eq(credentialReferences.projectId, params.scopes.projectId), eq(credentialReferences.id, params.id)));
+	await db.delete(credentialReferences).where(and(projectScopedWhere(credentialReferences, params.scopes), eq(credentialReferences.id, params.id)));
 	return await getCredentialReference(db)({
 		scopes: params.scopes,
 		id: params.id
@@ -110,13 +111,13 @@ const hasCredentialReference = (db) => async (params) => {
 * Get credential reference by ID (simple version without tools)
 */
 const getCredentialReferenceById = (db) => async (params) => {
-	return await db.query.credentialReferences.findFirst({ where: and(eq(credentialReferences.tenantId, params.scopes.tenantId), eq(credentialReferences.projectId, params.scopes.projectId), eq(credentialReferences.id, params.id)) }) || null;
+	return await db.query.credentialReferences.findFirst({ where: and(projectScopedWhere(credentialReferences, params.scopes), eq(credentialReferences.id, params.id)) }) || null;
 };
 /**
 * Count credential references for a tenant/project
 */
 const countCredentialReferences = (db) => async (params) => {
-	const total = (await db.select({ count: count() }).from(credentialReferences).where(and(eq(credentialReferences.tenantId, params.scopes.tenantId), eq(credentialReferences.projectId, params.scopes.projectId))))[0]?.count || 0;
+	const total = (await db.select({ count: count() }).from(credentialReferences).where(projectScopedWhere(credentialReferences, params.scopes)))[0]?.count || 0;
 	return typeof total === "string" ? Number.parseInt(total, 10) : total;
 };
 /**

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

@@ -65,12 +65,12 @@ declare const associateDataComponentWithAgent: (db: AgentsManageDatabaseClient)
   scopes: SubAgentScopeConfig;
   dataComponentId: string;
 }) => Promise<{
-  id: string;
-  createdAt: string;
-  subAgentId: string;
-  projectId: string;
   tenantId: string;
+  projectId: string;
   agentId: string;
+  subAgentId: string;
+  id: string;
+  createdAt: string;
   dataComponentId: string;
 }>;
 /**
@@ -107,12 +107,12 @@ declare const upsertAgentDataComponentRelation: (db: AgentsManageDatabaseClient)
   scopes: SubAgentScopeConfig;
   dataComponentId: string;
 }) => Promise<{
-  id: string;
-  createdAt: string;
-  subAgentId: string;
-  projectId: string;
   tenantId: string;
+  projectId: string;
   agentId: string;
+  subAgentId: string;
+  id: string;
+  createdAt: string;
   dataComponentId: string;
 } | null>;
 /**

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

@@ -2,6 +2,7 @@ import { dataComponents, subAgentDataComponents } from "../../db/manage/manage-s
 import { validatePropsAsJsonSchema } from "../../validation/props-validation.js";
 import { validateRender } from "../../validation/render-validation.js";
 import { generateId } from "../../utils/conversations.js";
+import { projectScopedWhere, subAgentScopedWhere } from "./scope-helpers.js";
 import { createApiError } from "../../utils/error.js";
 import "../../utils/index.js";
 import { and, count, desc, eq } from "drizzle-orm";
@@ -11,13 +12,13 @@ import { and, count, desc, eq } from "drizzle-orm";
 * Get a data component by ID
 */
 const getDataComponent = (db) => async (params) => {
-	return await db.query.dataComponents.findFirst({ where: and(eq(dataComponents.tenantId, params.scopes.tenantId), eq(dataComponents.projectId, params.scopes.projectId), eq(dataComponents.id, params.dataComponentId)) }) || null;
+	return await db.query.dataComponents.findFirst({ where: and(projectScopedWhere(dataComponents, params.scopes), eq(dataComponents.id, params.dataComponentId)) }) || null;
 };
 /**
 * List all data components for a tenant/project
 */
 const listDataComponents = (db) => async (params) => {
-	return await db.select().from(dataComponents).where(and(eq(dataComponents.tenantId, params.scopes.tenantId), eq(dataComponents.projectId, params.scopes.projectId))).orderBy(desc(dataComponents.createdAt));
+	return await db.select().from(dataComponents).where(projectScopedWhere(dataComponents, params.scopes)).orderBy(desc(dataComponents.createdAt));
 };
 /**
 * List data components with pagination
@@ -26,7 +27,8 @@ const listDataComponentsPaginated = (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(dataComponents).where(and(eq(dataComponents.tenantId, params.scopes.tenantId), eq(dataComponents.projectId, params.scopes.projectId))).limit(limit).offset(offset).orderBy(desc(dataComponents.createdAt)), db.select({ count: count() }).from(dataComponents).where(and(eq(dataComponents.tenantId, params.scopes.tenantId), eq(dataComponents.projectId, params.scopes.projectId)))]);
+	const whereClause = projectScopedWhere(dataComponents, params.scopes);
+	const [data, totalResult] = await Promise.all([db.select().from(dataComponents).where(whereClause).limit(limit).offset(offset).orderBy(desc(dataComponents.createdAt)), db.select({ count: count() }).from(dataComponents).where(whereClause)]);
 	const total = typeof totalResult[0]?.count === "string" ? parseInt(totalResult[0].count, 10) : totalResult[0]?.count || 0;
 	return {
 		data,
@@ -84,7 +86,7 @@ const updateDataComponent = (db) => async (params) => {
 	await db.update(dataComponents).set({
 		...params.data,
 		updatedAt: now
-	}).where(and(eq(dataComponents.tenantId, params.scopes.tenantId), eq(dataComponents.projectId, params.scopes.projectId), eq(dataComponents.id, params.dataComponentId)));
+	}).where(and(projectScopedWhere(dataComponents, params.scopes), eq(dataComponents.id, params.dataComponentId)));
 	return await getDataComponent(db)({
 		scopes: params.scopes,
 		dataComponentId: params.dataComponentId
@@ -94,7 +96,7 @@ const updateDataComponent = (db) => async (params) => {
 * Delete a data component
 */
 const deleteDataComponent = (db) => async (params) => {
-	return (await db.delete(dataComponents).where(and(eq(dataComponents.tenantId, params.scopes.tenantId), eq(dataComponents.projectId, params.scopes.projectId), eq(dataComponents.id, params.dataComponentId))).returning()).length > 0;
+	return (await db.delete(dataComponents).where(and(projectScopedWhere(dataComponents, params.scopes), eq(dataComponents.id, params.dataComponentId))).returning()).length > 0;
 };
 /**
 * Get data components for a specific agent
@@ -110,7 +112,7 @@ const getDataComponentsForAgent = (db) => async (params) => {
 		createdAt: dataComponents.createdAt,
 		updatedAt: dataComponents.updatedAt,
 		render: dataComponents.render
-	}).from(dataComponents).innerJoin(subAgentDataComponents, and(eq(dataComponents.id, subAgentDataComponents.dataComponentId), eq(dataComponents.tenantId, subAgentDataComponents.tenantId), eq(dataComponents.projectId, subAgentDataComponents.projectId))).where(and(eq(dataComponents.tenantId, params.scopes.tenantId), eq(dataComponents.projectId, params.scopes.projectId), eq(subAgentDataComponents.agentId, params.scopes.agentId), eq(subAgentDataComponents.subAgentId, params.scopes.subAgentId))).orderBy(desc(dataComponents.createdAt));
+	}).from(dataComponents).innerJoin(subAgentDataComponents, and(eq(dataComponents.id, subAgentDataComponents.dataComponentId), eq(dataComponents.tenantId, subAgentDataComponents.tenantId), eq(dataComponents.projectId, subAgentDataComponents.projectId))).where(and(projectScopedWhere(dataComponents, params.scopes), eq(subAgentDataComponents.agentId, params.scopes.agentId), eq(subAgentDataComponents.subAgentId, params.scopes.subAgentId))).orderBy(desc(dataComponents.createdAt));
 };
 /**
 * Associate a data component with an agent
@@ -129,10 +131,10 @@ const associateDataComponentWithAgent = (db) => async (params) => {
 * Remove association between data component and agent
 */
 const removeDataComponentFromAgent = (db) => async (params) => {
-	return (await db.delete(subAgentDataComponents).where(and(eq(subAgentDataComponents.tenantId, params.scopes.tenantId), eq(subAgentDataComponents.projectId, params.scopes.projectId), eq(subAgentDataComponents.agentId, params.scopes.agentId), eq(subAgentDataComponents.subAgentId, params.scopes.subAgentId), eq(subAgentDataComponents.dataComponentId, params.dataComponentId))).returning()).length > 0;
+	return (await db.delete(subAgentDataComponents).where(and(subAgentScopedWhere(subAgentDataComponents, params.scopes), eq(subAgentDataComponents.dataComponentId, params.dataComponentId))).returning()).length > 0;
 };
 const deleteAgentDataComponentRelationByAgent = (db) => async (params) => {
-	return (await db.delete(subAgentDataComponents).where(and(eq(subAgentDataComponents.tenantId, params.scopes.tenantId), eq(subAgentDataComponents.projectId, params.scopes.projectId), eq(subAgentDataComponents.agentId, params.scopes.agentId), eq(subAgentDataComponents.subAgentId, params.scopes.subAgentId))).returning()).length > 0;
+	return (await db.delete(subAgentDataComponents).where(subAgentScopedWhere(subAgentDataComponents, params.scopes)).returning()).length > 0;
 };
 /**
 * Get all agents that use a specific data component
@@ -141,13 +143,13 @@ const getAgentsUsingDataComponent = (db) => async (params) => {
 	return await db.select({
 		subAgentId: subAgentDataComponents.subAgentId,
 		createdAt: subAgentDataComponents.createdAt
-	}).from(subAgentDataComponents).where(and(eq(subAgentDataComponents.tenantId, params.scopes.tenantId), eq(subAgentDataComponents.projectId, params.scopes.projectId), eq(subAgentDataComponents.dataComponentId, params.dataComponentId))).orderBy(desc(subAgentDataComponents.createdAt));
+	}).from(subAgentDataComponents).where(and(projectScopedWhere(subAgentDataComponents, params.scopes), eq(subAgentDataComponents.dataComponentId, params.dataComponentId))).orderBy(desc(subAgentDataComponents.createdAt));
 };
 /**
 * Check if a data component is associated with an agent
 */
 const isDataComponentAssociatedWithAgent = (db) => async (params) => {
-	return (await db.select({ id: subAgentDataComponents.id }).from(subAgentDataComponents).where(and(eq(subAgentDataComponents.tenantId, params.scopes.tenantId), eq(subAgentDataComponents.projectId, params.scopes.projectId), eq(subAgentDataComponents.agentId, params.scopes.agentId), eq(subAgentDataComponents.subAgentId, params.scopes.subAgentId), eq(subAgentDataComponents.dataComponentId, params.dataComponentId))).limit(1)).length > 0;
+	return (await db.select({ id: subAgentDataComponents.id }).from(subAgentDataComponents).where(and(subAgentScopedWhere(subAgentDataComponents, params.scopes), eq(subAgentDataComponents.dataComponentId, params.dataComponentId))).limit(1)).length > 0;
 };
 /**
 * Upsert agent-data component relation (create if it doesn't exist, no-op if it does)
@@ -160,7 +162,7 @@ const upsertAgentDataComponentRelation = (db) => async (params) => {
 * Count data components for a tenant/project
 */
 const countDataComponents = (db) => async (params) => {
-	const countValue = (await db.select({ count: count() }).from(dataComponents).where(and(eq(dataComponents.tenantId, params.scopes.tenantId), eq(dataComponents.projectId, params.scopes.projectId))))[0]?.count;
+	const countValue = (await db.select({ count: count() }).from(dataComponents).where(projectScopedWhere(dataComponents, params.scopes)))[0]?.count;
 	return typeof countValue === "string" ? parseInt(countValue, 10) : countValue || 0;
 };
 /**

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

@@ -1,13 +1,14 @@
 import { dataset, datasetItem, datasetRunConfig, datasetRunConfigAgentRelations, evaluationJobConfig, evaluationJobConfigEvaluatorRelations, evaluationRunConfig, evaluationRunConfigEvaluationSuiteConfigRelations, evaluationSuiteConfig, evaluationSuiteConfigEvaluatorRelations, evaluator } from "../../db/manage/manage-schema.js";
 import { datasetRun } from "../../db/runtime/runtime-schema.js";
+import { projectScopedWhere } from "./scope-helpers.js";
 import { and, eq, inArray } from "drizzle-orm";
 
 //#region src/data-access/manage/evalConfig.ts
 const getDatasetById = (db) => async (params) => {
-	return (await db.select().from(dataset).where(and(eq(dataset.tenantId, params.scopes.tenantId), eq(dataset.projectId, params.scopes.projectId), eq(dataset.id, params.scopes.datasetId))).limit(1))[0] ?? null;
+	return (await db.select().from(dataset).where(and(projectScopedWhere(dataset, params.scopes), eq(dataset.id, params.scopes.datasetId))).limit(1))[0] ?? null;
 };
 const listDatasets = (db) => async (params) => {
-	return await db.select().from(dataset).where(and(eq(dataset.tenantId, params.scopes.tenantId), eq(dataset.projectId, params.scopes.projectId)));
+	return await db.select().from(dataset).where(projectScopedWhere(dataset, params.scopes));
 };
 const createDataset = (db) => async (data) => {
 	const now = (/* @__PURE__ */ new Date()).toISOString();
@@ -21,17 +22,17 @@ const createDataset = (db) => async (data) => {
 const updateDataset = (db) => async (params) => {
 	const updateData = { updatedAt: (/* @__PURE__ */ new Date()).toISOString() };
 	for (const [key, value] of Object.entries(params.data)) if (value !== void 0) updateData[key] = value;
-	const [updated] = await db.update(dataset).set(updateData).where(and(eq(dataset.tenantId, params.scopes.tenantId), eq(dataset.projectId, params.scopes.projectId), eq(dataset.id, params.scopes.datasetId))).returning();
+	const [updated] = await db.update(dataset).set(updateData).where(and(projectScopedWhere(dataset, params.scopes), eq(dataset.id, params.scopes.datasetId))).returning();
 	return updated ?? null;
 };
 const deleteDataset = (db) => async (params) => {
-	return (await db.delete(dataset).where(and(eq(dataset.tenantId, params.scopes.tenantId), eq(dataset.projectId, params.scopes.projectId), eq(dataset.id, params.scopes.datasetId))).returning()).length > 0;
+	return (await db.delete(dataset).where(and(projectScopedWhere(dataset, params.scopes), eq(dataset.id, params.scopes.datasetId))).returning()).length > 0;
 };
 const getDatasetItemById = (db) => async (params) => {
-	return (await db.select().from(datasetItem).where(and(eq(datasetItem.tenantId, params.scopes.tenantId), eq(datasetItem.projectId, params.scopes.projectId), eq(datasetItem.id, params.scopes.datasetItemId))).limit(1))[0] ?? null;
+	return (await db.select().from(datasetItem).where(and(projectScopedWhere(datasetItem, params.scopes), eq(datasetItem.id, params.scopes.datasetItemId))).limit(1))[0] ?? null;
 };
 const listDatasetItems = (db) => async (params) => {
-	return await db.select().from(datasetItem).where(and(eq(datasetItem.tenantId, params.scopes.tenantId), eq(datasetItem.projectId, params.scopes.projectId), eq(datasetItem.datasetId, params.scopes.datasetId)));
+	return await db.select().from(datasetItem).where(and(projectScopedWhere(datasetItem, params.scopes), eq(datasetItem.datasetId, params.scopes.datasetId)));
 };
 const createDatasetItem = (db) => async (data) => {
 	const now = (/* @__PURE__ */ new Date()).toISOString();
@@ -54,20 +55,20 @@ const createDatasetItems = (db) => async (data) => {
 const updateDatasetItem = (db) => async (params) => {
 	const updateData = { updatedAt: (/* @__PURE__ */ new Date()).toISOString() };
 	for (const [key, value] of Object.entries(params.data)) if (value !== void 0) updateData[key] = value;
-	const [updated] = await db.update(datasetItem).set(updateData).where(and(eq(datasetItem.tenantId, params.scopes.tenantId), eq(datasetItem.projectId, params.scopes.projectId), eq(datasetItem.id, params.scopes.datasetItemId))).returning();
+	const [updated] = await db.update(datasetItem).set(updateData).where(and(projectScopedWhere(datasetItem, params.scopes), eq(datasetItem.id, params.scopes.datasetItemId))).returning();
 	return updated ?? null;
 };
 const deleteDatasetItem = (db) => async (params) => {
-	return (await db.delete(datasetItem).where(and(eq(datasetItem.tenantId, params.scopes.tenantId), eq(datasetItem.projectId, params.scopes.projectId), eq(datasetItem.id, params.scopes.datasetItemId))).returning()).length > 0;
+	return (await db.delete(datasetItem).where(and(projectScopedWhere(datasetItem, params.scopes), eq(datasetItem.id, params.scopes.datasetItemId))).returning()).length > 0;
 };
 const deleteDatasetItemsByDataset = (db) => async (params) => {
-	return (await db.delete(datasetItem).where(and(eq(datasetItem.tenantId, params.scopes.tenantId), eq(datasetItem.projectId, params.scopes.projectId), eq(datasetItem.datasetId, params.scopes.datasetId))).returning()).length;
+	return (await db.delete(datasetItem).where(and(projectScopedWhere(datasetItem, params.scopes), eq(datasetItem.datasetId, params.scopes.datasetId))).returning()).length;
 };
 const getDatasetRunConfigById = (db) => async (params) => {
-	return (await db.select().from(datasetRunConfig).where(and(eq(datasetRunConfig.tenantId, params.scopes.tenantId), eq(datasetRunConfig.projectId, params.scopes.projectId), eq(datasetRunConfig.id, params.scopes.datasetRunConfigId))).limit(1))[0] ?? null;
+	return (await db.select().from(datasetRunConfig).where(and(projectScopedWhere(datasetRunConfig, params.scopes), eq(datasetRunConfig.id, params.scopes.datasetRunConfigId))).limit(1))[0] ?? null;
 };
 const listDatasetRunConfigs = (db) => async (params) => {
-	return await db.select().from(datasetRunConfig).where(and(eq(datasetRunConfig.tenantId, params.scopes.tenantId), eq(datasetRunConfig.projectId, params.scopes.projectId)));
+	return await db.select().from(datasetRunConfig).where(projectScopedWhere(datasetRunConfig, params.scopes));
 };
 const createDatasetRunConfig = (db) => async (data) => {
 	const now = (/* @__PURE__ */ new Date()).toISOString();
@@ -81,14 +82,14 @@ const createDatasetRunConfig = (db) => async (data) => {
 const updateDatasetRunConfig = (db) => async (params) => {
 	const updateData = { updatedAt: (/* @__PURE__ */ new Date()).toISOString() };
 	for (const [key, value] of Object.entries(params.data)) if (value !== void 0) updateData[key] = value;
-	const [updated] = await db.update(datasetRunConfig).set(updateData).where(and(eq(datasetRunConfig.tenantId, params.scopes.tenantId), eq(datasetRunConfig.projectId, params.scopes.projectId), eq(datasetRunConfig.id, params.scopes.datasetRunConfigId))).returning();
+	const [updated] = await db.update(datasetRunConfig).set(updateData).where(and(projectScopedWhere(datasetRunConfig, params.scopes), eq(datasetRunConfig.id, params.scopes.datasetRunConfigId))).returning();
 	return updated ?? null;
 };
 const deleteDatasetRunConfig = (db) => async (params) => {
-	return (await db.delete(datasetRunConfig).where(and(eq(datasetRunConfig.tenantId, params.scopes.tenantId), eq(datasetRunConfig.projectId, params.scopes.projectId), eq(datasetRunConfig.id, params.scopes.datasetRunConfigId))).returning()).length > 0;
+	return (await db.delete(datasetRunConfig).where(and(projectScopedWhere(datasetRunConfig, params.scopes), eq(datasetRunConfig.id, params.scopes.datasetRunConfigId))).returning()).length > 0;
 };
 const getDatasetRunConfigAgentRelations = (db) => async (params) => {
-	return await db.select().from(datasetRunConfigAgentRelations).where(and(eq(datasetRunConfigAgentRelations.tenantId, params.scopes.tenantId), eq(datasetRunConfigAgentRelations.projectId, params.scopes.projectId), eq(datasetRunConfigAgentRelations.datasetRunConfigId, params.scopes.datasetRunConfigId)));
+	return await db.select().from(datasetRunConfigAgentRelations).where(and(projectScopedWhere(datasetRunConfigAgentRelations, params.scopes), eq(datasetRunConfigAgentRelations.datasetRunConfigId, params.scopes.datasetRunConfigId)));
 };
 const createDatasetRunConfigAgentRelation = (db) => async (data) => {
 	const now = (/* @__PURE__ */ new Date()).toISOString();
@@ -100,17 +101,17 @@ const createDatasetRunConfigAgentRelation = (db) => async (data) => {
 	return created;
 };
 const deleteDatasetRunConfigAgentRelation = (db) => async (params) => {
-	return (await db.delete(datasetRunConfigAgentRelations).where(and(eq(datasetRunConfigAgentRelations.tenantId, params.scopes.tenantId), eq(datasetRunConfigAgentRelations.projectId, params.scopes.projectId), eq(datasetRunConfigAgentRelations.datasetRunConfigId, params.scopes.datasetRunConfigId), eq(datasetRunConfigAgentRelations.agentId, params.scopes.agentId))).returning()).length > 0;
+	return (await db.delete(datasetRunConfigAgentRelations).where(and(projectScopedWhere(datasetRunConfigAgentRelations, params.scopes), eq(datasetRunConfigAgentRelations.datasetRunConfigId, params.scopes.datasetRunConfigId), eq(datasetRunConfigAgentRelations.agentId, params.scopes.agentId))).returning()).length > 0;
 };
 const getEvaluatorById = (db) => async (params) => {
-	return (await db.select().from(evaluator).where(and(eq(evaluator.tenantId, params.scopes.tenantId), eq(evaluator.projectId, params.scopes.projectId), eq(evaluator.id, params.scopes.evaluatorId))).limit(1))[0] ?? null;
+	return (await db.select().from(evaluator).where(and(projectScopedWhere(evaluator, params.scopes), eq(evaluator.id, params.scopes.evaluatorId))).limit(1))[0] ?? null;
 };
 const listEvaluators = (db) => async (params) => {
-	return await db.select().from(evaluator).where(and(eq(evaluator.tenantId, params.scopes.tenantId), eq(evaluator.projectId, params.scopes.projectId)));
+	return await db.select().from(evaluator).where(projectScopedWhere(evaluator, params.scopes));
 };
 const getEvaluatorsByIds = (db) => async (params) => {
 	if (params.evaluatorIds.length === 0) return [];
-	return await db.select().from(evaluator).where(and(eq(evaluator.tenantId, params.scopes.tenantId), eq(evaluator.projectId, params.scopes.projectId), inArray(evaluator.id, params.evaluatorIds)));
+	return await db.select().from(evaluator).where(and(projectScopedWhere(evaluator, params.scopes), inArray(evaluator.id, params.evaluatorIds)));
 };
 const createEvaluator = (db) => async (data) => {
 	const now = (/* @__PURE__ */ new Date()).toISOString();
@@ -124,17 +125,17 @@ const createEvaluator = (db) => async (data) => {
 const updateEvaluator = (db) => async (params) => {
 	const updateData = { updatedAt: (/* @__PURE__ */ new Date()).toISOString() };
 	for (const [key, value] of Object.entries(params.data)) if (value !== void 0) updateData[key] = value;
-	const [updated] = await db.update(evaluator).set(updateData).where(and(eq(evaluator.tenantId, params.scopes.tenantId), eq(evaluator.projectId, params.scopes.projectId), eq(evaluator.id, params.scopes.evaluatorId))).returning();
+	const [updated] = await db.update(evaluator).set(updateData).where(and(projectScopedWhere(evaluator, params.scopes), eq(evaluator.id, params.scopes.evaluatorId))).returning();
 	return updated ?? null;
 };
 const deleteEvaluator = (db) => async (params) => {
-	return (await db.delete(evaluator).where(and(eq(evaluator.tenantId, params.scopes.tenantId), eq(evaluator.projectId, params.scopes.projectId), eq(evaluator.id, params.scopes.evaluatorId))).returning()).length > 0;
+	return (await db.delete(evaluator).where(and(projectScopedWhere(evaluator, params.scopes), eq(evaluator.id, params.scopes.evaluatorId))).returning()).length > 0;
 };
 const getEvaluationSuiteConfigById = (db) => async (params) => {
-	return (await db.select().from(evaluationSuiteConfig).where(and(eq(evaluationSuiteConfig.tenantId, params.scopes.tenantId), eq(evaluationSuiteConfig.projectId, params.scopes.projectId), eq(evaluationSuiteConfig.id, params.scopes.evaluationSuiteConfigId))).limit(1))[0] ?? null;
+	return (await db.select().from(evaluationSuiteConfig).where(and(projectScopedWhere(evaluationSuiteConfig, params.scopes), eq(evaluationSuiteConfig.id, params.scopes.evaluationSuiteConfigId))).limit(1))[0] ?? null;
 };
 const listEvaluationSuiteConfigs = (db) => async (params) => {
-	return await db.select().from(evaluationSuiteConfig).where(and(eq(evaluationSuiteConfig.tenantId, params.scopes.tenantId), eq(evaluationSuiteConfig.projectId, params.scopes.projectId)));
+	return await db.select().from(evaluationSuiteConfig).where(projectScopedWhere(evaluationSuiteConfig, params.scopes));
 };
 const createEvaluationSuiteConfig = (db) => async (data) => {
 	const now = (/* @__PURE__ */ new Date()).toISOString();
@@ -148,14 +149,14 @@ const createEvaluationSuiteConfig = (db) => async (data) => {
 const updateEvaluationSuiteConfig = (db) => async (params) => {
 	const updateData = { updatedAt: (/* @__PURE__ */ new Date()).toISOString() };
 	for (const [key, value] of Object.entries(params.data)) if (value !== void 0) updateData[key] = value;
-	const [updated] = await db.update(evaluationSuiteConfig).set(updateData).where(and(eq(evaluationSuiteConfig.tenantId, params.scopes.tenantId), eq(evaluationSuiteConfig.projectId, params.scopes.projectId), eq(evaluationSuiteConfig.id, params.scopes.evaluationSuiteConfigId))).returning();
+	const [updated] = await db.update(evaluationSuiteConfig).set(updateData).where(and(projectScopedWhere(evaluationSuiteConfig, params.scopes), eq(evaluationSuiteConfig.id, params.scopes.evaluationSuiteConfigId))).returning();
 	return updated ?? null;
 };
 const deleteEvaluationSuiteConfig = (db) => async (params) => {
-	return (await db.delete(evaluationSuiteConfig).where(and(eq(evaluationSuiteConfig.tenantId, params.scopes.tenantId), eq(evaluationSuiteConfig.projectId, params.scopes.projectId), eq(evaluationSuiteConfig.id, params.scopes.evaluationSuiteConfigId))).returning()).length > 0;
+	return (await db.delete(evaluationSuiteConfig).where(and(projectScopedWhere(evaluationSuiteConfig, params.scopes), eq(evaluationSuiteConfig.id, params.scopes.evaluationSuiteConfigId))).returning()).length > 0;
 };
 const getEvaluationSuiteConfigEvaluatorRelations = (db) => async (params) => {
-	return await db.select().from(evaluationSuiteConfigEvaluatorRelations).where(and(eq(evaluationSuiteConfigEvaluatorRelations.tenantId, params.scopes.tenantId), eq(evaluationSuiteConfigEvaluatorRelations.projectId, params.scopes.projectId), eq(evaluationSuiteConfigEvaluatorRelations.evaluationSuiteConfigId, params.scopes.evaluationSuiteConfigId)));
+	return await db.select().from(evaluationSuiteConfigEvaluatorRelations).where(and(projectScopedWhere(evaluationSuiteConfigEvaluatorRelations, params.scopes), eq(evaluationSuiteConfigEvaluatorRelations.evaluationSuiteConfigId, params.scopes.evaluationSuiteConfigId)));
 };
 const createEvaluationSuiteConfigEvaluatorRelation = (db) => async (data) => {
 	const now = (/* @__PURE__ */ new Date()).toISOString();
@@ -167,22 +168,22 @@ const createEvaluationSuiteConfigEvaluatorRelation = (db) => async (data) => {
 	return created;
 };
 const deleteEvaluationSuiteConfigEvaluatorRelation = (db) => async (params) => {
-	return (await db.delete(evaluationSuiteConfigEvaluatorRelations).where(and(eq(evaluationSuiteConfigEvaluatorRelations.tenantId, params.scopes.tenantId), eq(evaluationSuiteConfigEvaluatorRelations.projectId, params.scopes.projectId), eq(evaluationSuiteConfigEvaluatorRelations.evaluationSuiteConfigId, params.scopes.evaluationSuiteConfigId), eq(evaluationSuiteConfigEvaluatorRelations.evaluatorId, params.scopes.evaluatorId))).returning()).length > 0;
+	return (await db.delete(evaluationSuiteConfigEvaluatorRelations).where(and(projectScopedWhere(evaluationSuiteConfigEvaluatorRelations, params.scopes), eq(evaluationSuiteConfigEvaluatorRelations.evaluationSuiteConfigId, params.scopes.evaluationSuiteConfigId), eq(evaluationSuiteConfigEvaluatorRelations.evaluatorId, params.scopes.evaluatorId))).returning()).length > 0;
 };
 const deleteEvaluationSuiteConfigEvaluatorRelationsByEvaluator = (db) => async (params) => {
-	return (await db.delete(evaluationSuiteConfigEvaluatorRelations).where(and(eq(evaluationSuiteConfigEvaluatorRelations.tenantId, params.scopes.tenantId), eq(evaluationSuiteConfigEvaluatorRelations.projectId, params.scopes.projectId), eq(evaluationSuiteConfigEvaluatorRelations.evaluatorId, params.scopes.evaluatorId))).returning()).length;
+	return (await db.delete(evaluationSuiteConfigEvaluatorRelations).where(and(projectScopedWhere(evaluationSuiteConfigEvaluatorRelations, params.scopes), eq(evaluationSuiteConfigEvaluatorRelations.evaluatorId, params.scopes.evaluatorId))).returning()).length;
 };
 const getEvaluationRunConfigById = (db) => async (params) => {
-	return (await db.select().from(evaluationRunConfig).where(and(eq(evaluationRunConfig.tenantId, params.scopes.tenantId), eq(evaluationRunConfig.projectId, params.scopes.projectId), eq(evaluationRunConfig.id, params.scopes.evaluationRunConfigId))).limit(1))[0] ?? null;
+	return (await db.select().from(evaluationRunConfig).where(and(projectScopedWhere(evaluationRunConfig, params.scopes), eq(evaluationRunConfig.id, params.scopes.evaluationRunConfigId))).limit(1))[0] ?? null;
 };
 const listEvaluationRunConfigs = (db) => async (params) => {
-	return await db.select().from(evaluationRunConfig).where(and(eq(evaluationRunConfig.tenantId, params.scopes.tenantId), eq(evaluationRunConfig.projectId, params.scopes.projectId)));
+	return await db.select().from(evaluationRunConfig).where(projectScopedWhere(evaluationRunConfig, params.scopes));
 };
 const listEvaluationRunConfigsWithSuiteConfigs = (db) => async (params) => {
 	const rows = await db.select({
 		runConfig: evaluationRunConfig,
 		suiteConfigId: evaluationRunConfigEvaluationSuiteConfigRelations.evaluationSuiteConfigId
-	}).from(evaluationRunConfig).leftJoin(evaluationRunConfigEvaluationSuiteConfigRelations, and(eq(evaluationRunConfigEvaluationSuiteConfigRelations.tenantId, evaluationRunConfig.tenantId), eq(evaluationRunConfigEvaluationSuiteConfigRelations.projectId, evaluationRunConfig.projectId), eq(evaluationRunConfigEvaluationSuiteConfigRelations.evaluationRunConfigId, evaluationRunConfig.id))).where(and(eq(evaluationRunConfig.tenantId, params.scopes.tenantId), eq(evaluationRunConfig.projectId, params.scopes.projectId)));
+	}).from(evaluationRunConfig).leftJoin(evaluationRunConfigEvaluationSuiteConfigRelations, and(eq(evaluationRunConfigEvaluationSuiteConfigRelations.tenantId, evaluationRunConfig.tenantId), eq(evaluationRunConfigEvaluationSuiteConfigRelations.projectId, evaluationRunConfig.projectId), eq(evaluationRunConfigEvaluationSuiteConfigRelations.evaluationRunConfigId, evaluationRunConfig.id))).where(projectScopedWhere(evaluationRunConfig, params.scopes));
 	const runConfigsById = /* @__PURE__ */ new Map();
 	for (const row of rows) {
 		const runConfig = row.runConfig;
@@ -210,14 +211,14 @@ const createEvaluationRunConfig = (db) => async (data) => {
 const updateEvaluationRunConfig = (db) => async (params) => {
 	const updateData = { updatedAt: (/* @__PURE__ */ new Date()).toISOString() };
 	for (const [key, value] of Object.entries(params.data)) if (value !== void 0) updateData[key] = value;
-	const [updated] = await db.update(evaluationRunConfig).set(updateData).where(and(eq(evaluationRunConfig.tenantId, params.scopes.tenantId), eq(evaluationRunConfig.projectId, params.scopes.projectId), eq(evaluationRunConfig.id, params.scopes.evaluationRunConfigId))).returning();
+	const [updated] = await db.update(evaluationRunConfig).set(updateData).where(and(projectScopedWhere(evaluationRunConfig, params.scopes), eq(evaluationRunConfig.id, params.scopes.evaluationRunConfigId))).returning();
 	return updated ?? null;
 };
 const deleteEvaluationRunConfig = (db) => async (params) => {
-	return (await db.delete(evaluationRunConfig).where(and(eq(evaluationRunConfig.tenantId, params.scopes.tenantId), eq(evaluationRunConfig.projectId, params.scopes.projectId), eq(evaluationRunConfig.id, params.scopes.evaluationRunConfigId))).returning()).length > 0;
+	return (await db.delete(evaluationRunConfig).where(and(projectScopedWhere(evaluationRunConfig, params.scopes), eq(evaluationRunConfig.id, params.scopes.evaluationRunConfigId))).returning()).length > 0;
 };
 const getEvaluationRunConfigEvaluationSuiteConfigRelations = (db) => async (params) => {
-	return await db.select().from(evaluationRunConfigEvaluationSuiteConfigRelations).where(and(eq(evaluationRunConfigEvaluationSuiteConfigRelations.tenantId, params.scopes.tenantId), eq(evaluationRunConfigEvaluationSuiteConfigRelations.projectId, params.scopes.projectId), eq(evaluationRunConfigEvaluationSuiteConfigRelations.evaluationRunConfigId, params.scopes.evaluationRunConfigId)));
+	return await db.select().from(evaluationRunConfigEvaluationSuiteConfigRelations).where(and(projectScopedWhere(evaluationRunConfigEvaluationSuiteConfigRelations, params.scopes), eq(evaluationRunConfigEvaluationSuiteConfigRelations.evaluationRunConfigId, params.scopes.evaluationRunConfigId)));
 };
 const createEvaluationRunConfigEvaluationSuiteConfigRelation = (db) => async (data) => {
 	const now = (/* @__PURE__ */ new Date()).toISOString();
@@ -229,13 +230,13 @@ const createEvaluationRunConfigEvaluationSuiteConfigRelation = (db) => async (da
 	return created;
 };
 const deleteEvaluationRunConfigEvaluationSuiteConfigRelation = (db) => async (params) => {
-	return (await db.delete(evaluationRunConfigEvaluationSuiteConfigRelations).where(and(eq(evaluationRunConfigEvaluationSuiteConfigRelations.tenantId, params.scopes.tenantId), eq(evaluationRunConfigEvaluationSuiteConfigRelations.projectId, params.scopes.projectId), eq(evaluationRunConfigEvaluationSuiteConfigRelations.evaluationRunConfigId, params.scopes.evaluationRunConfigId), eq(evaluationRunConfigEvaluationSuiteConfigRelations.evaluationSuiteConfigId, params.scopes.evaluationSuiteConfigId))).returning()).length > 0;
+	return (await db.delete(evaluationRunConfigEvaluationSuiteConfigRelations).where(and(projectScopedWhere(evaluationRunConfigEvaluationSuiteConfigRelations, params.scopes), eq(evaluationRunConfigEvaluationSuiteConfigRelations.evaluationRunConfigId, params.scopes.evaluationRunConfigId), eq(evaluationRunConfigEvaluationSuiteConfigRelations.evaluationSuiteConfigId, params.scopes.evaluationSuiteConfigId))).returning()).length > 0;
 };
 const getEvaluationJobConfigById = (db) => async (params) => {
-	return (await db.select().from(evaluationJobConfig).where(and(eq(evaluationJobConfig.tenantId, params.scopes.tenantId), eq(evaluationJobConfig.projectId, params.scopes.projectId), eq(evaluationJobConfig.id, params.scopes.evaluationJobConfigId))).limit(1))[0] ?? null;
+	return (await db.select().from(evaluationJobConfig).where(and(projectScopedWhere(evaluationJobConfig, params.scopes), eq(evaluationJobConfig.id, params.scopes.evaluationJobConfigId))).limit(1))[0] ?? null;
 };
 const listEvaluationJobConfigs = (db) => async (params) => {
-	return await db.select().from(evaluationJobConfig).where(and(eq(evaluationJobConfig.tenantId, params.scopes.tenantId), eq(evaluationJobConfig.projectId, params.scopes.projectId)));
+	return await db.select().from(evaluationJobConfig).where(projectScopedWhere(evaluationJobConfig, params.scopes));
 };
 const createEvaluationJobConfig = (db) => async (data) => {
 	const now = (/* @__PURE__ */ new Date()).toISOString();
@@ -247,10 +248,10 @@ const createEvaluationJobConfig = (db) => async (data) => {
 	return created;
 };
 const deleteEvaluationJobConfig = (db) => async (params) => {
-	return (await db.delete(evaluationJobConfig).where(and(eq(evaluationJobConfig.tenantId, params.scopes.tenantId), eq(evaluationJobConfig.projectId, params.scopes.projectId), eq(evaluationJobConfig.id, params.scopes.evaluationJobConfigId))).returning()).length > 0;
+	return (await db.delete(evaluationJobConfig).where(and(projectScopedWhere(evaluationJobConfig, params.scopes), eq(evaluationJobConfig.id, params.scopes.evaluationJobConfigId))).returning()).length > 0;
 };
 const getEvaluationJobConfigEvaluatorRelations = (db) => async (params) => {
-	return await db.select().from(evaluationJobConfigEvaluatorRelations).where(and(eq(evaluationJobConfigEvaluatorRelations.tenantId, params.scopes.tenantId), eq(evaluationJobConfigEvaluatorRelations.projectId, params.scopes.projectId), eq(evaluationJobConfigEvaluatorRelations.evaluationJobConfigId, params.scopes.evaluationJobConfigId)));
+	return await db.select().from(evaluationJobConfigEvaluatorRelations).where(and(projectScopedWhere(evaluationJobConfigEvaluatorRelations, params.scopes), eq(evaluationJobConfigEvaluatorRelations.evaluationJobConfigId, params.scopes.evaluationJobConfigId)));
 };
 const createEvaluationJobConfigEvaluatorRelation = (db) => async (data) => {
 	const now = (/* @__PURE__ */ new Date()).toISOString();
@@ -262,13 +263,13 @@ const createEvaluationJobConfigEvaluatorRelation = (db) => async (data) => {
 	return created;
 };
 const deleteEvaluationJobConfigEvaluatorRelation = (db) => async (params) => {
-	return (await db.delete(evaluationJobConfigEvaluatorRelations).where(and(eq(evaluationJobConfigEvaluatorRelations.tenantId, params.scopes.tenantId), eq(evaluationJobConfigEvaluatorRelations.projectId, params.scopes.projectId), eq(evaluationJobConfigEvaluatorRelations.evaluationJobConfigId, params.scopes.evaluationJobConfigId), eq(evaluationJobConfigEvaluatorRelations.evaluatorId, params.scopes.evaluatorId))).returning()).length > 0;
+	return (await db.delete(evaluationJobConfigEvaluatorRelations).where(and(projectScopedWhere(evaluationJobConfigEvaluatorRelations, params.scopes), eq(evaluationJobConfigEvaluatorRelations.evaluationJobConfigId, params.scopes.evaluationJobConfigId), eq(evaluationJobConfigEvaluatorRelations.evaluatorId, params.scopes.evaluatorId))).returning()).length > 0;
 };
 const deleteEvaluationJobConfigEvaluatorRelationsByEvaluator = (db) => async (params) => {
-	return (await db.delete(evaluationJobConfigEvaluatorRelations).where(and(eq(evaluationJobConfigEvaluatorRelations.tenantId, params.scopes.tenantId), eq(evaluationJobConfigEvaluatorRelations.projectId, params.scopes.projectId), eq(evaluationJobConfigEvaluatorRelations.evaluatorId, params.scopes.evaluatorId))).returning()).length;
+	return (await db.delete(evaluationJobConfigEvaluatorRelations).where(and(projectScopedWhere(evaluationJobConfigEvaluatorRelations, params.scopes), eq(evaluationJobConfigEvaluatorRelations.evaluatorId, params.scopes.evaluatorId))).returning()).length;
 };
 const linkDatasetRunToEvaluationJobConfig = (db) => async (params) => {
-	await db.update(datasetRun).set({ evaluationJobConfigId: params.evaluationJobConfigId }).where(and(eq(datasetRun.tenantId, params.scopes.tenantId), eq(datasetRun.projectId, params.scopes.projectId), eq(datasetRun.id, params.scopes.datasetRunId)));
+	await db.update(datasetRun).set({ evaluationJobConfigId: params.evaluationJobConfigId }).where(and(projectScopedWhere(datasetRun, params.scopes), eq(datasetRun.id, params.scopes.datasetRunId)));
 };
 
 //#endregion

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

@@ -1,4 +1,5 @@
 import { externalAgents } from "../../db/manage/manage-schema.js";
+import { projectScopedWhere } from "./scope-helpers.js";
 import { and, asc, count, desc, eq } from "drizzle-orm";
 
 //#region src/data-access/manage/externalAgents.ts
@@ -12,20 +13,20 @@ const createExternalAgent = (db) => async (params) => {
 * Get external agent by ID
 */
 const getExternalAgent = (db) => async (params) => {
-	return await db.query.externalAgents.findFirst({ where: and(eq(externalAgents.tenantId, params.scopes.tenantId), eq(externalAgents.projectId, params.scopes.projectId), eq(externalAgents.id, params.externalAgentId)) }) || null;
+	return await db.query.externalAgents.findFirst({ where: and(projectScopedWhere(externalAgents, params.scopes), eq(externalAgents.id, params.externalAgentId)) }) || null;
 };
 /**
 * Get external agent by base URL
 */
 const getExternalAgentByUrl = (db) => async (params) => {
-	return await db.query.externalAgents.findFirst({ where: and(eq(externalAgents.tenantId, params.scopes.tenantId), eq(externalAgents.projectId, params.scopes.projectId), eq(externalAgents.baseUrl, params.baseUrl)) }) || null;
+	return await db.query.externalAgents.findFirst({ where: and(projectScopedWhere(externalAgents, params.scopes), eq(externalAgents.baseUrl, params.baseUrl)) }) || null;
 };
 /**
 * List external agents for a project
 */
 const listExternalAgents = (db) => async (params) => {
 	return await db.query.externalAgents.findMany({
-		where: and(eq(externalAgents.tenantId, params.scopes.tenantId), eq(externalAgents.projectId, params.scopes.projectId)),
+		where: projectScopedWhere(externalAgents, params.scopes),
 		orderBy: [asc(externalAgents.name)]
 	});
 };
@@ -36,7 +37,7 @@ const listExternalAgentsPaginated = (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(externalAgents).where(and(eq(externalAgents.tenantId, params.scopes.tenantId), eq(externalAgents.projectId, params.scopes.projectId))).limit(limit).offset(offset).orderBy(desc(externalAgents.createdAt)), db.select({ count: count() }).from(externalAgents).where(and(eq(externalAgents.tenantId, params.scopes.tenantId), eq(externalAgents.projectId, params.scopes.projectId)))]);
+	const [data, totalResult] = await Promise.all([db.select().from(externalAgents).where(projectScopedWhere(externalAgents, params.scopes)).limit(limit).offset(offset).orderBy(desc(externalAgents.createdAt)), db.select({ count: count() }).from(externalAgents).where(projectScopedWhere(externalAgents, params.scopes))]);
 	const total = typeof totalResult[0]?.count === "string" ? parseInt(totalResult[0].count, 10) : totalResult[0]?.count || 0;
 	return {
 		data,
@@ -58,7 +59,7 @@ const updateExternalAgent = (db) => async (params) => {
 	};
 	if (Object.keys(updateData).length === 1) throw new Error("No fields to update");
 	if (updateData.credentialReferenceId === void 0) updateData.credentialReferenceId = null;
-	return (await db.update(externalAgents).set(updateData).where(and(eq(externalAgents.tenantId, params.scopes.tenantId), eq(externalAgents.projectId, params.scopes.projectId), eq(externalAgents.id, params.externalAgentId))).returning())[0] || null;
+	return (await db.update(externalAgents).set(updateData).where(and(projectScopedWhere(externalAgents, params.scopes), eq(externalAgents.id, params.externalAgentId))).returning())[0] || null;
 };
 /**
 * Upsert external agent (create if it doesn't exist, update if it does)
@@ -92,7 +93,7 @@ const upsertExternalAgent = (db) => async (params) => {
 */
 const deleteExternalAgent = (db) => async (params) => {
 	try {
-		return (await db.delete(externalAgents).where(and(eq(externalAgents.tenantId, params.scopes.tenantId), eq(externalAgents.projectId, params.scopes.projectId), eq(externalAgents.id, params.externalAgentId))).returning()).length > 0;
+		return (await db.delete(externalAgents).where(and(projectScopedWhere(externalAgents, params.scopes), eq(externalAgents.id, params.externalAgentId))).returning()).length > 0;
 	} catch (error) {
 		console.error("Error deleting external agent:", error);
 		return false;
@@ -114,7 +115,7 @@ const externalAgentUrlExists = (db) => async (params) => {
 * Count external agents for a project
 */
 const countExternalAgents = (db) => async (params) => {
-	const countValue = (await db.select({ count: count() }).from(externalAgents).where(and(eq(externalAgents.tenantId, params.scopes.tenantId), eq(externalAgents.projectId, params.scopes.projectId))))[0]?.count;
+	const countValue = (await db.select({ count: count() }).from(externalAgents).where(projectScopedWhere(externalAgents, params.scopes)))[0]?.count;
 	return typeof countValue === "string" ? parseInt(countValue, 10) : countValue || 0;
 };