@inkeep/agents-sdk 0.0.0-dev-20250911175803 → 0.0.0-dev-20250911195722

package/dist/index.cjs

@@ -4,165 +4,8 @@ var agentsCore = require('@inkeep/agents-core');
 var zod = require('zod');
 
 var __defProp = Object.defineProperty;
-var __getOwnPropNames = Object.getOwnPropertyNames;
 var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __esm = (fn, res) => function __init() {
-  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
-};
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
 var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-
-// src/tool.ts
-var tool_exports = {};
-__export(tool_exports, {
-  Tool: () => exports.Tool
-});
-var logger3; exports.Tool = void 0;
-var init_tool = __esm({
-  "src/tool.ts"() {
-    logger3 = agentsCore.getLogger("tool");
-    exports.Tool = class {
-      constructor(config) {
-        __publicField(this, "config");
-        __publicField(this, "baseURL");
-        __publicField(this, "tenantId");
-        __publicField(this, "initialized", false);
-        __publicField(this, "projectId");
-        this.config = config;
-        this.baseURL = process.env.INKEEP_API_URL || "http://localhost:3002";
-        this.tenantId = config.tenantId || "default";
-        this.projectId = config.projectId || "default";
-        logger3.info(
-          {
-            Id: this.getId(),
-            Name: config.name
-          },
-          "Tool constructor initialized"
-        );
-      }
-      // Compute ID from name using same slug transformation as agents
-      getId() {
-        return this.config.id;
-      }
-      getName() {
-        return this.config.name;
-      }
-      getDescription() {
-        return this.config.description || "";
-      }
-      getServerUrl() {
-        return this.config.serverUrl;
-      }
-      getActiveTools() {
-        return this.config.activeTools;
-      }
-      getCredentialReferenceId() {
-        return this.config.credential?.id;
-      }
-      // Public method to ensure tool exists in backend (with upsert behavior)
-      async init(options) {
-        if (this.initialized) return;
-        try {
-          if (!options?.skipDatabaseRegistration) {
-            await this.upsertTool();
-          }
-          logger3.info(
-            {
-              toolId: this.getId()
-            },
-            "Tool initialized successfully"
-          );
-          this.initialized = true;
-        } catch (error) {
-          logger3.error(
-            {
-              toolId: this.getId(),
-              error: error instanceof Error ? error.message : "Unknown error"
-            },
-            "Failed to initialize tool"
-          );
-          throw error;
-        }
-      }
-      // Private method to upsert tool (create or update)
-      async upsertTool() {
-        const toolDataForUpdate = {
-          id: this.getId(),
-          name: this.config.name,
-          credentialReferenceId: this.config.credential?.id ?? null,
-          headers: this.config.headers ?? null,
-          imageUrl: this.config.imageUrl,
-          config: {
-            type: "mcp",
-            mcp: {
-              server: {
-                url: this.config.serverUrl
-              },
-              transport: this.config.transport,
-              activeTools: this.config.activeTools
-            }
-          }
-        };
-        const toolDataForCreate = {
-          ...toolDataForUpdate
-        };
-        logger3.info({ toolDataForCreate }, "toolDataForCreate");
-        const updateResponse = await fetch(
-          `${this.baseURL}/tenants/${this.tenantId}/crud/projects/${this.projectId}/tools/${this.getId()}`,
-          {
-            method: "PUT",
-            headers: {
-              "Content-Type": "application/json"
-            },
-            body: JSON.stringify(toolDataForUpdate)
-          }
-        );
-        logger3.info({ updateResponse }, "tool updateResponse");
-        if (updateResponse.ok) {
-          logger3.info(
-            {
-              toolId: this.getId()
-            },
-            "Tool updated successfully"
-          );
-          return;
-        }
-        if (updateResponse.status === 404) {
-          logger3.info(
-            {
-              toolId: this.getId()
-            },
-            "Tool not found, creating new tool"
-          );
-          const createResponse = await fetch(
-            `${this.baseURL}/tenants/${this.tenantId}/crud/projects/${this.projectId}/tools`,
-            {
-              method: "POST",
-              headers: {
-                "Content-Type": "application/json"
-              },
-              body: JSON.stringify(toolDataForCreate)
-            }
-          );
-          if (!createResponse.ok) {
-            throw new Error(`Failed to create tool: ${createResponse.status}`);
-          }
-          logger3.info(
-            {
-              toolId: this.getId()
-            },
-            "Tool created successfully"
-          );
-          return;
-        }
-        throw new Error(`Failed to update tool: ${updateResponse.status}`);
-      }
-    };
-  }
-});
 var logger = agentsCore.getLogger("artifactComponent");
 var ArtifactComponent = class {
   constructor(config) {
@@ -440,6 +283,144 @@ var DataComponent = class {
     );
   }
 };
+var logger3 = agentsCore.getLogger("tool");
+var Tool = class {
+  constructor(config) {
+    __publicField(this, "config");
+    __publicField(this, "baseURL");
+    __publicField(this, "tenantId");
+    __publicField(this, "initialized", false);
+    __publicField(this, "projectId");
+    this.config = config;
+    this.baseURL = process.env.INKEEP_API_URL || "http://localhost:3002";
+    this.tenantId = config.tenantId || "default";
+    this.projectId = config.projectId || "default";
+    logger3.info(
+      {
+        Id: this.getId(),
+        Name: config.name
+      },
+      "Tool constructor initialized"
+    );
+  }
+  // Compute ID from name using same slug transformation as agents
+  getId() {
+    return this.config.id;
+  }
+  getName() {
+    return this.config.name;
+  }
+  getDescription() {
+    return this.config.description || "";
+  }
+  getServerUrl() {
+    return this.config.serverUrl;
+  }
+  getActiveTools() {
+    return this.config.activeTools;
+  }
+  getCredentialReferenceId() {
+    return this.config.credential?.id;
+  }
+  // Public method to ensure tool exists in backend (with upsert behavior)
+  async init(options) {
+    if (this.initialized) return;
+    try {
+      if (!options?.skipDatabaseRegistration) {
+        await this.upsertTool();
+      }
+      logger3.info(
+        {
+          toolId: this.getId()
+        },
+        "Tool initialized successfully"
+      );
+      this.initialized = true;
+    } catch (error) {
+      logger3.error(
+        {
+          toolId: this.getId(),
+          error: error instanceof Error ? error.message : "Unknown error"
+        },
+        "Failed to initialize tool"
+      );
+      throw error;
+    }
+  }
+  // Private method to upsert tool (create or update)
+  async upsertTool() {
+    const toolDataForUpdate = {
+      id: this.getId(),
+      name: this.config.name,
+      credentialReferenceId: this.config.credential?.id ?? null,
+      headers: this.config.headers ?? null,
+      imageUrl: this.config.imageUrl,
+      config: {
+        type: "mcp",
+        mcp: {
+          server: {
+            url: this.config.serverUrl
+          },
+          transport: this.config.transport,
+          activeTools: this.config.activeTools
+        }
+      }
+    };
+    const toolDataForCreate = {
+      ...toolDataForUpdate
+    };
+    logger3.info({ toolDataForCreate }, "toolDataForCreate");
+    const updateResponse = await fetch(
+      `${this.baseURL}/tenants/${this.tenantId}/crud/projects/${this.projectId}/tools/${this.getId()}`,
+      {
+        method: "PUT",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify(toolDataForUpdate)
+      }
+    );
+    logger3.info({ updateResponse }, "tool updateResponse");
+    if (updateResponse.ok) {
+      logger3.info(
+        {
+          toolId: this.getId()
+        },
+        "Tool updated successfully"
+      );
+      return;
+    }
+    if (updateResponse.status === 404) {
+      logger3.info(
+        {
+          toolId: this.getId()
+        },
+        "Tool not found, creating new tool"
+      );
+      const createResponse = await fetch(
+        `${this.baseURL}/tenants/${this.tenantId}/crud/projects/${this.projectId}/tools`,
+        {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json"
+          },
+          body: JSON.stringify(toolDataForCreate)
+        }
+      );
+      if (!createResponse.ok) {
+        throw new Error(`Failed to create tool: ${createResponse.status}`);
+      }
+      logger3.info(
+        {
+          toolId: this.getId()
+        },
+        "Tool created successfully"
+      );
+      return;
+    }
+    throw new Error(`Failed to update tool: ${updateResponse.status}`);
+  }
+};
 
 // src/agent.ts
 var logger4 = agentsCore.getLogger("agent");
@@ -481,8 +462,9 @@ var Agent = class {
   getInstructions() {
     return this.config.prompt;
   }
+  // adjust
   getTools() {
-    const tools = resolveGetter(this.config.tools);
+    const tools = resolveGetter(this.config.canUse);
     if (!tools) {
       return {};
     }
@@ -492,9 +474,19 @@ var Agent = class {
     const toolRecord = {};
     for (const tool of tools) {
       if (tool && typeof tool === "object") {
-        const id = tool.id || tool.getId?.() || tool.name;
+        let id;
+        let toolInstance;
+        if ("server" in tool && "selectedTools" in tool) {
+          const agentMcpConfig = tool;
+          id = agentMcpConfig.server.getId();
+          toolInstance = agentMcpConfig.server;
+          toolInstance.selectedTools = agentMcpConfig.selectedTools;
+        } else {
+          id = tool.id || tool.getId?.() || tool.name;
+          toolInstance = tool;
+        }
         if (id) {
-          toolRecord[id] = tool;
+          toolRecord[id] = toolInstance;
         }
       }
     }
@@ -518,9 +510,10 @@ var Agent = class {
   getArtifactComponents() {
     return resolveGetter(this.config.artifactComponents) || [];
   }
+  // adjust
   addTool(_name, tool) {
-    const existingTools = this.config.tools ? this.config.tools() : [];
-    this.config.tools = () => [...existingTools, tool];
+    const existingTools = this.config.canUse ? this.config.canUse() : [];
+    this.config.canUse = () => [...existingTools, tool];
   }
   addTransfer(...agents) {
     if (typeof this.config.canTransferTo === "function") {
@@ -633,18 +626,32 @@ var Agent = class {
     );
   }
   async saveToolsAndRelations() {
-    logger4.info(
-      {
-        transfers: this.getTransfers(),
-        delegates: this.getDelegates(),
-        tools: this.config.tools
-      },
-      "transfers, delegates, and tools"
-    );
-    if (this.config.tools) {
-      logger4.info({ tools: this.config.tools }, "tools and config");
-      for (const [toolId, toolConfig] of Object.entries(this.config.tools)) {
-        await this.createTool(toolId, toolConfig);
+    if (this.config.canUse) {
+      const tools = resolveGetter(this.config.canUse);
+      if (tools && Array.isArray(tools)) {
+        for (let i = 0; i < tools.length; i++) {
+          const toolConfig = tools[i];
+          let toolId;
+          if (toolConfig instanceof Tool) {
+            toolId = toolConfig.getId();
+          } else if (toolConfig && typeof toolConfig === "object" && "server" in toolConfig) {
+            toolId = toolConfig.server.getId();
+          } else {
+            toolId = `tool-${i}`;
+          }
+          try {
+            await this.createTool(toolId, toolConfig);
+          } catch (error) {
+            logger4.error(
+              {
+                toolId,
+                error: error instanceof Error ? error.message : "Unknown error"
+              },
+              "Tool creation failed"
+            );
+            throw error;
+          }
+        }
       }
     }
   }
@@ -767,36 +774,24 @@ var Agent = class {
         logger4.info(
           {
             agentId: this.getId(),
-            toolId,
-            toolType: "function"
+            toolId
           },
           "Skipping function tool creation - will be handled at runtime"
         );
         return;
       }
-      const { Tool: Tool2 } = await Promise.resolve().then(() => (init_tool(), tool_exports));
       let tool;
-      if (toolConfig instanceof Tool2) {
-        logger4.info(
-          {
-            agentId: this.getId(),
-            toolId,
-            toolType: "Tool"
-          },
-          "Initializing Tool instance"
-        );
+      let selectedTools;
+      if (toolConfig && typeof toolConfig === "object" && "server" in toolConfig && "selectedTools" in toolConfig) {
+        const mcpConfig = toolConfig;
+        tool = mcpConfig.server;
+        selectedTools = mcpConfig.selectedTools;
+        await tool.init();
+      } else if (toolConfig instanceof Tool) {
         tool = toolConfig;
         await tool.init();
       } else {
-        logger4.info(
-          {
-            agentId: this.getId(),
-            toolId,
-            toolType: "legacy-config"
-          },
-          "Creating Tool from config"
-        );
-        tool = new Tool2({
+        tool = new Tool({
           id: toolId,
           tenantId: this.tenantId,
           name: toolConfig.name || toolId,
@@ -807,7 +802,7 @@ var Agent = class {
         });
         await tool.init();
       }
-      await this.createAgentToolRelation(tool.getId());
+      await this.createAgentToolRelation(tool.getId(), selectedTools);
       logger4.info(
         {
           agentId: this.getId(),
@@ -824,6 +819,7 @@ var Agent = class {
         },
         "Failed to create tool"
       );
+      throw error;
     }
   }
   async createDataComponent(dataComponent2) {
@@ -945,20 +941,25 @@ var Agent = class {
       "Created agent-artifactComponent relation"
     );
   }
-  async createAgentToolRelation(toolId) {
+  async createAgentToolRelation(toolId, selectedTools) {
+    const relationData = {
+      id: `${this.getId()}-tool-${toolId}`,
+      tenantId: this.tenantId,
+      projectId: this.projectId,
+      agentId: this.getId(),
+      toolId
+    };
+    if (selectedTools !== void 0) {
+      relationData.selectedTools = selectedTools;
+    }
     const relationResponse = await fetch(
-      `${this.baseURL}/tenants/${this.tenantId}/crud/agent-tool-relations`,
+      `${this.baseURL}/tenants/${this.tenantId}/crud/projects/${this.projectId}/agent-tool-relations`,
       {
         method: "POST",
         headers: {
           "Content-Type": "application/json"
         },
-        body: JSON.stringify({
-          id: `${this.getId()}-tool-${toolId}`,
-          tenantId: this.tenantId,
-          agentId: this.getId(),
-          toolId
-        })
+        body: JSON.stringify(relationData)
       }
     );
     if (!relationResponse.ok) {
@@ -969,14 +970,10 @@ var Agent = class {
     }
   }
 };
-init_tool();
 var TransferConfigSchema = zod.z.object({
   agent: zod.z.instanceof(Agent),
   description: zod.z.string().optional()
 });
-function generateIdFromName3(name) {
-  return name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
-}
 function validateFunction(value, name) {
   if (typeof value !== "function") {
     throw new Error(`${name} must be a function`);
@@ -990,27 +987,9 @@ function agent(config) {
   }
   return new Agent(config);
 }
-function mcpServer(config) {
-  if (!config.serverUrl) {
-    throw new Error("MCP server requires a serverUrl");
-  }
-  const id = config.id || generateIdFromName3(config.name);
-  return new exports.Tool({
-    id,
-    name: config.name,
-    description: config.description,
-    serverUrl: config.serverUrl,
-    tenantId: config.tenantId,
-    credential: config.credential,
-    activeTools: config.activeTools,
-    headers: config.headers,
-    imageUrl: config.imageUrl,
-    transport: config.transport ? { type: config.transport } : void 0
-  });
-}
 function mcpTool(config) {
   const validatedConfig = agentsCore.MCPToolConfigSchema.parse(config);
-  return new exports.Tool(validatedConfig);
+  return new Tool(validatedConfig);
 }
 function credential(config) {
   return agentsCore.CredentialReferenceApiInsertSchema.parse(config);
@@ -1398,10 +1377,20 @@ var AgentGraph = class {
         const transfers = internalAgent.getTransfers();
         const delegates = internalAgent.getDelegates();
         const tools = [];
+        const selectedToolsMapping = {};
         const agentTools = internalAgent.getTools();
         for (const [toolName, toolInstance] of Object.entries(agentTools)) {
           if (toolInstance && typeof toolInstance === "object") {
-            const toolId = toolInstance.getId?.() || toolInstance.id || toolName;
+            let toolId;
+            if ("server" in toolInstance && "selectedTools" in toolInstance) {
+              const mcpConfig = toolInstance;
+              toolId = mcpConfig.server.getId();
+              if (mcpConfig.selectedTools !== void 0) {
+                selectedToolsMapping[toolId] = mcpConfig.selectedTools;
+              }
+            } else {
+              toolId = toolInstance.getId?.() || toolInstance.id || toolName;
+            }
             tools.push(toolId);
           }
         }
@@ -1430,6 +1419,7 @@ var AgentGraph = class {
           canTransferTo: transfers.map((h) => h.getId()),
           canDelegateTo: delegates.map((d) => d.getId()),
           tools,
+          selectedTools: Object.keys(selectedToolsMapping).length > 0 ? selectedToolsMapping : void 0,
           dataComponents: dataComponents.length > 0 ? dataComponents : void 0,
           artifactComponents: artifactComponents.length > 0 ? artifactComponents : void 0,
           type: "internal"
@@ -1458,55 +1448,64 @@ var AgentGraph = class {
       const agentTools = internalAgent.getTools();
       for (const [toolName, toolInstance] of Object.entries(agentTools)) {
         if (toolInstance && typeof toolInstance === "object") {
-          const toolId = toolInstance.getId?.() || toolInstance.id || toolName;
+          let actualTool;
+          let toolId;
+          if ("server" in toolInstance && "selectedTools" in toolInstance) {
+            const mcpConfig = toolInstance;
+            actualTool = mcpConfig.server;
+            toolId = actualTool.getId();
+          } else {
+            actualTool = toolInstance;
+            toolId = actualTool.getId?.() || actualTool.id || toolName;
+          }
           if (!toolsObject[toolId]) {
             let toolConfig;
-            if (toolInstance.config?.serverUrl) {
+            if (actualTool.config?.serverUrl) {
               toolConfig = {
                 type: "mcp",
                 mcp: {
                   server: {
-                    url: toolInstance.config.serverUrl
+                    url: actualTool.config.serverUrl
                   }
                 }
               };
-            } else if (toolInstance.config?.type === "mcp") {
-              toolConfig = toolInstance.config;
+            } else if (actualTool.config?.type === "mcp") {
+              toolConfig = actualTool.config;
             } else {
               toolConfig = {
                 type: "function",
-                parameters: toolInstance.parameters || {}
+                parameters: actualTool.parameters || {}
               };
             }
             const toolData = {
               id: toolId,
-              name: toolInstance.config?.name || toolInstance.name || toolName,
+              name: actualTool.config?.name || actualTool.name || toolName,
               config: toolConfig,
-              status: toolInstance.getStatus?.() || toolInstance.status || "unknown"
+              status: actualTool.getStatus?.() || actualTool.status || "unknown"
             };
-            if (toolInstance.config?.imageUrl) {
-              toolData.imageUrl = toolInstance.config.imageUrl;
+            if (actualTool.config?.imageUrl) {
+              toolData.imageUrl = actualTool.config.imageUrl;
             }
-            if (toolInstance.config?.headers) {
-              toolData.headers = toolInstance.config.headers;
+            if (actualTool.config?.headers) {
+              toolData.headers = actualTool.config.headers;
             }
-            if (toolInstance.capabilities) {
-              toolData.capabilities = toolInstance.capabilities;
+            if (actualTool.capabilities) {
+              toolData.capabilities = actualTool.capabilities;
             }
-            if (toolInstance.lastHealthCheck) {
-              toolData.lastHealthCheck = toolInstance.lastHealthCheck;
+            if (actualTool.lastHealthCheck) {
+              toolData.lastHealthCheck = actualTool.lastHealthCheck;
             }
-            if (toolInstance.availableTools) {
-              toolData.availableTools = toolInstance.availableTools;
+            if (actualTool.availableTools) {
+              toolData.availableTools = actualTool.availableTools;
             }
-            if (toolInstance.lastError) {
-              toolData.lastError = toolInstance.lastError;
+            if (actualTool.lastError) {
+              toolData.lastError = actualTool.lastError;
             }
-            if (toolInstance.lastToolsSync) {
-              toolData.lastToolsSync = toolInstance.lastToolsSync;
+            if (actualTool.lastToolsSync) {
+              toolData.lastToolsSync = actualTool.lastToolsSync;
             }
-            if (toolInstance.getCredentialReferenceId?.()) {
-              toolData.credentialReferenceId = toolInstance.getCredentialReferenceId();
+            if (actualTool.getCredentialReferenceId?.()) {
+              toolData.credentialReferenceId = actualTool.getCredentialReferenceId();
             }
             toolsObject[toolId] = toolData;
           }
@@ -2828,15 +2827,13 @@ var run = Runner.run.bind(Runner);
 var stream = Runner.stream.bind(Runner);
 var raceGraphs = Runner.raceGraphs.bind(Runner);
 
-// src/index.ts
-init_tool();
-
 exports.Agent = Agent;
 exports.AgentGraph = AgentGraph;
 exports.ArtifactComponent = ArtifactComponent;
 exports.DataComponent = DataComponent;
 exports.ExternalAgent = ExternalAgent;
 exports.Runner = Runner;
+exports.Tool = Tool;
 exports.agent = agent;
 exports.agentGraph = agentGraph;
 exports.artifactComponent = artifactComponent;
@@ -2846,7 +2843,6 @@ exports.dataComponent = dataComponent;
 exports.externalAgent = externalAgent;
 exports.externalAgents = externalAgents;
 exports.generateGraph = generateGraph;
-exports.mcpServer = mcpServer;
 exports.mcpTool = mcpTool;
 exports.raceGraphs = raceGraphs;
 exports.registerEnvironmentSettings = registerEnvironmentSettings;