@inkeep/agents-sdk 0.24.1 → 0.25.0

package/dist/index.cjs

@@ -541,25 +541,17 @@ var Agent = class {
     this.tenantId = tenantId;
     this.projectId = projectId;
     this.baseURL = apiUrl;
-    for (const agent2 of this.subAgents) {
-      if (this.isInternalAgent(agent2)) {
-        const internalAgent = agent2;
-        if (internalAgent.setContext) {
-          internalAgent.setContext(tenantId, projectId, apiUrl);
-        }
-        const tools = internalAgent.getTools();
-        for (const [_, toolInstance] of Object.entries(tools)) {
-          if (toolInstance && typeof toolInstance === "object") {
-            if ("setContext" in toolInstance && typeof toolInstance.setContext === "function") {
-              toolInstance.setContext(tenantId, projectId, apiUrl);
-            }
+    for (const subAgent2 of this.subAgents) {
+      if (subAgent2.setContext) {
+        subAgent2.setContext(tenantId, projectId, apiUrl);
+      }
+      const tools = subAgent2.getTools();
+      for (const [_, toolInstance] of Object.entries(tools)) {
+        if (toolInstance && typeof toolInstance === "object") {
+          if ("setContext" in toolInstance && typeof toolInstance.setContext === "function") {
+            toolInstance.setContext(tenantId, projectId, apiUrl);
           }
         }
-      } else {
-        const externalAgent2 = agent2;
-        if (externalAgent2.setContext) {
-          externalAgent2.setContext(tenantId, apiUrl);
-        }
       }
     }
     if (this.contextConfig?.setContext) {
@@ -579,92 +571,102 @@ var Agent = class {
    * Convert the Agent to FullAgentDefinition format for the new agent endpoint
    */
   async toFullAgentDefinition() {
-    const agentsObject = {};
+    const subAgentsObject = {};
+    const externalAgentsObject = {};
     const functionToolsObject = {};
     const functionsObject = {};
-    for (const agent2 of this.subAgents) {
-      if (this.isInternalAgent(agent2)) {
-        const internalAgent = agent2;
-        const transfers = internalAgent.getTransfers();
-        const delegates = internalAgent.getDelegates();
-        const tools = [];
-        const selectedToolsMapping = {};
-        const headersMapping = {};
-        const agentTools = internalAgent.getTools();
-        for (const [_toolName, toolInstance] of Object.entries(agentTools)) {
-          const toolId = toolInstance.getId();
-          if (toolInstance.selectedTools) {
-            selectedToolsMapping[toolId] = toolInstance.selectedTools;
-          }
-          if (toolInstance.headers) {
-            headersMapping[toolId] = toolInstance.headers;
-          }
-          tools.push(toolId);
-          if (toolInstance.constructor.name === "FunctionTool" && toolInstance instanceof FunctionTool) {
-            if (!functionsObject[toolId]) {
-              const functionData = toolInstance.serializeFunction();
-              functionsObject[toolId] = functionData;
-            }
-            if (!functionToolsObject[toolId]) {
-              const toolData = toolInstance.serializeTool();
-              functionToolsObject[toolId] = {
-                id: toolData.id,
-                name: toolData.name,
-                description: toolData.description,
-                functionId: toolData.functionId,
-                agentId: this.agentId
-                // Include agentId for agent-scoped function tools
-              };
-            }
-          }
+    for (const subAgent2 of this.subAgents) {
+      const transfers = subAgent2.getTransfers();
+      const delegates = subAgent2.getDelegates();
+      const tools = [];
+      const selectedToolsMapping = {};
+      const headersMapping = {};
+      const subAgentTools = subAgent2.getTools();
+      for (const [_toolName, toolInstance] of Object.entries(subAgentTools)) {
+        const toolId = toolInstance.getId();
+        if (toolInstance.selectedTools) {
+          selectedToolsMapping[toolId] = toolInstance.selectedTools;
         }
-        const dataComponents = [];
-        const subAgentDataComponents = internalAgent.getDataComponents();
-        if (subAgentDataComponents) {
-          for (const dataComponent2 of subAgentDataComponents) {
-            const dataComponentId = dataComponent2.id || dataComponent2.name.toLowerCase().replace(/\s+/g, "-");
-            dataComponents.push(dataComponentId);
-          }
+        if (toolInstance.headers) {
+          headersMapping[toolId] = toolInstance.headers;
         }
-        const artifactComponents = [];
-        const subAgentArtifactComponents = internalAgent.getArtifactComponents();
-        if (subAgentArtifactComponents) {
-          for (const artifactComponent2 of subAgentArtifactComponents) {
-            const artifactComponentId = artifactComponent2.id || artifactComponent2.name.toLowerCase().replace(/\s+/g, "-");
-            artifactComponents.push(artifactComponentId);
+        tools.push(toolId);
+        if (toolInstance.constructor.name === "FunctionTool" && toolInstance instanceof FunctionTool) {
+          if (!functionsObject[toolId]) {
+            const functionData = toolInstance.serializeFunction();
+            functionsObject[toolId] = functionData;
+          }
+          if (!functionToolsObject[toolId]) {
+            const toolData = toolInstance.serializeTool();
+            functionToolsObject[toolId] = {
+              id: toolData.id,
+              name: toolData.name,
+              description: toolData.description,
+              functionId: toolData.functionId,
+              agentId: this.agentId
+              // Include agentId for agent-scoped function tools
+            };
           }
         }
-        const canUse = tools.map((toolId) => ({
-          toolId,
-          toolSelection: selectedToolsMapping[toolId] || null,
-          headers: headersMapping[toolId] || null
-        }));
-        agentsObject[internalAgent.getId()] = {
-          id: internalAgent.getId(),
-          name: internalAgent.getName(),
-          description: internalAgent.config.description || `Agent ${internalAgent.getName()}`,
-          prompt: internalAgent.getInstructions(),
-          models: internalAgent.config.models,
-          canTransferTo: transfers.map((h) => h.getId()),
-          canDelegateTo: delegates.map((d) => d.getId()),
-          canUse,
-          // Always include for internal agents (required by API)
-          dataComponents: dataComponents.length > 0 ? dataComponents : void 0,
-          artifactComponents: artifactComponents.length > 0 ? artifactComponents : void 0,
-          type: "internal"
-        };
-      } else {
-        const externalAgent2 = agent2;
-        agentsObject[externalAgent2.getId()] = {
+      }
+      const subAgentExternalAgents = subAgent2.getExternalAgentDelegates();
+      for (const externalAgentDelegate of subAgentExternalAgents) {
+        const externalAgent2 = externalAgentDelegate.externalAgent;
+        externalAgentsObject[externalAgent2.getId()] = {
           id: externalAgent2.getId(),
           name: externalAgent2.getName(),
           description: externalAgent2.getDescription(),
           baseUrl: externalAgent2.getBaseUrl(),
           credentialReferenceId: externalAgent2.getCredentialReferenceId(),
-          headers: externalAgent2.getHeaders(),
           type: "external"
         };
       }
+      const dataComponents = [];
+      const subAgentDataComponents = subAgent2.getDataComponents();
+      if (subAgentDataComponents) {
+        for (const dataComponent2 of subAgentDataComponents) {
+          const dataComponentId = dataComponent2.id || dataComponent2.name.toLowerCase().replace(/\s+/g, "-");
+          dataComponents.push(dataComponentId);
+        }
+      }
+      const artifactComponents = [];
+      const subAgentArtifactComponents = subAgent2.getArtifactComponents();
+      if (subAgentArtifactComponents) {
+        for (const artifactComponent2 of subAgentArtifactComponents) {
+          const artifactComponentId = artifactComponent2.id || artifactComponent2.name.toLowerCase().replace(/\s+/g, "-");
+          artifactComponents.push(artifactComponentId);
+        }
+      }
+      const canUse = tools.map((toolId) => ({
+        toolId,
+        toolSelection: selectedToolsMapping[toolId] || null,
+        headers: headersMapping[toolId] || null
+      }));
+      subAgentsObject[subAgent2.getId()] = {
+        id: subAgent2.getId(),
+        name: subAgent2.getName(),
+        description: subAgent2.config.description || `Agent ${subAgent2.getName()}`,
+        prompt: subAgent2.getInstructions(),
+        models: subAgent2.config.models,
+        canTransferTo: transfers.map((h) => h.getId()),
+        canDelegateTo: delegates.map((d) => {
+          if (typeof d === "object" && "externalAgent" in d) {
+            return {
+              externalAgentId: d.externalAgent.getId(),
+              ...d.headers && { headers: d.headers }
+            };
+          } else if (typeof d === "object" && "type" in d && d.type === "external") {
+            return {
+              externalAgentId: d.getId()
+            };
+          }
+          return d.getId();
+        }),
+        canUse,
+        dataComponents: dataComponents.length > 0 ? dataComponents : void 0,
+        artifactComponents: artifactComponents.length > 0 ? artifactComponents : void 0,
+        type: "internal"
+      };
     }
     const processedStatusUpdates = this.statusUpdateSettings ? {
       ...this.statusUpdateSettings,
@@ -696,7 +698,8 @@ var Agent = class {
       name: this.agentName,
       description: this.agentDescription,
       defaultSubAgentId: this.defaultSubAgent?.getId() || "",
-      subAgents: agentsObject,
+      subAgents: subAgentsObject,
+      externalAgents: externalAgentsObject,
       contextConfig: this.contextConfig?.toObject(),
       ...Object.keys(functionToolsObject).length > 0 && { functionTools: functionToolsObject },
       ...Object.keys(functionsObject).length > 0 && { functions: functionsObject },
@@ -713,12 +716,8 @@ var Agent = class {
   async initializeAllTools() {
     logger5.info({ agentId: this.agentId }, "Initializing all tools in agent");
     const toolInitPromises = [];
-    for (const agent2 of this.subAgents) {
-      if (!agent2.getTools) {
-        continue;
-      }
-      const internalAgent = agent2;
-      const agentTools = internalAgent.getTools();
+    for (const subAgent2 of this.subAgents) {
+      const agentTools = subAgent2.getTools();
       for (const [toolName, toolInstance] of Object.entries(agentTools)) {
         if (toolInstance && typeof toolInstance === "object") {
           if (typeof toolInstance.init === "function") {
@@ -737,7 +736,7 @@ var Agent = class {
                   }
                   logger5.debug(
                     {
-                      subAgentId: agent2.getId(),
+                      subAgentId: subAgent2.getId(),
                       toolName,
                       toolType: toolInstance.constructor.name,
                       skipDbRegistration
@@ -747,7 +746,7 @@ var Agent = class {
                 } catch (error) {
                   logger5.error(
                     {
-                      subAgentId: agent2.getId(),
+                      subAgentId: subAgent2.getId(),
                       toolName,
                       error: error instanceof Error ? error.message : "Unknown error"
                     },
@@ -820,80 +819,6 @@ var Agent = class {
       throw error;
     }
   }
-  /**
-   * Legacy initialization method - kept for backward compatibility
-   * Initialize the agent and all agents in the backend using individual endpoints
-   */
-  async initLegacy() {
-    if (this.initialized) {
-      logger5.info({ agentId: this.agentId }, "Agent already initialized");
-      return;
-    }
-    logger5.info(
-      {
-        agentId: this.agentId,
-        agentCount: this.subAgents.length
-      },
-      "Initializing agent"
-    );
-    try {
-      if (this.contextConfig) {
-        await this.contextConfig.init();
-        logger5.info(
-          {
-            agentId: this.agentId,
-            contextConfigId: this.contextConfig.getId()
-          },
-          "Context configuration initialized for agent"
-        );
-      }
-      const initPromises = this.subAgents.map(async (agent2) => {
-        try {
-          agent2.config.agentId = this.agentId;
-          await agent2.init();
-          logger5.debug(
-            {
-              subAgentId: agent2.getId(),
-              agentId: this.agentId
-            },
-            "Agent initialized in agent"
-          );
-        } catch (error) {
-          logger5.error(
-            {
-              subAgentId: agent2.getId(),
-              agentId: this.agentId,
-              error: error instanceof Error ? error.message : "Unknown error"
-            },
-            "Failed to initialize agent in agent"
-          );
-          throw error;
-        }
-      });
-      await Promise.all(initPromises);
-      await this.saveToDatabase();
-      await this.createExternalAgents();
-      await this.createAgentRelations();
-      await this.saveRelations();
-      this.initialized = true;
-      logger5.info(
-        {
-          agentId: this.agentId,
-          agentCount: this.subAgents.length
-        },
-        "Agent initialized successfully"
-      );
-    } catch (error) {
-      logger5.error(
-        {
-          agentId: this.agentId,
-          error: error instanceof Error ? error.message : "Unknown error"
-        },
-        "Failed to initialize agent"
-      );
-      throw error;
-    }
-  }
   /**
    * Generate a response using the default agent
    */
@@ -955,11 +880,6 @@ var Agent = class {
     if (!agent2) {
       throw new Error(`Agent '${subAgentId}' not found in agent`);
     }
-    if (!this.isInternalAgent(agent2)) {
-      throw new Error(
-        `Agent '${subAgentId}' is an external agent and cannot be run directly. External agents are only accessible via delegation.`
-      );
-    }
     logger5.info(
       {
         agentId: this.agentId,
@@ -992,16 +912,15 @@ var Agent = class {
   addSubAgent(agent2) {
     this.subAgents.push(agent2);
     this.agentMap.set(agent2.getId(), agent2);
-    if (this.models && this.isInternalAgent(agent2)) {
+    if (this.models) {
       this.propagateModelSettingsToAgent(agent2);
     }
     logger5.info(
       {
         agentId: this.agentId,
-        subAgentId: agent2.getId(),
-        agentType: this.isInternalAgent(agent2) ? "internal" : "external"
+        subAgentId: agent2.getId()
       },
-      "Agent added to agent"
+      "SubAgent added to agent"
     );
   }
   /**
@@ -1130,29 +1049,30 @@ var Agent = class {
       errors.push("Agent must have a default agent");
     }
     const names = /* @__PURE__ */ new Set();
-    for (const agent2 of this.subAgents) {
-      const name = agent2.getName();
+    for (const subAgent2 of this.subAgents) {
+      const name = subAgent2.getName();
       if (names.has(name)) {
         errors.push(`Duplicate agent name: ${name}`);
       }
       names.add(name);
     }
-    for (const agent2 of this.subAgents) {
-      if (!this.isInternalAgent(agent2)) continue;
-      const transfers = agent2.getTransfers();
+    for (const subAgent2 of this.subAgents) {
+      const transfers = subAgent2.getTransfers();
       for (const transferAgent of transfers) {
         if (!this.agentMap.has(transferAgent.getName())) {
           errors.push(
-            `Agent '${agent2.getName()}' has transfer to '${transferAgent.getName()}' which is not in the agent`
+            `Agent '${subAgent2.getName()}' has transfer to '${transferAgent.getName()}' which is not in the agent`
           );
         }
       }
-      const delegates = agent2.getDelegates();
+      const delegates = subAgent2.getDelegates();
       for (const delegateAgent of delegates) {
-        if (!this.agentMap.has(delegateAgent.getName())) {
-          errors.push(
-            `Agent '${agent2.getName()}' has delegation to '${delegateAgent.getName()}' which is not in the agent`
-          );
+        if (this.isInternalAgent(delegateAgent)) {
+          if (!this.agentMap.has(delegateAgent.getName())) {
+            errors.push(
+              `Agent '${subAgent2.getName()}' has delegation to '${delegateAgent.getName()}' which is not in the agent`
+            );
+          }
         }
       }
     }
@@ -1235,10 +1155,8 @@ var Agent = class {
       }
     }
     await this.applyStopWhenInheritance();
-    for (const agent2 of this.subAgents) {
-      if (this.isInternalAgent(agent2)) {
-        this.propagateModelSettingsToAgent(agent2);
-      }
+    for (const subAgent2 of this.subAgents) {
+      this.propagateModelSettingsToAgent(subAgent2);
     }
   }
   /**
@@ -1256,15 +1174,12 @@ var Agent = class {
       this.stopWhen.transferCountIs = 10;
     }
     if (projectStopWhen?.stepCountIs !== void 0) {
-      for (const agent2 of this.subAgents) {
-        if (this.isInternalAgent(agent2)) {
-          const internalAgent = agent2;
-          if (!internalAgent.config.stopWhen) {
-            internalAgent.config.stopWhen = {};
-          }
-          if (internalAgent.config.stopWhen.stepCountIs === void 0) {
-            internalAgent.config.stopWhen.stepCountIs = projectStopWhen.stepCountIs;
-          }
+      for (const subAgent2 of this.subAgents) {
+        if (!subAgent2.config.stopWhen) {
+          subAgent2.config.stopWhen = {};
+        }
+        if (subAgent2.config.stopWhen.stepCountIs === void 0) {
+          subAgent2.config.stopWhen.stepCountIs = projectStopWhen.stepCountIs;
         }
       }
     }
@@ -1300,18 +1215,10 @@ var Agent = class {
    * Immediately propagate agent-level models to all agents during construction
    */
   propagateImmediateModelSettings() {
-    for (const agent2 of this.subAgents) {
-      if (this.isInternalAgent(agent2)) {
-        this.propagateModelSettingsToAgent(agent2);
-      }
+    for (const subAgent2 of this.subAgents) {
+      this.propagateModelSettingsToAgent(subAgent2);
     }
   }
-  /**
-   * Type guard to check if an agent is an external AgentInterface
-   */
-  isExternalAgent(agent2) {
-    return !this.isInternalAgent(agent2);
-  }
   /**
    * Execute agent using the backend system instead of local runner
    */
@@ -1477,29 +1384,25 @@ var Agent = class {
       }
     }
   }
-  async createAgentRelations() {
-    const allRelationPromises = [];
-    for (const agent2 of this.subAgents) {
-      if (this.isInternalAgent(agent2)) {
-        const transfers = agent2.getTransfers();
-        for (const transferAgent of transfers) {
-          allRelationPromises.push(
-            this.createInternalAgentRelation(agent2, transferAgent, "transfer")
+  async createSubAgentRelations() {
+    const allSubAgentRelationPromises = [];
+    for (const subAgent2 of this.subAgents) {
+      const transfers = subAgent2.getTransfers();
+      for (const transferAgent of transfers) {
+        allSubAgentRelationPromises.push(
+          this.createSubAgentRelation(subAgent2, transferAgent, "transfer")
+        );
+      }
+      const delegates = subAgent2.getSubAgentDelegates();
+      for (const delegate of delegates) {
+        if (this.isInternalAgent(delegate)) {
+          allSubAgentRelationPromises.push(
+            this.createSubAgentRelation(subAgent2, delegate, "delegate")
           );
         }
-        const delegates = agent2.getDelegates();
-        for (const delegate of delegates) {
-          if (delegate.type === "external") {
-            allRelationPromises.push(this.createExternalAgentRelation(agent2, delegate, "delegate"));
-          } else {
-            allRelationPromises.push(
-              this.createInternalAgentRelation(agent2, delegate, "delegate")
-            );
-          }
-        }
       }
     }
-    const results = await Promise.allSettled(allRelationPromises);
+    const results = await Promise.allSettled(allSubAgentRelationPromises);
     const errors = [];
     let successCount = 0;
     for (const result of results) {
@@ -1519,7 +1422,7 @@ var Agent = class {
     logger5.info(
       {
         agentId: this.agentId,
-        totalRelations: allRelationPromises.length,
+        totalRelations: allSubAgentRelationPromises.length,
         successCount,
         errorCount: errors.length
       },
@@ -1529,7 +1432,7 @@ var Agent = class {
       throw new Error(`All ${errors.length} agent relation creations failed`);
     }
   }
-  async createInternalAgentRelation(sourceAgent, targetAgent, relationType) {
+  async createSubAgentRelation(sourceAgent, targetAgent, relationType) {
     try {
       const response = await fetch(`${this.baseURL}/tenants/${this.tenantId}/agent-relations`, {
         method: "POST",
@@ -1557,7 +1460,7 @@ var Agent = class {
           );
           return;
         }
-        throw new Error(`Failed to create agent relation: ${response.status} - ${errorText}`);
+        throw new Error(`Failed to create subAgent relation: ${response.status} - ${errorText}`);
       }
       logger5.info(
         {
@@ -1566,7 +1469,7 @@ var Agent = class {
           agentId: this.agentId,
           relationType
         },
-        `${relationType} relation created successfully`
+        `${relationType} subAgent relation created successfully`
       );
     } catch (error) {
       logger5.error(
@@ -1577,116 +1480,7 @@ var Agent = class {
           relationType,
           error: error instanceof Error ? error.message : "Unknown error"
         },
-        `Failed to create ${relationType} relation`
-      );
-      throw error;
-    }
-  }
-  async createExternalAgentRelation(sourceAgent, externalAgent2, relationType) {
-    try {
-      const response = await fetch(`${this.baseURL}/tenants/${this.tenantId}/agent-relations`, {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json"
-        },
-        body: JSON.stringify({
-          agentId: this.agentId,
-          sourceSubAgentId: sourceAgent.getId(),
-          externalSubAgentId: externalAgent2.getId(),
-          relationType
-        })
-      });
-      if (!response.ok) {
-        const errorText = await response.text().catch(() => "Unknown error");
-        if (response.status === 422 && errorText.includes("already exists")) {
-          logger5.info(
-            {
-              sourceSubAgentId: sourceAgent.getId(),
-              externalSubAgentId: externalAgent2.getId(),
-              agentId: this.agentId,
-              relationType
-            },
-            `${relationType} relation already exists, skipping creation`
-          );
-          return;
-        }
-        throw new Error(
-          `Failed to create external agent relation: ${response.status} - ${errorText}`
-        );
-      }
-      logger5.info(
-        {
-          sourceSubAgentId: sourceAgent.getId(),
-          externalSubAgentId: externalAgent2.getId(),
-          agentId: this.agentId,
-          relationType
-        },
-        `${relationType} relation created successfully`
-      );
-    } catch (error) {
-      logger5.error(
-        {
-          sourceSubAgentId: sourceAgent.getId(),
-          externalSubAgentId: externalAgent2.getId(),
-          agentId: this.agentId,
-          relationType,
-          error: error instanceof Error ? error.message : "Unknown error"
-        },
-        `Failed to create ${relationType} relation`
-      );
-      throw error;
-    }
-  }
-  /**
-   * Create external agents in the database
-   */
-  async createExternalAgents() {
-    const externalAgents2 = this.subAgents.filter((agent2) => this.isExternalAgent(agent2));
-    logger5.info(
-      {
-        agentId: this.agentId,
-        externalAgentCount: externalAgents2.length
-      },
-      "Creating external agents in database"
-    );
-    const initPromises = externalAgents2.map(async (externalAgent2) => {
-      try {
-        await externalAgent2.init();
-        logger5.debug(
-          {
-            externalSubAgentId: externalAgent2.getId(),
-            agentId: this.agentId
-          },
-          "External agent created in database"
-        );
-      } catch (error) {
-        logger5.error(
-          {
-            externalSubAgentId: externalAgent2.getId(),
-            agentId: this.agentId,
-            error: error instanceof Error ? error.message : "Unknown error"
-          },
-          "Failed to create external agent in database"
-        );
-        throw error;
-      }
-    });
-    try {
-      await Promise.all(initPromises);
-      logger5.info(
-        {
-          agentId: this.agentId,
-          externalAgentCount: externalAgents2.length
-        },
-        "All external agents created successfully"
-      );
-    } catch (error) {
-      logger5.error(
-        {
-          agentId: this.agentId,
-          error: error instanceof Error ? error.message : "Unknown error"
-        },
-        "Failed to create some external agents"
+        `Failed to create ${relationType} subAgent relation`
       );
       throw error;
     }
@@ -2095,6 +1889,8 @@ var Project = class {
     __publicField(this, "projectTools", []);
     __publicField(this, "projectDataComponents", []);
     __publicField(this, "projectArtifactComponents", []);
+    __publicField(this, "projectExternalAgents", []);
+    __publicField(this, "externalAgentMap", /* @__PURE__ */ new Map());
     this.projectId = config.id;
     this.projectName = config.name;
     this.projectDescription = config.description;
@@ -2121,6 +1917,12 @@ var Project = class {
     if (config.credentialReferences) {
       this.credentialReferences = config.credentialReferences();
     }
+    if (config.externalAgents) {
+      this.projectExternalAgents = config.externalAgents();
+      this.externalAgentMap = new Map(
+        this.projectExternalAgents.map((externalAgent2) => [externalAgent2.getId(), externalAgent2])
+      );
+    }
     logger8.info(
       {
         projectId: this.projectId,
@@ -2296,6 +2098,46 @@ var Project = class {
   getAgents() {
     return this.agents;
   }
+  /**
+   * Get all external agents in the project
+   */
+  getExternalAgents() {
+    return this.projectExternalAgents;
+  }
+  /**
+   * Get an external agent by ID
+   */
+  getExternalAgent(id) {
+    return this.externalAgentMap.get(id);
+  }
+  /**
+   * Add an external agent to the project
+   */
+  addExternalAgent(externalAgent2) {
+    this.projectExternalAgents.push(externalAgent2);
+    this.externalAgentMap.set(externalAgent2.getId(), externalAgent2);
+  }
+  /**
+   * Remove an external agent from the project
+   */
+  removeExternalAgent(id) {
+    const externalAgentToRemove = this.externalAgentMap.get(id);
+    if (externalAgentToRemove) {
+      this.externalAgentMap.delete(id);
+      this.projectExternalAgents = this.projectExternalAgents.filter(
+        (externalAgent2) => externalAgent2.getId() !== id
+      );
+      logger8.info(
+        {
+          projectId: this.projectId,
+          externalAgentId: id
+        },
+        "External agent removed from project"
+      );
+      return true;
+    }
+    return false;
+  }
   /**
    * Get an agent by ID
    */
@@ -2388,8 +2230,10 @@ var Project = class {
     const dataComponentsObject = {};
     const artifactComponentsObject = {};
     const credentialReferencesObject = {};
+    const externalAgentsObject = {};
     const credentialUsageMap = {};
     for (const agent2 of this.agents) {
+      logger8.info({ agentId: agent2.getId() }, "Agent id");
       const agentDefinition = await agent2.toFullAgentDefinition();
       agentsObject[agent2.getId()] = agentDefinition;
       const agentCredentials = agent2.credentials;
@@ -2464,9 +2308,6 @@ var Project = class {
         }
       }
       for (const subAgent2 of agent2.getSubAgents()) {
-        if (subAgent2.type === "external") {
-          continue;
-        }
         const agentTools = subAgent2.getTools();
         for (const [, toolInstance] of Object.entries(agentTools)) {
           const actualTool = toolInstance;
@@ -2596,8 +2437,40 @@ var Project = class {
             }
           }
         }
+        const subAgentExternalAgents = subAgent2.getExternalAgentDelegates();
+        if (subAgentExternalAgents) {
+          for (const externalAgentDelegate of subAgentExternalAgents) {
+            const externalAgent2 = externalAgentDelegate.externalAgent;
+            const credential2 = externalAgent2.getCredentialReference();
+            if (credential2) {
+              if (!credentialReferencesObject[credential2.id]) {
+                credentialReferencesObject[credential2.id] = {
+                  id: credential2.id,
+                  type: credential2.type,
+                  credentialStoreId: credential2.credentialStoreId,
+                  retrievalParams: credential2.retrievalParams
+                };
+                credentialUsageMap[credential2.id] = [];
+              }
+              logger8.info({ credentialId: credential2.id }, "Credential id in external agent");
+              credentialUsageMap[credential2.id].push({
+                type: "externalAgent",
+                id: externalAgent2.getId()
+              });
+            }
+            logger8.info({ externalAgentId: externalAgent2.getId() }, "External agent id");
+            externalAgentsObject[externalAgent2.getId()] = {
+              id: externalAgent2.getId(),
+              name: externalAgent2.getName(),
+              description: externalAgent2.getDescription(),
+              baseUrl: externalAgent2.getBaseUrl(),
+              credentialReferenceId: externalAgent2.getCredentialReferenceId()
+            };
+          }
+        }
       }
     }
+    logger8.info({ externalAgentsObject }, "External agents object");
     for (const tool of this.projectTools) {
       const toolId = tool.getId();
       if (!toolsObject[toolId]) {
@@ -2683,6 +2556,7 @@ var Project = class {
       functions: Object.keys(functionsObject).length > 0 ? functionsObject : void 0,
       dataComponents: Object.keys(dataComponentsObject).length > 0 ? dataComponentsObject : void 0,
       artifactComponents: Object.keys(artifactComponentsObject).length > 0 ? artifactComponentsObject : void 0,
+      externalAgents: Object.keys(externalAgentsObject).length > 0 ? externalAgentsObject : void 0,
       credentialReferences: Object.keys(credentialReferencesObject).length > 0 ? credentialReferencesObject : void 0,
       createdAt: (/* @__PURE__ */ new Date()).toISOString(),
       updatedAt: (/* @__PURE__ */ new Date()).toISOString()
@@ -2992,6 +2866,39 @@ var SubAgent = class {
   getTransfers() {
     return typeof this.config.canTransferTo === "function" ? this.config.canTransferTo() : [];
   }
+  getSubAgentDelegates() {
+    return typeof this.config.canDelegateTo === "function" ? this.config.canDelegateTo().filter((delegate) => {
+      if (typeof delegate === "object" && "externalAgent" in delegate) {
+        return false;
+      }
+      if (typeof delegate === "object" && "type" in delegate && delegate.type === "external") {
+        return false;
+      }
+      return true;
+    }) : [];
+  }
+  getExternalAgentDelegates() {
+    if (typeof this.config.canDelegateTo !== "function") {
+      return [];
+    }
+    return this.config.canDelegateTo().filter((delegate) => {
+      if (typeof delegate === "object" && "externalAgent" in delegate) {
+        return true;
+      }
+      if (typeof delegate === "object" && "type" in delegate && delegate.type === "external") {
+        return true;
+      }
+      return false;
+    }).map((delegate) => {
+      if ("externalAgent" in delegate) {
+        return delegate;
+      }
+      return {
+        externalAgent: delegate,
+        headers: void 0
+      };
+    });
+  }
   getDelegates() {
     return typeof this.config.canDelegateTo === "function" ? this.config.canDelegateTo() : [];
   }
@@ -3787,10 +3694,12 @@ var ExternalAgent = class {
     __publicField(this, "type", "external");
     __publicField(this, "initialized", false);
     __publicField(this, "tenantId");
+    __publicField(this, "projectId");
     __publicField(this, "baseURL");
     this.config = { ...config, type: "external" };
     this.tenantId = "default";
-    this.baseURL = process.env.INKEEP_API_URL || "http://localhost:3002";
+    this.projectId = "default";
+    this.baseURL = this.config.baseUrl;
     logger12.debug(
       {
         externalAgentName: this.config.name,
@@ -3826,16 +3735,20 @@ var ExternalAgent = class {
     }
   }
   // Set context (tenantId and baseURL) from external source (agent, CLI, etc)
-  setContext(tenantId, baseURL) {
+  setContext(tenantId, projectId) {
     this.tenantId = tenantId;
-    if (baseURL) {
-      this.baseURL = baseURL;
-    }
+    this.projectId = projectId;
   }
   // Compute ID from name using a simple slug transformation
   getId() {
     return this.config.id;
   }
+  with(options) {
+    return {
+      externalAgent: this,
+      headers: options.headers
+    };
+  }
   // Private method to upsert external agent (create or update)
   async upsertExternalAgent() {
     const externalAgentData = {
@@ -3843,11 +3756,10 @@ var ExternalAgent = class {
       name: this.config.name,
       description: this.config.description,
       baseUrl: this.config.baseUrl,
-      credentialReferenceId: this.config.credentialReference?.id || void 0,
-      headers: this.config.headers || void 0
+      credentialReferenceId: this.config.credentialReference?.id || void 0
     };
     const updateResponse = await fetch(
-      `${this.baseURL}/tenants/${this.tenantId}/external-agents/${this.getId()}`,
+      `${this.baseURL}/tenants/${this.tenantId}/projects/${this.projectId}/external-agents/${this.getId()}`,
       {
         method: "PUT",
         headers: {
@@ -3873,7 +3785,7 @@ var ExternalAgent = class {
         "External agent not found, creating new external agent"
       );
       const createResponse = await fetch(
-        `${this.baseURL}/tenants/${this.tenantId}/external-agents`,
+        `${this.baseURL}/tenants/${this.tenantId}/projects/${this.projectId}/external-agents`,
         {
           method: "POST",
           headers: {
@@ -3931,8 +3843,8 @@ var ExternalAgent = class {
   getCredentialReferenceId() {
     return this.config.credentialReference?.id || void 0;
   }
-  getHeaders() {
-    return this.config.headers;
+  getCredentialReference() {
+    return this.config.credentialReference || void 0;
   }
 };
 function externalAgent(config) {