@inkeep/agents-core 0.41.2 → 0.43.0

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

@@ -1,9 +1,9 @@
-import { functionTools, subAgentFunctionToolRelations } from "../db/schema.js";
-import { getLogger } from "../utils/logger.js";
-import { generateId } from "../utils/conversations.js";
+import { functionTools, subAgentFunctionToolRelations } from "../../db/manage/manage-schema.js";
+import { getLogger } from "../../utils/logger.js";
+import { generateId } from "../../utils/conversations.js";
 import { and, count, desc, eq } from "drizzle-orm";
 
-//#region src/data-access/functionTools.ts
+//#region src/data-access/manage/functionTools.ts
 const logger = getLogger("functionTools");
 /**
 * Get a function tool by ID (agent-scoped)
@@ -96,32 +96,41 @@ const upsertFunctionTool = (db) => async (params) => {
 };
 const getFunctionToolsForSubAgent = (db) => {
 	return async (params) => {
-		const { scopes, subAgentId } = params;
-		const { tenantId, projectId, agentId } = scopes;
+		const page = params.pagination?.page || 1;
+		const limit = Math.min(params.pagination?.limit || 1e3, 1e3);
+		const offset = (page - 1) * limit;
+		const { tenantId, projectId, agentId } = params.scopes;
 		try {
-			const functionToolsList = await listFunctionTools(db)({
-				scopes: {
-					tenantId,
-					projectId,
-					agentId
-				},
+			const whereClause = and(eq(subAgentFunctionToolRelations.tenantId, tenantId), eq(subAgentFunctionToolRelations.projectId, projectId), eq(subAgentFunctionToolRelations.agentId, agentId), eq(subAgentFunctionToolRelations.subAgentId, params.subAgentId));
+			const [data, totalResult] = await Promise.all([db.select({
+				id: functionTools.id,
+				name: functionTools.name,
+				description: functionTools.description,
+				functionId: functionTools.functionId,
+				createdAt: functionTools.createdAt,
+				updatedAt: functionTools.updatedAt,
+				tenantId: functionTools.tenantId,
+				projectId: functionTools.projectId,
+				agentId: functionTools.agentId,
+				relationshipId: subAgentFunctionToolRelations.id,
+				toolPolicies: subAgentFunctionToolRelations.toolPolicies
+			}).from(subAgentFunctionToolRelations).innerJoin(functionTools, and(eq(subAgentFunctionToolRelations.functionToolId, functionTools.id), eq(subAgentFunctionToolRelations.tenantId, functionTools.tenantId), eq(subAgentFunctionToolRelations.projectId, functionTools.projectId), eq(subAgentFunctionToolRelations.agentId, functionTools.agentId))).where(whereClause).limit(limit).offset(offset).orderBy(desc(subAgentFunctionToolRelations.createdAt)), db.select({ count: count() }).from(subAgentFunctionToolRelations).where(whereClause)]);
+			const total = totalResult[0]?.count || 0;
+			return {
+				data,
 				pagination: {
-					page: 1,
-					limit: 1e3
+					page,
+					limit,
+					total,
+					pages: Math.ceil(total / limit)
 				}
-			});
-			const relations$1 = await db.select().from(subAgentFunctionToolRelations).where(and(eq(subAgentFunctionToolRelations.tenantId, tenantId), eq(subAgentFunctionToolRelations.projectId, projectId), eq(subAgentFunctionToolRelations.agentId, agentId), eq(subAgentFunctionToolRelations.subAgentId, subAgentId)));
-			const relatedFunctionToolIds = new Set(relations$1.map((r) => r.functionToolId));
-			return {
-				data: functionToolsList.data.filter((ft) => relatedFunctionToolIds.has(ft.id)),
-				pagination: functionToolsList.pagination
 			};
 		} catch (error) {
 			logger.error({
 				tenantId,
 				projectId,
 				agentId,
-				subAgentId,
+				subAgentId: params.subAgentId,
 				error
 			}, "Failed to get function tools for agent");
 			throw error;
@@ -132,14 +141,15 @@ const getFunctionToolsForSubAgent = (db) => {
 * Upsert a sub_agent-function tool relation (create if it doesn't exist, update if it does)
 */
 const upsertSubAgentFunctionToolRelation = (db) => async (params) => {
-	const { scopes, subAgentId, functionToolId, relationId } = params;
+	const { scopes, subAgentId, functionToolId, toolPolicies, relationId } = params;
 	const { tenantId, projectId, agentId } = scopes;
 	if (relationId) return await updateSubAgentFunctionToolRelation(db)({
 		scopes,
 		relationId,
 		data: {
 			subAgentId,
-			functionToolId
+			functionToolId,
+			...toolPolicies !== void 0 ? { toolPolicies } : {}
 		}
 	});
 	try {
@@ -173,18 +183,19 @@ const upsertSubAgentFunctionToolRelation = (db) => async (params) => {
 */
 const addFunctionToolToSubAgent = (db) => {
 	return async (params) => {
-		const { scopes, subAgentId, functionToolId } = params;
+		const { scopes, subAgentId, functionToolId, toolPolicies } = params;
 		const { tenantId, projectId, agentId } = scopes;
 		try {
 			const relationId = generateId();
-			await db.insert(subAgentFunctionToolRelations).values({
+			const [result] = await db.insert(subAgentFunctionToolRelations).values({
 				id: relationId,
 				tenantId,
 				projectId,
 				agentId,
 				subAgentId,
-				functionToolId
-			});
+				functionToolId,
+				...toolPolicies !== void 0 ? { toolPolicies } : {}
+			}).returning();
 			logger.info({
 				tenantId,
 				projectId,
@@ -193,7 +204,7 @@ const addFunctionToolToSubAgent = (db) => {
 				functionToolId,
 				relationId
 			}, "Function tool added to sub_agent");
-			return { id: relationId };
+			return result;
 		} catch (error) {
 			logger.error({
 				tenantId,
@@ -217,7 +228,8 @@ const updateSubAgentFunctionToolRelation = (db) => {
 		try {
 			await db.update(subAgentFunctionToolRelations).set({
 				subAgentId: data.subAgentId,
-				functionToolId: data.functionToolId
+				functionToolId: data.functionToolId,
+				...data.toolPolicies !== void 0 ? { toolPolicies: data.toolPolicies } : {}
 			}).where(and(eq(subAgentFunctionToolRelations.id, relationId), eq(subAgentFunctionToolRelations.tenantId, tenantId), eq(subAgentFunctionToolRelations.projectId, projectId), eq(subAgentFunctionToolRelations.agentId, agentId)));
 			logger.info({
 				tenantId,
@@ -240,6 +252,88 @@ const updateSubAgentFunctionToolRelation = (db) => {
 		}
 	};
 };
+/**
+* Get all sub-agents that use a specific function tool
+*/
+const getSubAgentsUsingFunctionTool = (db) => {
+	return async (params) => {
+		const { scopes, functionToolId } = params;
+		const { tenantId, projectId, agentId } = scopes;
+		try {
+			return await db.select({
+				subAgentId: subAgentFunctionToolRelations.subAgentId,
+				createdAt: subAgentFunctionToolRelations.createdAt
+			}).from(subAgentFunctionToolRelations).where(and(eq(subAgentFunctionToolRelations.tenantId, tenantId), eq(subAgentFunctionToolRelations.projectId, projectId), eq(subAgentFunctionToolRelations.agentId, agentId), eq(subAgentFunctionToolRelations.functionToolId, functionToolId)));
+		} catch (error) {
+			logger.error({
+				tenantId,
+				projectId,
+				agentId,
+				functionToolId,
+				error
+			}, "Failed to get sub-agents using function tool");
+			throw error;
+		}
+	};
+};
+/**
+* Remove a function tool from a sub-agent
+*/
+const removeFunctionToolFromSubAgent = (db) => {
+	return async (params) => {
+		const { scopes, subAgentId, functionToolId } = params;
+		const { tenantId, projectId, agentId } = scopes;
+		try {
+			const removed = (await db.delete(subAgentFunctionToolRelations).where(and(eq(subAgentFunctionToolRelations.tenantId, tenantId), eq(subAgentFunctionToolRelations.projectId, projectId), eq(subAgentFunctionToolRelations.agentId, agentId), eq(subAgentFunctionToolRelations.subAgentId, subAgentId), eq(subAgentFunctionToolRelations.functionToolId, functionToolId))).returning()).length > 0;
+			if (removed) logger.info({
+				tenantId,
+				projectId,
+				agentId,
+				subAgentId,
+				functionToolId
+			}, "Function tool removed from sub-agent");
+			return removed;
+		} catch (error) {
+			logger.error({
+				tenantId,
+				projectId,
+				agentId,
+				subAgentId,
+				functionToolId,
+				error
+			}, "Failed to remove function tool from sub-agent");
+			throw error;
+		}
+	};
+};
+/**
+* Check if a function tool is associated with a sub-agent
+*/
+const isFunctionToolAssociatedWithSubAgent = (db) => {
+	return async (params) => {
+		const { scopes, subAgentId, functionToolId } = params;
+		const { tenantId, projectId, agentId } = scopes;
+		try {
+			return (await db.select({ id: subAgentFunctionToolRelations.id }).from(subAgentFunctionToolRelations).where(and(eq(subAgentFunctionToolRelations.tenantId, tenantId), eq(subAgentFunctionToolRelations.projectId, projectId), eq(subAgentFunctionToolRelations.agentId, agentId), eq(subAgentFunctionToolRelations.subAgentId, subAgentId), eq(subAgentFunctionToolRelations.functionToolId, functionToolId))).limit(1)).length > 0;
+		} catch (error) {
+			logger.error({
+				tenantId,
+				projectId,
+				agentId,
+				subAgentId,
+				functionToolId,
+				error
+			}, "Failed to check function tool association with sub-agent");
+			throw error;
+		}
+	};
+};
+/**
+* Associate a function tool with a sub-agent (alias for addFunctionToolToSubAgent)
+*/
+const associateFunctionToolWithSubAgent = (db) => {
+	return addFunctionToolToSubAgent(db);
+};
 
 //#endregion
-export { addFunctionToolToSubAgent, createFunctionTool, deleteFunctionTool, getFunctionToolById, getFunctionToolsForSubAgent, listFunctionTools, updateFunctionTool, updateSubAgentFunctionToolRelation, upsertFunctionTool, upsertSubAgentFunctionToolRelation };
+export { addFunctionToolToSubAgent, associateFunctionToolWithSubAgent, createFunctionTool, deleteFunctionTool, getFunctionToolById, getFunctionToolsForSubAgent, getSubAgentsUsingFunctionTool, isFunctionToolAssociatedWithSubAgent, listFunctionTools, removeFunctionToolFromSubAgent, updateFunctionTool, updateSubAgentFunctionToolRelation, upsertFunctionTool, upsertSubAgentFunctionToolRelation };

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

@@ -1,33 +1,33 @@
-import { FunctionApiInsert } from "../types/entities.js";
-import { PaginationConfig, ProjectScopeConfig } from "../types/utility.js";
-import { DatabaseClient } from "../db/client.js";
+import { PaginationConfig, ProjectScopeConfig } from "../../types/utility.js";
+import { AgentsManageDatabaseClient } from "../../db/manage/manage-client.js";
+import { FunctionApiInsert } from "../../types/entities.js";
 
-//#region src/data-access/functions.d.ts
+//#region src/data-access/manage/functions.d.ts
 
 /**
  * Create or update a function (project-scoped)
  */
-declare const upsertFunction: (db: DatabaseClient) => (params: {
+declare const upsertFunction: (db: AgentsManageDatabaseClient) => (params: {
   data: FunctionApiInsert;
   scopes: ProjectScopeConfig;
 }) => Promise<void>;
 /**
  * Get a function by ID (project-scoped)
  */
-declare const getFunction: (db: DatabaseClient) => (params: {
+declare const getFunction: (db: AgentsManageDatabaseClient) => (params: {
   functionId: string;
   scopes: ProjectScopeConfig;
 }) => Promise<FunctionApiInsert | null>;
 /**
  * List all functions for a project
  */
-declare const listFunctions: (db: DatabaseClient) => (params: {
+declare const listFunctions: (db: AgentsManageDatabaseClient) => (params: {
   scopes: ProjectScopeConfig;
 }) => Promise<FunctionApiInsert[]>;
 /**
  * List all functions for a project with pagination
  */
-declare const listFunctionsPaginated: (db: DatabaseClient) => (params: {
+declare const listFunctionsPaginated: (db: AgentsManageDatabaseClient) => (params: {
   scopes: ProjectScopeConfig;
   pagination?: PaginationConfig;
 }) => Promise<{
@@ -51,7 +51,7 @@ declare const listFunctionsPaginated: (db: DatabaseClient) => (params: {
 /**
  * Delete a function (project-scoped)
  */
-declare const deleteFunction: (db: DatabaseClient) => (params: {
+declare const deleteFunction: (db: AgentsManageDatabaseClient) => (params: {
   functionId: string;
   scopes: ProjectScopeConfig;
 }) => Promise<void>;

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

@@ -1,7 +1,7 @@
-import { functions } from "../db/schema.js";
+import { functions } from "../../db/manage/manage-schema.js";
 import { and, count, desc, eq } from "drizzle-orm";
 
-//#region src/data-access/functions.ts
+//#region src/data-access/manage/functions.ts
 /**
 * Create or update a function (project-scoped)
 */
@@ -10,7 +10,7 @@ const upsertFunction = (db) => async (params) => {
 	const { tenantId, projectId } = scopes;
 	let dependencies = data.dependencies;
 	if (!dependencies || Object.keys(dependencies).length === 0) {
-		const { autoDetectDependencies } = await import("../utils/detectDependencies.js");
+		const { autoDetectDependencies } = await import("../../utils/detectDependencies.js");
 		dependencies = autoDetectDependencies(data.executeCode);
 	}
 	if ((await db.select().from(functions).where(and(eq(functions.tenantId, tenantId), eq(functions.projectId, projectId), eq(functions.id, data.id))).limit(1)).length > 0) await db.update(functions).set({

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

@@ -0,0 +1,38 @@
+import { ProjectScopeConfig } from "../../types/utility.js";
+import { getLogger } from "../../utils/logger.js";
+import { AgentsManageDatabaseClient } from "../../db/manage/manage-client.js";
+import { FullProjectDefinition, FullProjectSelect, FullProjectSelectWithRelationIds } from "../../types/entities.js";
+
+//#region src/data-access/manage/projectFull.d.ts
+
+type ProjectLogger = ReturnType<typeof getLogger>;
+/**
+ * Server-side implementation of createFullProject that performs actual database operations.
+ * This function creates a complete project with all agent and their nested resources.
+ */
+declare const createFullProjectServerSide: (db: AgentsManageDatabaseClient, logger?: ProjectLogger) => (params: {
+  scopes: ProjectScopeConfig;
+  projectData: FullProjectDefinition;
+}) => Promise<FullProjectSelect>;
+/**
+ * Server-side implementation of updateFullProject that performs actual database operations.
+ * This function updates a complete project with all agent and their nested resources.
+ */
+declare const updateFullProjectServerSide: (db: AgentsManageDatabaseClient, logger?: ProjectLogger) => (params: {
+  scopes: ProjectScopeConfig;
+  projectData: FullProjectDefinition;
+}) => Promise<FullProjectSelect>;
+declare const getFullProject: (db: AgentsManageDatabaseClient, logger?: ProjectLogger) => (params: {
+  scopes: ProjectScopeConfig;
+}) => Promise<FullProjectSelect | null>;
+declare const getFullProjectWithRelationIds: (db: AgentsManageDatabaseClient, logger?: ProjectLogger) => (params: {
+  scopes: ProjectScopeConfig;
+}) => Promise<FullProjectSelectWithRelationIds | null>;
+/**
+ * Delete a complete project and cascade to all related entities
+ */
+declare const deleteFullProject: (db: AgentsManageDatabaseClient, logger?: ProjectLogger) => (params: {
+  scopes: ProjectScopeConfig;
+}) => Promise<boolean>;
+//#endregion
+export { ProjectLogger, createFullProjectServerSide, deleteFullProject, getFullProject, getFullProjectWithRelationIds, updateFullProjectServerSide };

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 };