@inkeep/agents-core 0.41.2 → 0.42.0

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

@@ -1,4 +1,4 @@
-import { getLogger } from "../utils/logger.js";
+import { getLogger } from "../../utils/logger.js";
 import { deleteExternalAgent, listExternalAgents, upsertExternalAgent } from "./externalAgents.js";
 import { deleteFunction, listFunctions, upsertFunction } from "./functions.js";
 import { deleteCredentialReference, listCredentialReferences, upsertCredentialReference } from "./credentialReferences.js";
@@ -6,10 +6,10 @@ import { deleteTool, listTools, upsertTool } from "./tools.js";
 import { listAgents } from "./agents.js";
 import { deleteArtifactComponent, listArtifactComponents, upsertArtifactComponent } from "./artifactComponents.js";
 import { deleteDataComponent, listDataComponents, upsertDataComponent } from "./dataComponents.js";
-import { createFullAgentServerSide, deleteFullAgent, getFullAgent, updateFullAgentServerSide } from "./agentFull.js";
+import { createFullAgentServerSide, deleteFullAgent, getFullAgent, getFullAgentWithRelationIds, updateFullAgentServerSide } from "./agentFull.js";
 import { createProject, deleteProject, getProject, updateProject } from "./projects.js";
 
-//#region src/data-access/projectFull.ts
+//#region src/data-access/manage/projectFull.ts
 const defaultLogger = getLogger("projectFull");
 /**
 * Validate and type the project data
@@ -21,7 +21,8 @@ function validateAndTypeProjectData(projectData) {
 * Server-side implementation of createFullProject that performs actual database operations.
 * This function creates a complete project with all agent and their nested resources.
 */
-const createFullProjectServerSide = (db, logger = defaultLogger) => async (scopes, projectData) => {
+const createFullProjectServerSide = (db, logger = defaultLogger) => async (params) => {
+	const { scopes, projectData } = params;
 	const { tenantId } = scopes;
 	const typed = validateAndTypeProjectData(projectData);
 	logger.info({
@@ -336,10 +337,12 @@ const createFullProjectServerSide = (db, logger = defaultLogger) => async (scope
 			}, "Phase 2 complete: All sub-agents added successfully");
 		}
 		logger.info({ projectId: typed.id }, "Full project created successfully");
-		return await getFullProject(db, logger)({ scopes: {
+		const fullProject = await getFullProject(db, logger)({ scopes: {
 			tenantId,
 			projectId: typed.id
 		} });
+		if (!fullProject) throw new Error(`Failed to retrieve created project ${typed.id}`);
+		return fullProject;
 	} catch (error) {
 		logger.error({
 			tenantId,
@@ -353,7 +356,8 @@ const createFullProjectServerSide = (db, logger = defaultLogger) => async (scope
 * Server-side implementation of updateFullProject that performs actual database operations.
 * This function updates a complete project with all agent and their nested resources.
 */
-const updateFullProjectServerSide = (db, logger = defaultLogger) => async (scopes, projectData) => {
+const updateFullProjectServerSide = (db, logger = defaultLogger) => async (params) => {
+	const { scopes, projectData } = params;
 	const { tenantId } = scopes;
 	const typed = validateAndTypeProjectData(projectData);
 	if (!typed.id) throw new Error("Project ID is required");
@@ -369,9 +373,12 @@ const updateFullProjectServerSide = (db, logger = defaultLogger) => async (scope
 		} })) {
 			logger.info({ projectId: typed.id }, "Project not found, creating new project");
 			return await createFullProjectServerSide(db, logger)({
-				tenantId,
-				projectId: typed.id
-			}, projectData);
+				scopes: {
+					tenantId,
+					projectId: typed.id
+				},
+				projectData
+			});
 		}
 		const projectUpdatePayload = {
 			name: typed.name,
@@ -831,10 +838,12 @@ const updateFullProjectServerSide = (db, logger = defaultLogger) => async (scope
 			}, "All project agent updated successfully");
 		}
 		logger.info({ projectId: typed.id }, "Full project updated successfully");
-		return await getFullProject(db, logger)({ scopes: {
+		const fullProject = await getFullProject(db, logger)({ scopes: {
 			tenantId,
 			projectId: typed.id
 		} });
+		if (!fullProject) throw new Error("Failed to retrieve full project");
+		return fullProject;
 	} catch (error) {
 		logger.error({
 			tenantId,
@@ -847,12 +856,13 @@ const updateFullProjectServerSide = (db, logger = defaultLogger) => async (scope
 /**
 * Get a complete project definition with all nested resources
 */
-const getFullProject = (db, logger = defaultLogger) => async (params) => {
-	const { scopes } = params;
+const getFullProjectInternal = (db, logger = defaultLogger) => async (params) => {
+	const { scopes, includeRelationIds = false } = params;
 	const { tenantId, projectId } = scopes;
 	logger.info({
 		tenantId,
-		projectId
+		projectId,
+		includeRelationIds
 	}, "Retrieving full project definition");
 	try {
 		const project = await getProject(db)({ scopes: {
@@ -891,15 +901,7 @@ const getFullProject = (db, logger = defaultLogger) => async (params) => {
 					limit: 1e3
 				}
 			});
-			for (const tool of toolsList.data) projectTools[tool.id] = {
-				id: tool.id,
-				name: tool.name,
-				config: tool.config,
-				credentialReferenceId: tool.credentialReferenceId || void 0,
-				imageUrl: tool.imageUrl || void 0,
-				capabilities: tool.capabilities || void 0,
-				lastError: tool.lastError || void 0
-			};
+			for (const tool of toolsList.data) projectTools[tool.id] = tool;
 			logger.info({
 				tenantId,
 				projectId,
@@ -918,13 +920,7 @@ const getFullProject = (db, logger = defaultLogger) => async (params) => {
 				tenantId,
 				projectId
 			} });
-			for (const externalAgent of externalAgentsList) projectExternalAgents[externalAgent.id] = {
-				id: externalAgent.id,
-				name: externalAgent.name,
-				description: externalAgent.description,
-				baseUrl: externalAgent.baseUrl,
-				credentialReferenceId: externalAgent.credentialReferenceId || void 0
-			};
+			for (const externalAgent of externalAgentsList) projectExternalAgents[externalAgent.id] = externalAgent;
 			logger.info({
 				tenantId,
 				projectId,
@@ -943,13 +939,7 @@ const getFullProject = (db, logger = defaultLogger) => async (params) => {
 				tenantId,
 				projectId
 			} });
-			for (const component of dataComponentsList) projectDataComponents[component.id] = {
-				id: component.id,
-				name: component.name,
-				description: component.description,
-				props: component.props,
-				render: component.render
-			};
+			for (const component of dataComponentsList) projectDataComponents[component.id] = component;
 			logger.info({
 				tenantId,
 				projectId,
@@ -968,12 +958,7 @@ const getFullProject = (db, logger = defaultLogger) => async (params) => {
 				tenantId,
 				projectId
 			} });
-			for (const component of artifactComponentsList) projectArtifactComponents[component.id] = {
-				id: component.id,
-				name: component.name,
-				description: component.description,
-				props: component.props
-			};
+			for (const component of artifactComponentsList) projectArtifactComponents[component.id] = component;
 			logger.info({
 				tenantId,
 				projectId,
@@ -992,13 +977,7 @@ const getFullProject = (db, logger = defaultLogger) => async (params) => {
 				tenantId,
 				projectId
 			} });
-			for (const credential of credentialReferencesList) projectCredentialReferences[credential.id] = {
-				id: credential.id,
-				name: credential.name,
-				type: credential.type,
-				credentialStoreId: credential.credentialStoreId,
-				retrievalParams: credential.retrievalParams
-			};
+			for (const credential of credentialReferencesList) projectCredentialReferences[credential.id] = credential;
 			logger.info({
 				tenantId,
 				projectId,
@@ -1017,12 +996,7 @@ const getFullProject = (db, logger = defaultLogger) => async (params) => {
 				tenantId,
 				projectId
 			} });
-			for (const func of functionsList) projectFunctions[func.id] = {
-				id: func.id,
-				inputSchema: func.inputSchema,
-				executeCode: func.executeCode,
-				dependencies: func.dependencies
-			};
+			for (const func of functionsList) projectFunctions[func.id] = func;
 			logger.info({
 				tenantId,
 				projectId,
@@ -1037,6 +1011,7 @@ const getFullProject = (db, logger = defaultLogger) => async (params) => {
 		}
 		const agents = {};
 		if (agentList.length > 0) {
+			const getAgentFn = includeRelationIds ? getFullAgentWithRelationIds : getFullAgent;
 			const agentPromises = agentList.map(async (agent) => {
 				try {
 					logger.info({
@@ -1044,7 +1019,7 @@ const getFullProject = (db, logger = defaultLogger) => async (params) => {
 						projectId,
 						agentId: agent.id
 					}, "Retrieving full agent definition");
-					const fullAgent = await getFullAgent(db)({ scopes: {
+					const fullAgent = await getAgentFn(db)({ scopes: {
 						tenantId,
 						projectId,
 						agentId: agent.id
@@ -1072,20 +1047,30 @@ const getFullProject = (db, logger = defaultLogger) => async (params) => {
 			});
 			await Promise.all(agentPromises);
 		}
-		if (!project.models) throw new Error(`Project ${project.id} is missing required models configuration. Please update the project to include a base model.`);
+		const projectModels = project.models ?? {
+			base: { model: "claude-sonnet-4-5" },
+			structuredOutput: { model: "claude-sonnet-4-5" },
+			summarizer: { model: "claude-sonnet-4-5" }
+		};
+		if (!projectModels.base) logger.warn({
+			tenantId,
+			projectId
+		}, `Project ${project.id} is missing base model configuration. Using default: claude-sonnet-4-5`);
 		const fullProjectDefinition = {
 			id: project.id,
 			name: project.name,
 			description: project.description,
-			models: project.models,
-			stopWhen: project.stopWhen || void 0,
+			models: projectModels,
+			stopWhen: project.stopWhen ?? null,
 			agents,
 			tools: projectTools,
-			functions: projectFunctions,
-			externalAgents: projectExternalAgents,
-			dataComponents: projectDataComponents,
-			artifactComponents: projectArtifactComponents,
-			credentialReferences: projectCredentialReferences,
+			functions: Object.keys(projectFunctions).length > 0 ? projectFunctions : null,
+			externalAgents: Object.keys(projectExternalAgents).length > 0 ? projectExternalAgents : null,
+			dataComponents: Object.keys(projectDataComponents).length > 0 ? projectDataComponents : null,
+			artifactComponents: Object.keys(projectArtifactComponents).length > 0 ? projectArtifactComponents : null,
+			credentialReferences: Object.keys(projectCredentialReferences).length > 0 ? projectCredentialReferences : null,
+			statusUpdates: null,
+			functionTools: null,
 			createdAt: project.createdAt,
 			updatedAt: project.updatedAt
 		};
@@ -1104,6 +1089,20 @@ const getFullProject = (db, logger = defaultLogger) => async (params) => {
 		throw error;
 	}
 };
+const getFullProject = (db, logger = defaultLogger) => async (params) => {
+	const { scopes } = params;
+	return getFullProjectInternal(db, logger)({
+		scopes,
+		includeRelationIds: false
+	});
+};
+const getFullProjectWithRelationIds = (db, logger = defaultLogger) => async (params) => {
+	const { scopes } = params;
+	return getFullProjectInternal(db, logger)({
+		scopes,
+		includeRelationIds: true
+	});
+};
 /**
 * Delete a complete project and cascade to all related entities
 */
@@ -1192,4 +1191,4 @@ const deleteFullProject = (db, logger = defaultLogger) => async (params) => {
 };
 
 //#endregion
-export { createFullProjectServerSide, deleteFullProject, getFullProject, updateFullProjectServerSide };
+export { createFullProjectServerSide, deleteFullProject, getFullProject, getFullProjectWithRelationIds, updateFullProjectServerSide };

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

@@ -0,0 +1,119 @@
+import { PaginationConfig, PaginationResult, ProjectModels } from "../../types/utility.js";
+import { AgentsManageDatabaseClient } from "../../db/manage/manage-client.js";
+import { AgentsRunDatabaseClient } from "../../db/runtime/runtime-client.js";
+import { StopWhen } from "../../validation/schemas.js";
+import { ProjectMetadataSelect } from "../../types/entities.js";
+
+//#region src/data-access/manage/projectLifecycle.d.ts
+interface CreateProjectWithBranchParams {
+  tenantId: string;
+  projectId: string;
+  createdBy?: string;
+}
+interface CreateProjectWithBranchResult {
+  id: string;
+  tenantId: string;
+  mainBranchName: string;
+  createdAt: string;
+  createdBy: string | null;
+}
+interface DeleteProjectWithBranchParams {
+  tenantId: string;
+  projectId: string;
+}
+/**
+ * Generate the main branch name for a project
+ */
+declare function getProjectMainBranchName(tenantId: string, projectId: string): string;
+/**
+ * Create a project with its main branch
+ *
+ * This utility:
+ * 1. Creates the project record in the runtime DB (source of truth for existence)
+ * 2. Creates the project main branch in the config DB (Doltgres)
+ *
+ * @param runDb - Runtime database client (Postgres)
+ * @param configDb - Config database client (Doltgres)
+ */
+declare const createProjectMetadataAndBranch: (runDb: AgentsRunDatabaseClient, configDb: AgentsManageDatabaseClient) => (params: CreateProjectWithBranchParams) => Promise<CreateProjectWithBranchResult>;
+/**
+ * Delete a project and its branch
+ *
+ * This utility:
+ * 1. Gets the project from runtime DB to find the branch name
+ * 2. Deletes the project branch from config DB (Doltgres)
+ * 3. Deletes the project record from runtime DB
+ *
+ * Note: Callers should handle cascade deletion of runtime entities (conversations, etc.)
+ * before calling this function.
+ *
+ * @param runDb - Runtime database client (Postgres)
+ * @param configDb - Config database client (Doltgres)
+ */
+declare const deleteProjectWithBranch: (runDb: AgentsRunDatabaseClient, configDb: AgentsManageDatabaseClient) => (params: DeleteProjectWithBranchParams) => Promise<boolean>;
+/**
+ * Get project with branch info
+ *
+ * Returns the project from runtime DB including the main branch name
+ */
+declare const getProjectWithBranchInfo: (runDb: AgentsRunDatabaseClient) => (params: {
+  tenantId: string;
+  projectId: string;
+}) => Promise<ProjectMetadataSelect | null>;
+/**
+ * Project metadata from the versioned config DB
+ */
+interface ProjectConfigMetadata {
+  name: string;
+  description: string | null;
+  models: ProjectModels | null;
+  stopWhen: StopWhen | null;
+  createdAt: string;
+  updatedAt: string;
+}
+/**
+ * Combined project data from runtime + config DBs
+ */
+interface ProjectWithMetadata {
+  id: string;
+  tenantId: string;
+  createdAt: string;
+  createdBy: string | null;
+  mainBranchName: string;
+  name: string | null;
+  description: string | null;
+  models: ProjectModels | null;
+  stopWhen: StopWhen | null;
+  configUpdatedAt: string | null;
+}
+interface ListProjectsWithMetadataResult {
+  data: ProjectWithMetadata[];
+  pagination: PaginationResult;
+}
+/**
+ * List projects with metadata from both runtime and config DBs
+ *
+ * This function:
+ * 1. Gets the list of projects from runtime DB (source of truth for existence)
+ * 2. For each project, queries the config DB at the project's main branch to get metadata
+ *
+ * @param runDb - Runtime database client (Postgres)
+ * @param configDb - Config database client (Doltgres)
+ */
+declare const listProjectsWithMetadataPaginated: (runDb: AgentsRunDatabaseClient, configDb: AgentsManageDatabaseClient) => (params: {
+  tenantId: string;
+  pagination?: PaginationConfig;
+  projectIds?: string[];
+}) => Promise<ListProjectsWithMetadataResult>;
+/**
+ * Get a single project with metadata from both runtime and config DBs
+ *
+ * @param runDb - Runtime database client (Postgres)
+ * @param configDb - Config database client (Doltgres)
+ */
+declare const getProjectWithMetadata: (runDb: AgentsRunDatabaseClient, configDb: AgentsManageDatabaseClient) => (params: {
+  tenantId: string;
+  projectId: string;
+}) => Promise<ProjectWithMetadata | null>;
+//#endregion
+export { CreateProjectWithBranchParams, CreateProjectWithBranchResult, DeleteProjectWithBranchParams, ListProjectsWithMetadataResult, ProjectConfigMetadata, ProjectWithMetadata, createProjectMetadataAndBranch, deleteProjectWithBranch, getProjectMainBranchName, getProjectWithBranchInfo, getProjectWithMetadata, listProjectsWithMetadataPaginated };

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

@@ -0,0 +1,234 @@
+import { getLogger } from "../../utils/logger.js";
+import { doltBranch, doltBranchExists, doltCheckout, doltDeleteBranch } from "../../dolt/branch.js";
+import { createProjectMetadata, deleteProjectMetadata, getProjectMetadata, listProjectsMetadataPaginated } from "../runtime/projects.js";
+import { sql } from "drizzle-orm";
+
+//#region src/data-access/manage/projectLifecycle.ts
+const logger = getLogger("project-lifecycle");
+/**
+* Generate the main branch name for a project
+*/
+function getProjectMainBranchName(tenantId, projectId) {
+	return `${tenantId}_${projectId}_main`;
+}
+/**
+* Create a project with its main branch
+*
+* This utility:
+* 1. Creates the project record in the runtime DB (source of truth for existence)
+* 2. Creates the project main branch in the config DB (Doltgres)
+*
+* @param runDb - Runtime database client (Postgres)
+* @param configDb - Config database client (Doltgres)
+*/
+const createProjectMetadataAndBranch = (runDb, configDb) => async (params) => {
+	const { tenantId, projectId, createdBy } = params;
+	const mainBranchName = getProjectMainBranchName(tenantId, projectId);
+	logger.info({
+		tenantId,
+		projectId,
+		mainBranchName
+	}, "Creating project with branch");
+	const runtimeProject = await createProjectMetadata(runDb)({
+		id: projectId,
+		tenantId,
+		createdBy: createdBy ?? null,
+		mainBranchName
+	});
+	logger.debug({ projectId }, "Created project in runtime DB");
+	try {
+		if (!await doltBranchExists(configDb)({ name: mainBranchName })) {
+			await doltBranch(configDb)({ name: mainBranchName });
+			logger.debug({ mainBranchName }, "Created project main branch");
+		}
+	} catch (error) {
+		logger.error({
+			error,
+			mainBranchName
+		}, "Failed to create project branch, rolling back");
+		await deleteProjectMetadata(runDb)({
+			tenantId,
+			projectId
+		});
+		throw error;
+	}
+	logger.info({
+		tenantId,
+		projectId,
+		mainBranchName
+	}, "Successfully created project with branch");
+	return {
+		id: runtimeProject.id,
+		tenantId: runtimeProject.tenantId,
+		mainBranchName: runtimeProject.mainBranchName,
+		createdAt: runtimeProject.createdAt,
+		createdBy: runtimeProject.createdBy
+	};
+};
+/**
+* Delete a project and its branch
+*
+* This utility:
+* 1. Gets the project from runtime DB to find the branch name
+* 2. Deletes the project branch from config DB (Doltgres)
+* 3. Deletes the project record from runtime DB
+*
+* Note: Callers should handle cascade deletion of runtime entities (conversations, etc.)
+* before calling this function.
+*
+* @param runDb - Runtime database client (Postgres)
+* @param configDb - Config database client (Doltgres)
+*/
+const deleteProjectWithBranch = (runDb, configDb) => async (params) => {
+	const { tenantId, projectId } = params;
+	logger.info({
+		tenantId,
+		projectId
+	}, "Deleting project with branch");
+	const project = await getProjectMetadata(runDb)({
+		tenantId,
+		projectId
+	});
+	if (!project) {
+		logger.warn({
+			tenantId,
+			projectId
+		}, "Project not found in runtime DB");
+		return false;
+	}
+	const { mainBranchName } = project;
+	try {
+		await doltCheckout(configDb)({ branch: "main" });
+		await doltDeleteBranch(configDb)({
+			name: mainBranchName,
+			force: true
+		});
+		logger.info({ mainBranchName }, "Deleted project branch");
+	} catch (error) {
+		logger.error({
+			error,
+			mainBranchName
+		}, "Failed to delete project branch, continuing with runtime cleanup");
+	}
+	const deleted = await deleteProjectMetadata(runDb)({
+		tenantId,
+		projectId
+	});
+	if (deleted) logger.info({
+		tenantId,
+		projectId,
+		mainBranchName
+	}, "Successfully deleted project with branch");
+	else logger.warn({
+		tenantId,
+		projectId
+	}, "Failed to delete project from runtime DB");
+	return deleted;
+};
+/**
+* Get project with branch info
+*
+* Returns the project from runtime DB including the main branch name
+*/
+const getProjectWithBranchInfo = (runDb) => async (params) => {
+	return await getProjectMetadata(runDb)(params);
+};
+/**
+* Get project metadata from config DB at a specific branch using AS OF syntax
+*
+* This queries the projects table without checking out the branch
+*/
+async function getProjectMetadataFromBranch(configDb, branchName, tenantId, projectId) {
+	try {
+		const result = await configDb.execute(sql.raw(`
+        SELECT name, description, models, stop_when, created_at, updated_at
+        FROM projects AS OF '${branchName}'
+        WHERE tenant_id = '${tenantId}' AND id = '${projectId}'
+        LIMIT 1
+      `));
+		if (result.rows.length === 0) return null;
+		const row = result.rows[0];
+		return {
+			name: row.name,
+			description: row.description,
+			models: row.models,
+			stopWhen: row.stop_when,
+			createdAt: row.created_at,
+			updatedAt: row.updated_at
+		};
+	} catch (error) {
+		logger.warn({
+			error,
+			branchName,
+			tenantId,
+			projectId
+		}, "Failed to get project metadata from branch");
+		return null;
+	}
+}
+/**
+* List projects with metadata from both runtime and config DBs
+*
+* This function:
+* 1. Gets the list of projects from runtime DB (source of truth for existence)
+* 2. For each project, queries the config DB at the project's main branch to get metadata
+*
+* @param runDb - Runtime database client (Postgres)
+* @param configDb - Config database client (Doltgres)
+*/
+const listProjectsWithMetadataPaginated = (runDb, configDb) => async (params) => {
+	const { tenantId, pagination, projectIds } = params;
+	const projectMetadataResult = await listProjectsMetadataPaginated(runDb)({
+		tenantId,
+		pagination,
+		projectIds
+	});
+	return {
+		data: await Promise.all(projectMetadataResult.data.map(async (projectMetadata) => {
+			const metadata = await getProjectMetadataFromBranch(configDb, projectMetadata.mainBranchName, tenantId, projectMetadata.id);
+			return {
+				id: projectMetadata.id,
+				tenantId: projectMetadata.tenantId,
+				createdAt: projectMetadata.createdAt,
+				createdBy: projectMetadata.createdBy,
+				mainBranchName: projectMetadata.mainBranchName,
+				name: metadata?.name ?? null,
+				description: metadata?.description ?? null,
+				models: metadata?.models ?? null,
+				stopWhen: metadata?.stopWhen ?? null,
+				configUpdatedAt: metadata?.updatedAt ?? null
+			};
+		})),
+		pagination: projectMetadataResult.pagination
+	};
+};
+/**
+* Get a single project with metadata from both runtime and config DBs
+*
+* @param runDb - Runtime database client (Postgres)
+* @param configDb - Config database client (Doltgres)
+*/
+const getProjectWithMetadata = (runDb, configDb) => async (params) => {
+	const { tenantId, projectId } = params;
+	const runtimeProject = await getProjectMetadata(runDb)({
+		tenantId,
+		projectId
+	});
+	if (!runtimeProject) return null;
+	const metadata = await getProjectMetadataFromBranch(configDb, runtimeProject.mainBranchName, tenantId, projectId);
+	return {
+		id: runtimeProject.id,
+		tenantId: runtimeProject.tenantId,
+		createdAt: runtimeProject.createdAt,
+		createdBy: runtimeProject.createdBy,
+		mainBranchName: runtimeProject.mainBranchName,
+		name: metadata?.name ?? null,
+		description: metadata?.description ?? null,
+		models: metadata?.models ?? null,
+		stopWhen: metadata?.stopWhen ?? null,
+		configUpdatedAt: metadata?.updatedAt ?? null
+	};
+};
+
+//#endregion
+export { createProjectMetadataAndBranch, deleteProjectWithBranch, getProjectMainBranchName, getProjectWithBranchInfo, getProjectWithMetadata, listProjectsWithMetadataPaginated };

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

@@ -0,0 +1,75 @@
+import { PaginationConfig, PaginationResult, ProjectInfo, ProjectResourceCounts, ProjectScopeConfig } from "../../types/utility.js";
+import { AgentsManageDatabaseClient } from "../../db/manage/manage-client.js";
+import { ProjectInsert, ProjectSelect, ProjectUpdate } from "../../types/entities.js";
+
+//#region src/data-access/manage/projects.d.ts
+
+/**
+ * List all unique project IDs within a tenant by scanning all resource tables
+ * @param projectIds - Optional array of project IDs to filter by. If undefined, returns all projects.
+ */
+declare const listProjects: (db: AgentsManageDatabaseClient) => (params: {
+  tenantId: string;
+  projectIds?: string[];
+}) => Promise<ProjectInfo[]>;
+/**
+ * List all unique project IDs within a tenant with pagination
+ * Optionally filter by a list of project IDs (for access control)
+ */
+declare const listProjectsPaginated: (db: AgentsManageDatabaseClient) => (params: {
+  tenantId: string;
+  pagination?: PaginationConfig;
+  projectIds?: string[];
+}) => Promise<{
+  data: ProjectSelect[];
+  pagination: PaginationResult;
+}>;
+/**
+ * Get resource counts for a specific project
+ */
+declare const getProjectResourceCounts: (db: AgentsManageDatabaseClient) => (params: ProjectScopeConfig) => Promise<ProjectResourceCounts>;
+/**
+ * Check if a project exists (has any resources)
+ */
+declare const projectExists: (db: AgentsManageDatabaseClient) => (params: ProjectScopeConfig) => Promise<boolean>;
+/**
+ * Count total projects for a tenant
+ */
+declare const countProjects: (db: AgentsManageDatabaseClient) => (params: {
+  tenantId: string;
+}) => Promise<number>;
+/**
+ * Get a single project by ID
+ */
+declare const getProject: (db: AgentsManageDatabaseClient) => (params: {
+  scopes: ProjectScopeConfig;
+}) => Promise<ProjectSelect | null>;
+/**
+ * Create a new project
+ */
+declare const createProject: (db: AgentsManageDatabaseClient) => (params: ProjectInsert) => Promise<ProjectSelect>;
+/**
+ * Update an existing project
+ */
+declare const updateProject: (db: AgentsManageDatabaseClient) => (params: {
+  scopes: ProjectScopeConfig;
+  data: ProjectUpdate;
+}) => Promise<ProjectSelect | null>;
+/**
+ * Check if a project exists in the projects table
+ */
+declare const projectExistsInTable: (db: AgentsManageDatabaseClient) => (params: {
+  scopes: ProjectScopeConfig;
+}) => Promise<boolean>;
+/**
+ * Check if a project has any resources (used before deletion)
+ */
+declare const projectHasResources: (db: AgentsManageDatabaseClient) => (params: ProjectScopeConfig) => Promise<boolean>;
+/**
+ * Delete a project (with validation for existing resources)
+ */
+declare const deleteProject: (db: AgentsManageDatabaseClient) => (params: {
+  scopes: ProjectScopeConfig;
+}) => Promise<boolean>;
+//#endregion
+export { countProjects, createProject, deleteProject, getProject, getProjectResourceCounts, listProjects, listProjectsPaginated, projectExists, projectExistsInTable, projectHasResources, updateProject };