@inkeep/agents-core 0.8.7 → 0.10.1

package/dist/index.cjs

@@ -1638,6 +1638,7 @@ var StatusUpdateSchema = zodOpenapi.z.object({
   statusComponents: zodOpenapi.z.array(StatusComponentSchema).optional()
 });
 var CanUseItemSchema = zodOpenapi.z.object({
+  agentToolRelationId: zodOpenapi.z.string().optional(),
   toolId: zodOpenapi.z.string(),
   toolSelection: zodOpenapi.z.array(zodOpenapi.z.string()).nullish(),
   headers: zodOpenapi.z.record(zodOpenapi.z.string(), zodOpenapi.z.string()).nullish()
@@ -3696,7 +3697,8 @@ var getFullGraphDefinition = (db) => async ({
         projectId: tools.projectId,
         imageUrl: tools.imageUrl,
         selectedTools: agentToolRelations.selectedTools,
-        headers: agentToolRelations.headers
+        headers: agentToolRelations.headers,
+        agentToolRelationId: agentToolRelations.id
       }).from(agentToolRelations).innerJoin(
         tools,
         drizzleOrm.and(
@@ -3729,6 +3731,7 @@ var getFullGraphDefinition = (db) => async ({
         (rel) => rel.artifactComponentId
       );
       const canUse = agentTools.map((tool2) => ({
+        agentToolRelationId: tool2.agentToolRelationId,
         toolId: tool2.id,
         toolSelection: tool2.selectedTools || null,
         headers: tool2.headers || null
@@ -6060,28 +6063,19 @@ var removeToolFromAgent = (db) => async (params) => {
   return deleted;
 };
 var upsertAgentToolRelation = (db) => async (params) => {
-  const existing = await db.query.agentToolRelations.findFirst({
-    where: drizzleOrm.and(
-      drizzleOrm.eq(agentToolRelations.tenantId, params.scopes.tenantId),
-      drizzleOrm.eq(agentToolRelations.projectId, params.scopes.projectId),
-      drizzleOrm.eq(agentToolRelations.graphId, params.scopes.graphId),
-      drizzleOrm.eq(agentToolRelations.agentId, params.agentId),
-      drizzleOrm.eq(agentToolRelations.toolId, params.toolId)
-    )
-  });
-  if (!existing) {
-    return await addToolToAgent(db)(params);
+  if (params.relationId) {
+    return await updateAgentToolRelation(db)({
+      scopes: params.scopes,
+      relationId: params.relationId,
+      data: {
+        agentId: params.agentId,
+        toolId: params.toolId,
+        selectedTools: params.selectedTools,
+        headers: params.headers
+      }
+    });
   }
-  return await updateAgentToolRelation(db)({
-    scopes: params.scopes,
-    relationId: existing.id,
-    data: {
-      agentId: params.agentId,
-      toolId: params.toolId,
-      selectedTools: params.selectedTools,
-      headers: params.headers
-    }
-  });
+  return await addToolToAgent(db)(params);
 };
 var upsertTool = (db) => async (params) => {
   const scopes = { tenantId: params.data.tenantId, projectId: params.data.projectId };
@@ -6340,14 +6334,15 @@ var createFullGraphServerSide = (db, logger12 = defaultLogger) => async (scopes,
           agentToolPromises.push(
             (async () => {
               try {
-                const { toolId, toolSelection, headers } = canUseItem;
+                const { toolId, toolSelection, headers, agentToolRelationId } = canUseItem;
                 logger12.info({ agentId, toolId }, "Processing agent-tool relation");
                 await upsertAgentToolRelation(db)({
                   scopes: { tenantId, projectId, graphId: finalGraphId },
                   agentId,
                   toolId,
                   selectedTools: toolSelection || void 0,
-                  headers: headers || void 0
+                  headers: headers || void 0,
+                  relationId: agentToolRelationId
                 });
                 logger12.info({ agentId, toolId }, "Agent-tool relation processed successfully");
               } catch (error) {
@@ -6711,6 +6706,53 @@ var updateFullGraphServerSide = (db, logger12 = defaultLogger) => async (scopes,
       ([_, agentData]) => isExternalAgent(agentData)
     ).length;
     logger12.info({ externalAgentCount }, "All external agents created/updated successfully");
+    const incomingAgentIds = new Set(Object.keys(typedGraphDefinition.agents));
+    const existingInternalAgents = await listAgents(db)({
+      scopes: { tenantId, projectId, graphId: finalGraphId }
+    });
+    const existingExternalAgents = await listExternalAgents(db)({
+      scopes: { tenantId, projectId, graphId: finalGraphId }
+    });
+    let deletedInternalCount = 0;
+    for (const agent of existingInternalAgents) {
+      if (!incomingAgentIds.has(agent.id)) {
+        try {
+          await deleteAgent(db)({
+            scopes: { tenantId, projectId, graphId: finalGraphId },
+            agentId: agent.id
+          });
+          deletedInternalCount++;
+          logger12.info({ agentId: agent.id }, "Deleted orphaned internal agent");
+        } catch (error) {
+          logger12.error({ agentId: agent.id, error }, "Failed to delete orphaned internal agent");
+        }
+      }
+    }
+    let deletedExternalCount = 0;
+    for (const agent of existingExternalAgents) {
+      if (!incomingAgentIds.has(agent.id)) {
+        try {
+          await deleteExternalAgent(db)({
+            scopes: { tenantId, projectId, graphId: finalGraphId },
+            agentId: agent.id
+          });
+          deletedExternalCount++;
+          logger12.info({ agentId: agent.id }, "Deleted orphaned external agent");
+        } catch (error) {
+          logger12.error({ agentId: agent.id, error }, "Failed to delete orphaned external agent");
+        }
+      }
+    }
+    if (deletedInternalCount > 0 || deletedExternalCount > 0) {
+      logger12.info(
+        {
+          deletedInternalCount,
+          deletedExternalCount,
+          totalDeleted: deletedInternalCount + deletedExternalCount
+        },
+        "Deleted orphaned agents from graph"
+      );
+    }
     await updateAgentGraph(db)({
       scopes: { tenantId, projectId, graphId: typedGraphDefinition.id },
       data: {
@@ -6725,10 +6767,47 @@ var updateFullGraphServerSide = (db, logger12 = defaultLogger) => async (scopes,
       }
     });
     logger12.info({ graphId: typedGraphDefinition.id }, "Graph metadata updated");
+    const incomingRelationshipIds = /* @__PURE__ */ new Set();
+    for (const [_agentId, agentData] of Object.entries(typedGraphDefinition.agents)) {
+      if (isInternalAgent(agentData) && agentData.canUse && Array.isArray(agentData.canUse)) {
+        for (const canUseItem of agentData.canUse) {
+          if (canUseItem.agentToolRelationId) {
+            incomingRelationshipIds.add(canUseItem.agentToolRelationId);
+          }
+        }
+      }
+    }
     for (const agentId of Object.keys(typedGraphDefinition.agents)) {
-      await deleteAgentToolRelationByAgent(db)({
-        scopes: { tenantId, projectId, graphId: finalGraphId, agentId }
-      });
+      try {
+        let deletedCount = 0;
+        if (incomingRelationshipIds.size === 0) {
+          const result = await db.delete(agentToolRelations).where(
+            drizzleOrm.and(
+              drizzleOrm.eq(agentToolRelations.tenantId, tenantId),
+              drizzleOrm.eq(agentToolRelations.projectId, projectId),
+              drizzleOrm.eq(agentToolRelations.graphId, finalGraphId),
+              drizzleOrm.eq(agentToolRelations.agentId, agentId)
+            )
+          );
+          deletedCount = result.rowsAffected || 0;
+        } else {
+          const result = await db.delete(agentToolRelations).where(
+            drizzleOrm.and(
+              drizzleOrm.eq(agentToolRelations.tenantId, tenantId),
+              drizzleOrm.eq(agentToolRelations.projectId, projectId),
+              drizzleOrm.eq(agentToolRelations.graphId, finalGraphId),
+              drizzleOrm.eq(agentToolRelations.agentId, agentId),
+              drizzleOrm.not(drizzleOrm.inArray(agentToolRelations.id, Array.from(incomingRelationshipIds)))
+            )
+          );
+          deletedCount = result.rowsAffected || 0;
+        }
+        if (deletedCount > 0) {
+          logger12.info({ agentId, deletedCount }, "Deleted orphaned agent-tool relations");
+        }
+      } catch (error) {
+        logger12.error({ agentId, error }, "Failed to delete orphaned agent-tool relations");
+      }
     }
     const agentToolPromises = [];
     for (const [agentId, agentData] of Object.entries(typedGraphDefinition.agents)) {
@@ -6737,21 +6816,28 @@ var updateFullGraphServerSide = (db, logger12 = defaultLogger) => async (scopes,
           agentToolPromises.push(
             (async () => {
               try {
-                const { toolId, toolSelection, headers } = canUseItem;
-                await createAgentToolRelation(db)({
+                const { toolId, toolSelection, headers, agentToolRelationId } = canUseItem;
+                await upsertAgentToolRelation(db)({
                   scopes: { tenantId, projectId, graphId: finalGraphId },
-                  data: {
-                    agentId,
-                    toolId,
-                    selectedTools: toolSelection || void 0,
-                    headers: headers || void 0
-                  }
+                  agentId,
+                  toolId,
+                  selectedTools: toolSelection || void 0,
+                  headers: headers || void 0,
+                  relationId: agentToolRelationId
                 });
-                logger12.info({ agentId, toolId }, "Agent-tool relation created");
+                logger12.info(
+                  { agentId, toolId, relationId: agentToolRelationId },
+                  "Agent-tool relation upserted"
+                );
               } catch (error) {
                 logger12.error(
-                  { agentId, toolId: canUseItem.toolId, error },
-                  "Failed to create agent-tool relation"
+                  {
+                    agentId,
+                    toolId: canUseItem.toolId,
+                    relationId: canUseItem.agentToolRelationId,
+                    error
+                  },
+                  "Failed to upsert agent-tool relation"
                 );
               }
             })()
@@ -8115,6 +8201,36 @@ var updateFullProjectServerSide = (db, logger12 = defaultLogger2) => async (scop
         "All project artifactComponents updated successfully"
       );
     }
+    const incomingGraphIds = new Set(Object.keys(typed.graphs || {}));
+    const existingGraphs = await listAgentGraphs(db)({
+      scopes: { tenantId, projectId: typed.id }
+    });
+    let deletedGraphCount = 0;
+    for (const graph of existingGraphs) {
+      if (!incomingGraphIds.has(graph.id)) {
+        try {
+          await deleteFullGraph(db, logger12)({
+            scopes: { tenantId, projectId: typed.id, graphId: graph.id }
+          });
+          deletedGraphCount++;
+          logger12.info({ graphId: graph.id }, "Deleted orphaned graph from project");
+        } catch (error) {
+          logger12.error(
+            { graphId: graph.id, error },
+            "Failed to delete orphaned graph from project"
+          );
+        }
+      }
+    }
+    if (deletedGraphCount > 0) {
+      logger12.info(
+        {
+          deletedGraphCount,
+          projectId: typed.id
+        },
+        "Deleted orphaned graphs from project"
+      );
+    }
     if (typed.graphs && Object.keys(typed.graphs).length > 0) {
       logger12.info(
         {
@@ -8930,7 +9046,42 @@ var ContextResolver = class {
    * Resolve a single context variable
    */
   async resolveSingleFetchDefinition(contextConfig2, definition, templateKey, options, requestHash, result) {
-    return tracer.startActiveSpan(
+    const cachedEntry = await this.cache.get({
+      conversationId: options.conversationId,
+      contextConfigId: contextConfig2.id,
+      contextVariableKey: templateKey,
+      requestHash
+    });
+    if (cachedEntry) {
+      result.resolvedContext[templateKey] = cachedEntry.value;
+      result.cacheHits.push(definition.id);
+      logger7.debug(
+        {
+          definitionId: definition.id,
+          templateKey,
+          conversationId: options.conversationId
+        },
+        "Cache hit for context variable"
+      );
+      return;
+    }
+    result.cacheMisses.push(definition.id);
+    logger7.debug(
+      {
+        definitionId: definition.id,
+        templateKey,
+        conversationId: options.conversationId
+      },
+      "Cache miss for context variable, fetching data"
+    );
+    const definitionWithConversationId = {
+      ...definition,
+      fetchConfig: {
+        ...definition.fetchConfig,
+        conversationId: options.conversationId
+      }
+    };
+    const fetchedData = await tracer.startActiveSpan(
       "context-resolver.resolve_single_fetch_definition",
       {
         attributes: {
@@ -8943,78 +9094,17 @@ var ContextResolver = class {
       },
       async (parentSpan) => {
         try {
-          const cachedEntry = await this.cache.get({
-            conversationId: options.conversationId,
-            contextConfigId: contextConfig2.id,
-            contextVariableKey: templateKey,
-            requestHash
-          });
-          if (cachedEntry) {
-            result.resolvedContext[templateKey] = cachedEntry.value;
-            result.cacheHits.push(definition.id);
-            parentSpan.setStatus({ code: api.SpanStatusCode.OK });
-            parentSpan.addEvent("context.cache_hit", {
-              definition_id: definition.id,
-              template_key: templateKey
-            });
-            logger7.debug(
-              {
-                definitionId: definition.id,
-                templateKey,
-                conversationId: options.conversationId
-              },
-              "Cache hit for context variable"
-            );
-            return;
-          }
-          result.cacheMisses.push(definition.id);
-          parentSpan.addEvent("context.cache_miss", {
-            definition_id: definition.id,
-            template_key: templateKey
-          });
-          logger7.debug(
-            {
-              definitionId: definition.id,
-              templateKey,
-              conversationId: options.conversationId
-            },
-            "Cache miss for context variable, fetching data"
-          );
-          const definitionWithConversationId = {
-            ...definition,
-            fetchConfig: {
-              ...definition.fetchConfig,
-              conversationId: options.conversationId
-            }
-          };
-          const fetchedData = await this.fetcher.fetch(
+          const data = await this.fetcher.fetch(
             definitionWithConversationId,
             result.resolvedContext
           );
-          result.resolvedContext[templateKey] = fetchedData;
-          result.fetchedDefinitions.push(definition.id);
-          await this.cache.set({
-            contextConfigId: contextConfig2.id,
-            contextVariableKey: templateKey,
-            conversationId: options.conversationId,
-            value: fetchedData,
-            requestHash,
-            tenantId: this.tenantId
-          });
           parentSpan.setStatus({ code: api.SpanStatusCode.OK });
           parentSpan.addEvent("context.fetch_success", {
             definition_id: definition.id,
             template_key: templateKey,
             source: definition.fetchConfig.url
           });
-          logger7.debug(
-            {
-              definitionId: definition.id,
-              templateKey,
-              conversationId: options.conversationId
-            },
-            "Context variable resolved and cached"
-          );
+          return data;
         } catch (error) {
           setSpanWithError(parentSpan, error);
           throw error;
@@ -9023,6 +9113,24 @@ var ContextResolver = class {
         }
       }
     );
+    result.resolvedContext[templateKey] = fetchedData;
+    result.fetchedDefinitions.push(definition.id);
+    await this.cache.set({
+      contextConfigId: contextConfig2.id,
+      contextVariableKey: templateKey,
+      conversationId: options.conversationId,
+      value: fetchedData,
+      requestHash,
+      tenantId: this.tenantId
+    });
+    logger7.debug(
+      {
+        definitionId: definition.id,
+        templateKey,
+        conversationId: options.conversationId
+      },
+      "Context variable resolved and cached"
+    );
   }
   /**
    * Resolve the request context for a given conversation
@@ -10290,14 +10398,31 @@ var NangoCredentialStore = class {
     if (!isSupportedAuthMode(type)) {
       return null;
     }
+    const extractAccessTokenForBearerType = (tokenString) => {
+      if (tokenString && typeof tokenString === "string") {
+        try {
+          const parsedToken = JSON.parse(tokenString);
+          if (parsedToken.access_token && typeof parsedToken.access_token === "string") {
+            return parsedToken.access_token;
+          }
+        } catch {
+        }
+        return tokenString;
+      }
+      return void 0;
+    };
     switch (type) {
       case "API_KEY":
         return {
-          token: credentials.apiKey || credentials.api_key
+          token: extractAccessTokenForBearerType(
+            credentials.apiKey || credentials.api_key
+          )
         };
       case "APP":
         return {
-          token: credentials.accessToken || credentials.access_token
+          token: extractAccessTokenForBearerType(
+            credentials.accessToken || credentials.access_token
+          )
         };
       case "BASIC":
         return {
@@ -10308,7 +10433,7 @@ var NangoCredentialStore = class {
         return credentials.raw;
       case "JWT":
         return {
-          token: credentials.token
+          token: extractAccessTokenForBearerType(credentials.token)
         };
       case "OAUTH1":
         return {
@@ -10317,12 +10442,12 @@ var NangoCredentialStore = class {
         };
       case "OAUTH2":
         return {
-          token: credentials.access_token,
+          token: extractAccessTokenForBearerType(credentials.access_token),
           refresh_token: credentials.refresh_token
         };
       case "OAUTH2_CC":
         return {
-          token: credentials.token,
+          token: extractAccessTokenForBearerType(credentials.token),
           client_certificate: credentials.client_certificate,
           client_id: credentials.client_id,
           client_private_key: credentials.client_private_key,
@@ -10348,6 +10473,104 @@ var NangoCredentialStore = class {
     }
     return result;
   }
+  /**
+   * Fetch a specific Nango integration
+   */
+  async fetchNangoIntegration(uniqueKey) {
+    try {
+      const response = await this.nangoClient.getIntegration(
+        { uniqueKey },
+        { include: ["credentials"] }
+      );
+      const integration = response.data;
+      let areCredentialsSet = false;
+      if (integration.credentials?.type === "OAUTH2" || integration.credentials?.type === "OAUTH1" || integration.credentials?.type === "TBA") {
+        areCredentialsSet = !!(integration.credentials?.client_id && integration.credentials?.client_secret);
+      } else if (integration.credentials?.type === "APP") {
+        areCredentialsSet = !!(integration.credentials?.app_id && integration.credentials?.app_link);
+      } else {
+        areCredentialsSet = true;
+      }
+      const { credentials: _credentials, ...integrationWithoutCredentials } = integration;
+      return {
+        ...integrationWithoutCredentials,
+        areCredentialsSet
+      };
+    } catch (error) {
+      if (error && typeof error === "object" && "status" in error && error.status === 404) {
+        return null;
+      }
+      console.error(`Failed to fetch integration ${uniqueKey}:`, error);
+      return null;
+    }
+  }
+  /**
+   * Create an API key credential by setting up Nango integration and importing the connection
+   */
+  async createNangoApiKeyConnection({
+    name,
+    apiKeyToSet,
+    metadata
+  }) {
+    const provider = "private-api-bearer";
+    try {
+      let integration;
+      try {
+        const response2 = await this.nangoClient.createIntegration({
+          provider,
+          unique_key: name,
+          display_name: name
+        });
+        integration = response2.data;
+      } catch (error) {
+        const existingIntegration = await this.fetchNangoIntegration(name);
+        if (existingIntegration) {
+          integration = existingIntegration;
+        } else {
+          console.log(`Integration creation failed for unexpected reasons`, error);
+        }
+      }
+      if (!integration) {
+        throw new Error(`Integration '${name}' not found`);
+      }
+      const importConnectionUrl = `${process.env.NANGO_SERVER_URL || "https://api.nango.dev"}/connections`;
+      const credentials = {
+        type: "API_KEY",
+        apiKey: apiKeyToSet
+      };
+      const body = {
+        provider_config_key: integration.unique_key,
+        connection_id: name,
+        metadata,
+        credentials
+      };
+      const response = await fetch(importConnectionUrl, {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${process.env.NANGO_SECRET_KEY}`,
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify(body)
+      });
+      if (!response.ok) {
+        throw new Error(
+          `Failed to import connection: HTTP ${response.status} - ${response.statusText}`
+        );
+      }
+    } catch (error) {
+      console.error("Unexpected error creating API key credential:", error);
+      logger11.error(
+        {
+          error: error instanceof Error ? error.message : "Unknown error",
+          name
+        },
+        `Unexpected error creating API key credential '${name}'`
+      );
+      throw new Error(
+        `Failed to create API key credential '${name}': ${error instanceof Error ? error.message : "Unknown error"}`
+      );
+    }
+  }
   /**
    * Fetch credentials from Nango API using connection information
    * @param connectionId - The connection ID for the Nango connection
@@ -10437,8 +10660,12 @@ var NangoCredentialStore = class {
   /**
    * Set credentials - not supported for Nango (OAuth flow handles this)
    */
-  async set(_key, _value) {
-    throw new Error("Setting credentials not supported for Nango store - use OAuth flow instead");
+  async set(key, value) {
+    await this.createNangoApiKeyConnection({
+      name: key,
+      apiKeyToSet: value,
+      metadata: {}
+    });
   }
   /**
    * Check if credentials exist by attempting to fetch them
@@ -10532,7 +10759,16 @@ function createDefaultCredentialStores() {
       })
     );
   }
-  stores.push(createKeyChainStore("keychain-default"));
+  if (process.env.ENABLE_KEYCHAIN_STORE === "true") {
+    try {
+      stores.push(createKeyChainStore("keychain-default"));
+    } catch (error) {
+      console.warn(
+        "Failed to create keychain store:",
+        error instanceof Error ? error.message : error
+      );
+    }
+  }
   return stores;
 }
 var loadEnvironmentFiles = () => {
@@ -10852,7 +11088,6 @@ exports.createExternalAgentRelation = createExternalAgentRelation;
 exports.createFullGraphServerSide = createFullGraphServerSide;
 exports.createFullProjectServerSide = createFullProjectServerSide;
 exports.createInMemoryDatabaseClient = createInMemoryDatabaseClient;
-exports.createKeyChainStore = createKeyChainStore;
 exports.createMessage = createMessage;
 exports.createNangoCredentialStore = createNangoCredentialStore;
 exports.createOrGetConversation = createOrGetConversation;