@inkeep/agents-core 0.1.10 → 0.2.1

package/dist/index.cjs

@@ -1510,7 +1510,7 @@ var FullGraphAgentInsertSchema = AgentApiInsertSchema.extend({
 var FullGraphDefinitionSchema = AgentGraphApiInsertSchema.extend({
   agents: zodOpenapi.z.record(zodOpenapi.z.string(), zodOpenapi.z.union([FullGraphAgentInsertSchema, ExternalAgentApiInsertSchema])),
   tools: zodOpenapi.z.record(zodOpenapi.z.string(), ToolApiInsertSchema).optional(),
-  credentialReferences: zodOpenapi.z.array(CredentialReferenceApiInsertSchema).optional(),
+  credentialReferences: zodOpenapi.z.record(zodOpenapi.z.string(), CredentialReferenceApiInsertSchema).optional(),
   dataComponents: zodOpenapi.z.record(zodOpenapi.z.string(), DataComponentApiInsertSchema).optional(),
   artifactComponents: zodOpenapi.z.record(zodOpenapi.z.string(), ArtifactComponentApiInsertSchema).optional(),
   contextConfig: zodOpenapi.z.optional(ContextConfigApiInsertSchema),
@@ -1569,7 +1569,7 @@ var FullProjectDefinitionSchema = ProjectApiInsertSchema.extend({
   artifactComponents: zodOpenapi.z.record(zodOpenapi.z.string(), ArtifactComponentApiInsertSchema).optional(),
   contextConfig: zodOpenapi.z.record(zodOpenapi.z.string(), ContextConfigApiInsertSchema).optional(),
   statusUpdates: zodOpenapi.z.optional(StatusUpdateSchema),
-  credentialReferences: zodOpenapi.z.array(CredentialReferenceApiInsertSchema).optional(),
+  credentialReferences: zodOpenapi.z.record(zodOpenapi.z.string(), CredentialReferenceApiInsertSchema).optional(),
   createdAt: zodOpenapi.z.string().optional(),
   updatedAt: zodOpenapi.z.string().optional()
 });
@@ -5267,33 +5267,35 @@ var createFullGraphServerSide = (db, logger11 = defaultLogger) => async (scopes,
   validateGraphStructure(typed);
   await applyExecutionLimitsInheritance(db, logger11, { tenantId, projectId }, typed);
   try {
-    if (typed.credentialReferences) {
+    if (typed.credentialReferences && Object.keys(typed.credentialReferences).length > 0) {
       logger11.info(
-        { credentialReferencesCount: typed.credentialReferences.length },
+        { credentialReferencesCount: Object.keys(typed.credentialReferences).length },
         "Processing credential references"
       );
-      const credentialRefPromises = typed.credentialReferences.map(async (credData) => {
-        try {
-          logger11.info({ credId: credData.id }, "Processing credential reference");
-          await upsertCredentialReference(db)({
-            data: {
-              ...credData,
-              tenantId,
-              projectId
-            }
-          });
-          logger11.info({ credId: credData.id }, "Credential reference processed successfully");
-        } catch (error) {
-          logger11.error(
-            { credId: credData.id, error },
-            "Failed to create/update credential reference"
-          );
-          throw error;
+      const credentialRefPromises = Object.entries(typed.credentialReferences).map(
+        async ([_credId, credData]) => {
+          try {
+            logger11.info({ credId: credData.id }, "Processing credential reference");
+            await upsertCredentialReference(db)({
+              data: {
+                ...credData,
+                tenantId,
+                projectId
+              }
+            });
+            logger11.info({ credId: credData.id }, "Credential reference processed successfully");
+          } catch (error) {
+            logger11.error(
+              { credId: credData.id, error },
+              "Failed to create/update credential reference"
+            );
+            throw error;
+          }
         }
-      });
+      );
       await Promise.all(credentialRefPromises);
       logger11.info(
-        { credentialReferencesCount: typed.credentialReferences.length },
+        { credentialReferencesCount: Object.keys(typed.credentialReferences).length },
         "All credential references created/updated successfully"
       );
     }
@@ -5698,13 +5700,15 @@ var updateFullGraphServerSide = (db, logger11 = defaultLogger) => async (scopes,
       return createFullGraphServerSide(db)(scopes, graphData);
     }
     const existingGraphModels = existingGraph.models;
-    if (typedGraphDefinition.credentialReferences) {
+    if (typedGraphDefinition.credentialReferences && Object.keys(typedGraphDefinition.credentialReferences).length > 0) {
       logger11.info(
-        { credentialReferencesCount: typedGraphDefinition.credentialReferences.length },
+        {
+          credentialReferencesCount: Object.keys(typedGraphDefinition.credentialReferences).length
+        },
         "Processing credential references"
       );
-      const credentialRefPromises = typedGraphDefinition.credentialReferences.map(
-        async (credData) => {
+      const credentialRefPromises = Object.entries(typedGraphDefinition.credentialReferences).map(
+        async ([_credId, credData]) => {
           try {
             logger11.info({ credId: credData.id }, "Processing credential reference");
             await upsertCredentialReference(db)({
@@ -5726,7 +5730,9 @@ var updateFullGraphServerSide = (db, logger11 = defaultLogger) => async (scopes,
       );
       await Promise.all(credentialRefPromises);
       logger11.info(
-        { credentialReferencesCount: typedGraphDefinition.credentialReferences.length },
+        {
+          credentialReferencesCount: Object.keys(typedGraphDefinition.credentialReferences).length
+        },
         "All credential references created/updated successfully"
       );
     }
@@ -6667,6 +6673,213 @@ var createFullProjectServerSide = (db, logger11 = defaultLogger2) => async (scop
     logger11.info({ projectId: typed.id }, "Creating project metadata");
     await createProject(db)(projectPayload);
     logger11.info({ projectId: typed.id }, "Project metadata created successfully");
+    if (typed.credentialReferences && Object.keys(typed.credentialReferences).length > 0) {
+      logger11.info(
+        {
+          projectId: typed.id,
+          count: Object.keys(typed.credentialReferences).length
+        },
+        "Creating project credentialReferences"
+      );
+      const credentialPromises = Object.entries(typed.credentialReferences).map(
+        async ([_credId, credData]) => {
+          try {
+            logger11.info(
+              { projectId: typed.id, credId: credData.id },
+              "Creating credentialReference in project"
+            );
+            await upsertCredentialReference(db)({
+              data: {
+                ...credData,
+                tenantId,
+                projectId: typed.id
+              }
+            });
+            logger11.info(
+              { projectId: typed.id, credId: credData.id },
+              "CredentialReference created successfully"
+            );
+          } catch (error) {
+            logger11.error(
+              { projectId: typed.id, credId: credData.id, error },
+              "Failed to create credentialReference in project"
+            );
+            throw error;
+          }
+        }
+      );
+      await Promise.all(credentialPromises);
+      logger11.info(
+        {
+          projectId: typed.id,
+          count: Object.keys(typed.credentialReferences).length
+        },
+        "All project credentialReferences created successfully"
+      );
+    }
+    if (typed.tools && Object.keys(typed.tools).length > 0) {
+      logger11.info(
+        {
+          projectId: typed.id,
+          toolCount: Object.keys(typed.tools).length
+        },
+        "Creating project tools"
+      );
+      const toolPromises = Object.entries(typed.tools).map(async ([toolId, toolData]) => {
+        try {
+          logger11.info({ projectId: typed.id, toolId }, "Creating tool in project");
+          await upsertTool(db)({
+            data: {
+              tenantId,
+              projectId: typed.id,
+              ...toolData
+            }
+          });
+          logger11.info({ projectId: typed.id, toolId }, "Tool created successfully");
+        } catch (error) {
+          logger11.error(
+            { projectId: typed.id, toolId, error },
+            "Failed to create tool in project"
+          );
+          throw error;
+        }
+      });
+      await Promise.all(toolPromises);
+      logger11.info(
+        {
+          projectId: typed.id,
+          toolCount: Object.keys(typed.tools).length
+        },
+        "All project tools created successfully"
+      );
+    }
+    if (typed.contextConfig && Object.keys(typed.contextConfig).length > 0) {
+      logger11.info(
+        {
+          projectId: typed.id,
+          count: Object.keys(typed.contextConfig).length
+        },
+        "Creating project contextConfigs"
+      );
+      const contextConfigPromises = Object.entries(typed.contextConfig).map(
+        async ([configId, configData]) => {
+          try {
+            logger11.info({ projectId: typed.id, configId }, "Creating contextConfig in project");
+            await upsertContextConfig(db)({
+              data: {
+                ...configData,
+                tenantId,
+                projectId: typed.id
+              }
+            });
+            logger11.info({ projectId: typed.id, configId }, "ContextConfig created successfully");
+          } catch (error) {
+            logger11.error(
+              { projectId: typed.id, configId, error },
+              "Failed to create contextConfig in project"
+            );
+            throw error;
+          }
+        }
+      );
+      await Promise.all(contextConfigPromises);
+      logger11.info(
+        {
+          projectId: typed.id,
+          count: Object.keys(typed.contextConfig).length
+        },
+        "All project contextConfigs created successfully"
+      );
+    }
+    if (typed.dataComponents && Object.keys(typed.dataComponents).length > 0) {
+      logger11.info(
+        {
+          projectId: typed.id,
+          count: Object.keys(typed.dataComponents).length
+        },
+        "Creating project dataComponents"
+      );
+      const dataComponentPromises = Object.entries(typed.dataComponents).map(
+        async ([componentId, componentData]) => {
+          try {
+            logger11.info(
+              { projectId: typed.id, componentId },
+              "Creating dataComponent in project"
+            );
+            await upsertDataComponent(db)({
+              data: {
+                ...componentData,
+                tenantId,
+                projectId: typed.id
+              }
+            });
+            logger11.info(
+              { projectId: typed.id, componentId },
+              "DataComponent created successfully"
+            );
+          } catch (error) {
+            logger11.error(
+              { projectId: typed.id, componentId, error },
+              "Failed to create dataComponent in project"
+            );
+            throw error;
+          }
+        }
+      );
+      await Promise.all(dataComponentPromises);
+      logger11.info(
+        {
+          projectId: typed.id,
+          count: Object.keys(typed.dataComponents).length
+        },
+        "All project dataComponents created successfully"
+      );
+    }
+    if (typed.artifactComponents && Object.keys(typed.artifactComponents).length > 0) {
+      logger11.info(
+        {
+          projectId: typed.id,
+          count: Object.keys(typed.artifactComponents).length
+        },
+        "Creating project artifactComponents"
+      );
+      const artifactComponentPromises = Object.entries(typed.artifactComponents).map(
+        async ([componentId, componentData]) => {
+          try {
+            logger11.info(
+              { projectId: typed.id, componentId },
+              "Creating artifactComponent in project"
+            );
+            await upsertArtifactComponent(db)({
+              data: {
+                id: componentId,
+                ...componentData,
+                tenantId,
+                projectId: typed.id
+              }
+            });
+            logger11.info(
+              { projectId: typed.id, componentId },
+              "ArtifactComponent created successfully"
+            );
+          } catch (error) {
+            logger11.error(
+              { projectId: typed.id, componentId, error },
+              "Failed to create artifactComponent in project"
+            );
+            throw error;
+          }
+        }
+      );
+      await Promise.all(artifactComponentPromises);
+      logger11.info(
+        {
+          projectId: typed.id,
+          count: Object.keys(typed.artifactComponents).length
+        },
+        "All project artifactComponents created successfully"
+      );
+    }
     if (typed.graphs && Object.keys(typed.graphs).length > 0) {
       logger11.info(
         {
@@ -6678,13 +6891,19 @@ var createFullProjectServerSide = (db, logger11 = defaultLogger2) => async (scop
       const graphPromises = Object.entries(typed.graphs).map(async ([graphId, graphData]) => {
         try {
           logger11.info({ projectId: typed.id, graphId }, "Creating graph in project");
-          const graphDataWithUndefined = {
+          const graphDataWithProjectResources = {
             ...graphData,
+            tools: typed.tools || {},
+            // Pass project-level resources for validation
+            dataComponents: typed.dataComponents || {},
+            artifactComponents: typed.artifactComponents || {},
+            contextConfig: typed.contextConfig?.[graphId] || void 0,
+            credentialReferences: typed.credentialReferences || {},
             statusUpdates: graphData.statusUpdates === null ? void 0 : graphData.statusUpdates
           };
           await createFullGraphServerSide(db, logger11)(
             { tenantId, projectId: typed.id },
-            graphDataWithUndefined
+            graphDataWithProjectResources
           );
           logger11.info({ projectId: typed.id, graphId }, "Graph created successfully in project");
         } catch (error) {
@@ -6761,6 +6980,213 @@ var updateFullProjectServerSide = (db, logger11 = defaultLogger2) => async (scop
       data: projectUpdatePayload
     });
     logger11.info({ projectId: typed.id }, "Project metadata updated successfully");
+    if (typed.credentialReferences && Object.keys(typed.credentialReferences).length > 0) {
+      logger11.info(
+        {
+          projectId: typed.id,
+          count: Object.keys(typed.credentialReferences).length
+        },
+        "Updating project credentialReferences"
+      );
+      const credentialPromises = Object.entries(typed.credentialReferences).map(
+        async ([_credId, credData]) => {
+          try {
+            logger11.info(
+              { projectId: typed.id, credId: credData.id },
+              "Updating credentialReference in project"
+            );
+            await upsertCredentialReference(db)({
+              data: {
+                ...credData,
+                tenantId,
+                projectId: typed.id
+              }
+            });
+            logger11.info(
+              { projectId: typed.id, credId: credData.id },
+              "CredentialReference updated successfully"
+            );
+          } catch (error) {
+            logger11.error(
+              { projectId: typed.id, credId: credData.id, error },
+              "Failed to update credentialReference in project"
+            );
+            throw error;
+          }
+        }
+      );
+      await Promise.all(credentialPromises);
+      logger11.info(
+        {
+          projectId: typed.id,
+          count: Object.keys(typed.credentialReferences).length
+        },
+        "All project credentialReferences updated successfully"
+      );
+    }
+    if (typed.tools && Object.keys(typed.tools).length > 0) {
+      logger11.info(
+        {
+          projectId: typed.id,
+          toolCount: Object.keys(typed.tools).length
+        },
+        "Updating project tools"
+      );
+      const toolPromises = Object.entries(typed.tools).map(async ([toolId, toolData]) => {
+        try {
+          logger11.info({ projectId: typed.id, toolId }, "Updating tool in project");
+          await upsertTool(db)({
+            data: {
+              tenantId,
+              projectId: typed.id,
+              ...toolData
+            }
+          });
+          logger11.info({ projectId: typed.id, toolId }, "Tool updated successfully");
+        } catch (error) {
+          logger11.error(
+            { projectId: typed.id, toolId, error },
+            "Failed to update tool in project"
+          );
+          throw error;
+        }
+      });
+      await Promise.all(toolPromises);
+      logger11.info(
+        {
+          projectId: typed.id,
+          toolCount: Object.keys(typed.tools).length
+        },
+        "All project tools updated successfully"
+      );
+    }
+    if (typed.contextConfig && Object.keys(typed.contextConfig).length > 0) {
+      logger11.info(
+        {
+          projectId: typed.id,
+          count: Object.keys(typed.contextConfig).length
+        },
+        "Updating project contextConfigs"
+      );
+      const contextConfigPromises = Object.entries(typed.contextConfig).map(
+        async ([configId, configData]) => {
+          try {
+            logger11.info({ projectId: typed.id, configId }, "Updating contextConfig in project");
+            await upsertContextConfig(db)({
+              data: {
+                ...configData,
+                tenantId,
+                projectId: typed.id
+              }
+            });
+            logger11.info({ projectId: typed.id, configId }, "ContextConfig updated successfully");
+          } catch (error) {
+            logger11.error(
+              { projectId: typed.id, configId, error },
+              "Failed to update contextConfig in project"
+            );
+            throw error;
+          }
+        }
+      );
+      await Promise.all(contextConfigPromises);
+      logger11.info(
+        {
+          projectId: typed.id,
+          count: Object.keys(typed.contextConfig).length
+        },
+        "All project contextConfigs updated successfully"
+      );
+    }
+    if (typed.dataComponents && Object.keys(typed.dataComponents).length > 0) {
+      logger11.info(
+        {
+          projectId: typed.id,
+          count: Object.keys(typed.dataComponents).length
+        },
+        "Updating project dataComponents"
+      );
+      const dataComponentPromises = Object.entries(typed.dataComponents).map(
+        async ([componentId, componentData]) => {
+          try {
+            logger11.info(
+              { projectId: typed.id, componentId },
+              "Updating dataComponent in project"
+            );
+            await upsertDataComponent(db)({
+              data: {
+                ...componentData,
+                tenantId,
+                projectId: typed.id
+              }
+            });
+            logger11.info(
+              { projectId: typed.id, componentId },
+              "DataComponent updated successfully"
+            );
+          } catch (error) {
+            logger11.error(
+              { projectId: typed.id, componentId, error },
+              "Failed to update dataComponent in project"
+            );
+            throw error;
+          }
+        }
+      );
+      await Promise.all(dataComponentPromises);
+      logger11.info(
+        {
+          projectId: typed.id,
+          count: Object.keys(typed.dataComponents).length
+        },
+        "All project dataComponents updated successfully"
+      );
+    }
+    if (typed.artifactComponents && Object.keys(typed.artifactComponents).length > 0) {
+      logger11.info(
+        {
+          projectId: typed.id,
+          count: Object.keys(typed.artifactComponents).length
+        },
+        "Updating project artifactComponents"
+      );
+      const artifactComponentPromises = Object.entries(typed.artifactComponents).map(
+        async ([componentId, componentData]) => {
+          try {
+            logger11.info(
+              { projectId: typed.id, componentId },
+              "Updating artifactComponent in project"
+            );
+            await upsertArtifactComponent(db)({
+              data: {
+                id: componentId,
+                ...componentData,
+                tenantId,
+                projectId: typed.id
+              }
+            });
+            logger11.info(
+              { projectId: typed.id, componentId },
+              "ArtifactComponent updated successfully"
+            );
+          } catch (error) {
+            logger11.error(
+              { projectId: typed.id, componentId, error },
+              "Failed to update artifactComponent in project"
+            );
+            throw error;
+          }
+        }
+      );
+      await Promise.all(artifactComponentPromises);
+      logger11.info(
+        {
+          projectId: typed.id,
+          count: Object.keys(typed.artifactComponents).length
+        },
+        "All project artifactComponents updated successfully"
+      );
+    }
     if (typed.graphs && Object.keys(typed.graphs).length > 0) {
       logger11.info(
         {
@@ -6772,13 +7198,19 @@ var updateFullProjectServerSide = (db, logger11 = defaultLogger2) => async (scop
       const graphPromises = Object.entries(typed.graphs).map(async ([graphId, graphData]) => {
         try {
           logger11.info({ projectId: typed.id, graphId }, "Updating graph in project");
-          const graphDataWithUndefined = {
+          const graphDataWithProjectResources = {
             ...graphData,
+            tools: typed.tools || {},
+            // Pass project-level resources for validation
+            dataComponents: typed.dataComponents || {},
+            artifactComponents: typed.artifactComponents || {},
+            contextConfig: typed.contextConfig?.[graphId] || void 0,
+            credentialReferences: typed.credentialReferences || {},
             statusUpdates: graphData.statusUpdates === null ? void 0 : graphData.statusUpdates
           };
           await updateFullGraphServerSide(db, logger11)(
             { tenantId, projectId: typed.id },
-            graphDataWithUndefined
+            graphDataWithProjectResources
           );
           logger11.info({ projectId: typed.id, graphId }, "Graph updated successfully in project");
         } catch (error) {
@@ -6842,6 +7274,129 @@ var getFullProject = (db, logger11 = defaultLogger2) => async (params) => {
       },
       "Found graphs for project"
     );
+    const projectTools = {};
+    try {
+      const toolsList = await listTools(db)({
+        scopes: { tenantId, projectId },
+        pagination: { page: 1, limit: 1e3 }
+        // Get all tools
+      });
+      for (const tool2 of toolsList.data) {
+        projectTools[tool2.id] = {
+          id: tool2.id,
+          name: tool2.name,
+          config: tool2.config,
+          imageUrl: tool2.imageUrl || void 0,
+          status: tool2.status,
+          capabilities: tool2.capabilities || void 0,
+          lastHealthCheck: tool2.lastHealthCheck && !Number.isNaN(new Date(tool2.lastHealthCheck).getTime()) ? new Date(tool2.lastHealthCheck).toISOString() : void 0,
+          lastError: tool2.lastError || void 0,
+          availableTools: tool2.availableTools || void 0,
+          activeTools: tool2.config?.mcp?.activeTools || void 0,
+          lastToolsSync: tool2.lastToolsSync && !Number.isNaN(new Date(tool2.lastToolsSync).getTime()) ? new Date(tool2.lastToolsSync).toISOString() : void 0
+        };
+      }
+      logger11.info(
+        { tenantId, projectId, toolCount: Object.keys(projectTools).length },
+        "Tools retrieved for project"
+      );
+    } catch (error) {
+      logger11.warn({ tenantId, projectId, error }, "Failed to retrieve tools for project");
+    }
+    const projectDataComponents = {};
+    try {
+      const dataComponentsList = await listDataComponents(db)({
+        scopes: { tenantId, projectId }
+      });
+      for (const component of dataComponentsList) {
+        projectDataComponents[component.id] = {
+          id: component.id,
+          name: component.name,
+          description: component.description,
+          props: component.props
+        };
+      }
+      logger11.info(
+        { tenantId, projectId, count: Object.keys(projectDataComponents).length },
+        "DataComponents retrieved for project"
+      );
+    } catch (error) {
+      logger11.warn(
+        { tenantId, projectId, error },
+        "Failed to retrieve dataComponents for project"
+      );
+    }
+    const projectArtifactComponents = {};
+    try {
+      const artifactComponentsList = await listArtifactComponents(db)({
+        scopes: { tenantId, projectId }
+      });
+      for (const component of artifactComponentsList) {
+        projectArtifactComponents[component.id] = {
+          id: component.id,
+          name: component.name,
+          description: component.description,
+          summaryProps: component.summaryProps,
+          fullProps: component.fullProps
+        };
+      }
+      logger11.info(
+        { tenantId, projectId, count: Object.keys(projectArtifactComponents).length },
+        "ArtifactComponents retrieved for project"
+      );
+    } catch (error) {
+      logger11.warn(
+        { tenantId, projectId, error },
+        "Failed to retrieve artifactComponents for project"
+      );
+    }
+    const projectContextConfigs = {};
+    try {
+      const contextConfigsList = await listContextConfigs(db)({
+        scopes: { tenantId, projectId }
+      });
+      for (const config of contextConfigsList) {
+        projectContextConfigs[config.id] = {
+          id: config.id,
+          name: config.name,
+          description: config.description,
+          requestContextSchema: config.requestContextSchema,
+          contextVariables: config.contextVariables
+        };
+      }
+      logger11.info(
+        { tenantId, projectId, count: Object.keys(projectContextConfigs).length },
+        "ContextConfigs retrieved for project"
+      );
+    } catch (error) {
+      logger11.warn(
+        { tenantId, projectId, error },
+        "Failed to retrieve contextConfigs for project"
+      );
+    }
+    const projectCredentialReferences = {};
+    try {
+      const credentialReferencesList = await listCredentialReferences(db)({
+        scopes: { tenantId, projectId }
+      });
+      for (const credential of credentialReferencesList) {
+        projectCredentialReferences[credential.id] = {
+          id: credential.id,
+          type: credential.type,
+          credentialStoreId: credential.credentialStoreId,
+          retrievalParams: credential.retrievalParams
+        };
+      }
+      logger11.info(
+        { tenantId, projectId, count: Object.keys(projectCredentialReferences).length },
+        "CredentialReferences retrieved for project"
+      );
+    } catch (error) {
+      logger11.warn(
+        { tenantId, projectId, error },
+        "Failed to retrieve credentialReferences for project"
+      );
+    }
     const graphs = {};
     if (graphList.length > 0) {
       const graphPromises = graphList.map(async (graph) => {
@@ -6855,7 +7410,15 @@ var getFullProject = (db, logger11 = defaultLogger2) => async (params) => {
             graphId: graph.id
           });
           if (fullGraph) {
-            graphs[graph.id] = fullGraph;
+            const {
+              tools: _tools,
+              dataComponents: _dataComponents,
+              artifactComponents: _artifactComponents,
+              contextConfig: _contextConfig,
+              credentialReferences: _credentialReferences,
+              ...graphWithoutProjectResources
+            } = fullGraph;
+            graphs[graph.id] = graphWithoutProjectResources;
             logger11.info(
               { tenantId, projectId, graphId: graph.id },
               "Full graph definition retrieved"
@@ -6879,8 +7442,11 @@ var getFullProject = (db, logger11 = defaultLogger2) => async (params) => {
       models: project.models || void 0,
       stopWhen: project.stopWhen || void 0,
       graphs,
-      tools: {},
-      // TODO: Implement proper tools retrieval
+      tools: projectTools,
+      dataComponents: projectDataComponents,
+      artifactComponents: projectArtifactComponents,
+      contextConfig: projectContextConfigs,
+      credentialReferences: projectCredentialReferences,
       createdAt: project.createdAt,
       updatedAt: project.updatedAt
     };
@@ -9382,11 +9948,11 @@ var NangoCredentialStore = class {
     switch (type) {
       case "API_KEY":
         return {
-          token: credentials.apiKey
+          token: credentials.apiKey || credentials.api_key
         };
       case "APP":
         return {
-          token: credentials.access_token
+          token: credentials.accessToken || credentials.access_token
         };
       case "BASIC":
         return {