@inkeep/agents-core 0.41.2 → 0.43.0

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

@@ -0,0 +1,275 @@
+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 { 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;
+};
+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)));
+};
+const createDataset = (db) => async (data) => {
+	const now = (/* @__PURE__ */ new Date()).toISOString();
+	const [created] = await db.insert(dataset).values({
+		...data,
+		createdAt: now,
+		updatedAt: now
+	}).returning();
+	return created;
+};
+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();
+	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;
+};
+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;
+};
+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)));
+};
+const createDatasetItem = (db) => async (data) => {
+	const now = (/* @__PURE__ */ new Date()).toISOString();
+	const [created] = await db.insert(datasetItem).values({
+		...data,
+		createdAt: now,
+		updatedAt: now
+	}).returning();
+	return created;
+};
+const createDatasetItems = (db) => async (data) => {
+	const now = (/* @__PURE__ */ new Date()).toISOString();
+	const values = data.map((item) => ({
+		...item,
+		createdAt: now,
+		updatedAt: now
+	}));
+	return await db.insert(datasetItem).values(values).returning();
+};
+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();
+	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;
+};
+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;
+};
+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;
+};
+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)));
+};
+const createDatasetRunConfig = (db) => async (data) => {
+	const now = (/* @__PURE__ */ new Date()).toISOString();
+	const [created] = await db.insert(datasetRunConfig).values({
+		...data,
+		createdAt: now,
+		updatedAt: now
+	}).returning();
+	return created;
+};
+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();
+	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;
+};
+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)));
+};
+const createDatasetRunConfigAgentRelation = (db) => async (data) => {
+	const now = (/* @__PURE__ */ new Date()).toISOString();
+	const [created] = await db.insert(datasetRunConfigAgentRelations).values({
+		...data,
+		createdAt: now,
+		updatedAt: now
+	}).returning();
+	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;
+};
+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;
+};
+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)));
+};
+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)));
+};
+const createEvaluator = (db) => async (data) => {
+	const now = (/* @__PURE__ */ new Date()).toISOString();
+	const [created] = await db.insert(evaluator).values({
+		...data,
+		createdAt: now,
+		updatedAt: now
+	}).returning();
+	return created;
+};
+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();
+	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;
+};
+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;
+};
+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)));
+};
+const createEvaluationSuiteConfig = (db) => async (data) => {
+	const now = (/* @__PURE__ */ new Date()).toISOString();
+	const [created] = await db.insert(evaluationSuiteConfig).values({
+		...data,
+		createdAt: now,
+		updatedAt: now
+	}).returning();
+	return created;
+};
+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();
+	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;
+};
+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)));
+};
+const createEvaluationSuiteConfigEvaluatorRelation = (db) => async (data) => {
+	const now = (/* @__PURE__ */ new Date()).toISOString();
+	const [created] = await db.insert(evaluationSuiteConfigEvaluatorRelations).values({
+		...data,
+		createdAt: now,
+		updatedAt: now
+	}).returning();
+	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;
+};
+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;
+};
+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;
+};
+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)));
+};
+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)));
+	const runConfigsById = /* @__PURE__ */ new Map();
+	for (const row of rows) {
+		const runConfig = row.runConfig;
+		const runConfigId = runConfig.id;
+		if (!runConfigsById.has(runConfigId)) {
+			const { tenantId: _tenantId, projectId: _projectId, ...apiRunConfig } = runConfig;
+			runConfigsById.set(runConfigId, {
+				...apiRunConfig,
+				suiteConfigIds: []
+			});
+		}
+		if (row.suiteConfigId) runConfigsById.get(runConfigId)?.suiteConfigIds.push(row.suiteConfigId);
+	}
+	return Array.from(runConfigsById.values());
+};
+const createEvaluationRunConfig = (db) => async (data) => {
+	const now = (/* @__PURE__ */ new Date()).toISOString();
+	const [created] = await db.insert(evaluationRunConfig).values({
+		...data,
+		createdAt: now,
+		updatedAt: now
+	}).returning();
+	return created;
+};
+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();
+	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;
+};
+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)));
+};
+const createEvaluationRunConfigEvaluationSuiteConfigRelation = (db) => async (data) => {
+	const now = (/* @__PURE__ */ new Date()).toISOString();
+	const [created] = await db.insert(evaluationRunConfigEvaluationSuiteConfigRelations).values({
+		...data,
+		createdAt: now,
+		updatedAt: now
+	}).returning();
+	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;
+};
+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;
+};
+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)));
+};
+const createEvaluationJobConfig = (db) => async (data) => {
+	const now = (/* @__PURE__ */ new Date()).toISOString();
+	const [created] = await db.insert(evaluationJobConfig).values({
+		...data,
+		createdAt: now,
+		updatedAt: now
+	}).returning();
+	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;
+};
+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)));
+};
+const createEvaluationJobConfigEvaluatorRelation = (db) => async (data) => {
+	const now = (/* @__PURE__ */ new Date()).toISOString();
+	const [created] = await db.insert(evaluationJobConfigEvaluatorRelations).values({
+		...data,
+		createdAt: now,
+		updatedAt: now
+	}).returning();
+	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;
+};
+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;
+};
+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)));
+};
+
+//#endregion
+export { createDataset, createDatasetItem, createDatasetItems, createDatasetRunConfig, createDatasetRunConfigAgentRelation, createEvaluationJobConfig, createEvaluationJobConfigEvaluatorRelation, createEvaluationRunConfig, createEvaluationRunConfigEvaluationSuiteConfigRelation, createEvaluationSuiteConfig, createEvaluationSuiteConfigEvaluatorRelation, createEvaluator, deleteDataset, deleteDatasetItem, deleteDatasetItemsByDataset, deleteDatasetRunConfig, deleteDatasetRunConfigAgentRelation, deleteEvaluationJobConfig, deleteEvaluationJobConfigEvaluatorRelation, deleteEvaluationJobConfigEvaluatorRelationsByEvaluator, deleteEvaluationRunConfig, deleteEvaluationRunConfigEvaluationSuiteConfigRelation, deleteEvaluationSuiteConfig, deleteEvaluationSuiteConfigEvaluatorRelation, deleteEvaluationSuiteConfigEvaluatorRelationsByEvaluator, deleteEvaluator, getDatasetById, getDatasetItemById, getDatasetRunConfigAgentRelations, getDatasetRunConfigById, getEvaluationJobConfigById, getEvaluationJobConfigEvaluatorRelations, getEvaluationRunConfigById, getEvaluationRunConfigEvaluationSuiteConfigRelations, getEvaluationSuiteConfigById, getEvaluationSuiteConfigEvaluatorRelations, getEvaluatorById, getEvaluatorsByIds, linkDatasetRunToEvaluationJobConfig, listDatasetItems, listDatasetRunConfigs, listDatasets, listEvaluationJobConfigs, listEvaluationRunConfigs, listEvaluationRunConfigsWithSuiteConfigs, listEvaluationSuiteConfigs, listEvaluators, updateDataset, updateDatasetItem, updateDatasetRunConfig, updateEvaluationRunConfig, updateEvaluationSuiteConfig, updateEvaluator };

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

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

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

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

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

@@ -0,0 +1,242 @@
+import { AgentScopeConfig, PaginationConfig } from "../../types/utility.js";
+import { AgentsManageDatabaseClient } from "../../db/manage/manage-client.js";
+import { FunctionToolApiInsert, FunctionToolApiUpdate } from "../../types/entities.js";
+
+//#region src/data-access/manage/functionTools.d.ts
+
+/**
+ * Get a function tool by ID (agent-scoped)
+ */
+declare const getFunctionToolById: (db: AgentsManageDatabaseClient) => (params: {
+  scopes: AgentScopeConfig;
+  functionToolId: string;
+}) => Promise<{
+  createdAt: string;
+  updatedAt: string;
+  name: string;
+  description: string | null;
+  functionId: string;
+  agentId: string;
+  projectId: string;
+  tenantId: string;
+  id: string;
+}>;
+/**
+ * List function tools (agent-scoped)
+ */
+declare const listFunctionTools: (db: AgentsManageDatabaseClient) => (params: {
+  scopes: AgentScopeConfig;
+  pagination?: PaginationConfig;
+}) => Promise<{
+  data: {
+    createdAt: string;
+    updatedAt: string;
+    name: string;
+    description: string | null;
+    functionId: string;
+    agentId: string;
+    projectId: string;
+    tenantId: string;
+    id: string;
+  }[];
+  pagination: {
+    page: number;
+    limit: number;
+    total: number;
+    pages: number;
+  };
+}>;
+/**
+ * Create a function tool (agent-scoped)
+ */
+declare const createFunctionTool: (db: AgentsManageDatabaseClient) => (params: {
+  data: FunctionToolApiInsert;
+  scopes: AgentScopeConfig;
+}) => Promise<{
+  id: string;
+  name: string;
+  createdAt: string;
+  updatedAt: string;
+  description: string | null;
+  tenantId: string;
+  agentId: string;
+  projectId: string;
+  functionId: string;
+}>;
+/**
+ * Update a function tool (agent-scoped)
+ */
+declare const updateFunctionTool: (db: AgentsManageDatabaseClient) => (params: {
+  scopes: AgentScopeConfig;
+  functionToolId: string;
+  data: FunctionToolApiUpdate;
+}) => Promise<{
+  createdAt: string;
+  updatedAt: string;
+  name: string;
+  description: string | null;
+  functionId: string;
+  agentId: string;
+  projectId: string;
+  tenantId: string;
+  id: string;
+}>;
+/**
+ * Delete a function tool (agent-scoped)
+ */
+declare const deleteFunctionTool: (db: AgentsManageDatabaseClient) => (params: {
+  scopes: AgentScopeConfig;
+  functionToolId: string;
+}) => Promise<boolean>;
+/**
+ * Upsert a function tool (create if it doesn't exist, update if it does)
+ */
+declare const upsertFunctionTool: (db: AgentsManageDatabaseClient) => (params: {
+  data: FunctionToolApiInsert;
+  scopes: AgentScopeConfig;
+}) => Promise<{
+  id: string;
+  name: string;
+  createdAt: string;
+  updatedAt: string;
+  description: string | null;
+  tenantId: string;
+  agentId: string;
+  projectId: string;
+  functionId: string;
+}>;
+declare const getFunctionToolsForSubAgent: (db: AgentsManageDatabaseClient) => (params: {
+  scopes: {
+    tenantId: string;
+    projectId: string;
+    agentId: string;
+  };
+  subAgentId: string;
+  pagination?: PaginationConfig;
+}) => Promise<{
+  data: {
+    id: string;
+    name: string;
+    description: string | null;
+    functionId: string;
+    createdAt: string;
+    updatedAt: string;
+    tenantId: string;
+    projectId: string;
+    agentId: string;
+    relationshipId: string;
+    toolPolicies: Record<string, {
+      needsApproval?: boolean;
+    }> | null;
+  }[];
+  pagination: {
+    page: number;
+    limit: number;
+    total: number;
+    pages: number;
+  };
+}>;
+/**
+ * Upsert a sub_agent-function tool relation (create if it doesn't exist, update if it does)
+ */
+declare const upsertSubAgentFunctionToolRelation: (db: AgentsManageDatabaseClient) => (params: {
+  scopes: AgentScopeConfig;
+  subAgentId: string;
+  functionToolId: string;
+  toolPolicies?: Record<string, {
+    needsApproval?: boolean;
+  }> | null;
+  relationId?: string;
+}) => Promise<{
+  id: string;
+}>;
+/**
+ * Add a function tool to an agent
+ */
+declare const addFunctionToolToSubAgent: (db: AgentsManageDatabaseClient) => (params: {
+  scopes: AgentScopeConfig;
+  subAgentId: string;
+  functionToolId: string;
+  toolPolicies?: Record<string, {
+    needsApproval?: boolean;
+  }> | null;
+}) => Promise<{
+  id: string;
+  createdAt: string;
+  updatedAt: string;
+  tenantId: string;
+  agentId: string;
+  projectId: string;
+  subAgentId: string;
+  toolPolicies: Record<string, {
+    needsApproval?: boolean;
+  }> | null;
+  functionToolId: string;
+}>;
+/**
+ * Update an agent-function tool relation
+ */
+declare const updateSubAgentFunctionToolRelation: (db: AgentsManageDatabaseClient) => (params: {
+  scopes: AgentScopeConfig;
+  relationId: string;
+  data: {
+    subAgentId: string;
+    functionToolId: string;
+    toolPolicies?: Record<string, {
+      needsApproval?: boolean;
+    }> | null;
+  };
+}) => Promise<{
+  id: string;
+}>;
+/**
+ * Get all sub-agents that use a specific function tool
+ */
+declare const getSubAgentsUsingFunctionTool: (db: AgentsManageDatabaseClient) => (params: {
+  scopes: AgentScopeConfig;
+  functionToolId: string;
+}) => Promise<{
+  subAgentId: string;
+  createdAt: string;
+}[]>;
+/**
+ * Remove a function tool from a sub-agent
+ */
+declare const removeFunctionToolFromSubAgent: (db: AgentsManageDatabaseClient) => (params: {
+  scopes: AgentScopeConfig;
+  subAgentId: string;
+  functionToolId: string;
+}) => Promise<boolean>;
+/**
+ * Check if a function tool is associated with a sub-agent
+ */
+declare const isFunctionToolAssociatedWithSubAgent: (db: AgentsManageDatabaseClient) => (params: {
+  scopes: AgentScopeConfig;
+  subAgentId: string;
+  functionToolId: string;
+}) => Promise<boolean>;
+/**
+ * Associate a function tool with a sub-agent (alias for addFunctionToolToSubAgent)
+ */
+declare const associateFunctionToolWithSubAgent: (db: AgentsManageDatabaseClient) => (params: {
+  scopes: AgentScopeConfig;
+  subAgentId: string;
+  functionToolId: string;
+  toolPolicies?: Record<string, {
+    needsApproval?: boolean;
+  }> | null;
+}) => Promise<{
+  id: string;
+  createdAt: string;
+  updatedAt: string;
+  tenantId: string;
+  agentId: string;
+  projectId: string;
+  subAgentId: string;
+  toolPolicies: Record<string, {
+    needsApproval?: boolean;
+  }> | null;
+  functionToolId: string;
+}>;
+//#endregion
+export { addFunctionToolToSubAgent, associateFunctionToolWithSubAgent, createFunctionTool, deleteFunctionTool, getFunctionToolById, getFunctionToolsForSubAgent, getSubAgentsUsingFunctionTool, isFunctionToolAssociatedWithSubAgent, listFunctionTools, removeFunctionToolFromSubAgent, updateFunctionTool, updateSubAgentFunctionToolRelation, upsertFunctionTool, upsertSubAgentFunctionToolRelation };