@inkeep/agents-sdk 0.0.0-dev-20250910233133 → 0.0.0-dev-20250910233151

package/dist/index.cjs

@@ -0,0 +1,2948 @@
+'use strict';
+
+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);
+        this.config = config;
+        this.baseURL = process.env.INKEEP_API_URL || "http://localhost:3002";
+        this.tenantId = config.tenantId || "default";
+        logger3.info(
+          {
+            toolId: this.getId(),
+            toolName: 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,
+          // Don't send description as it's not in the database schema
+          // Explicitly set to null when undefined to ensure removal
+          credentialReferenceId: this.config.credential?.id ?? null,
+          // Explicitly set headers to null when undefined to ensure removal
+          headers: this.config.headers ?? null,
+          imageUrl: this.config.imageUrl,
+          // Include image URL
+          config: {
+            type: "mcp",
+            mcp: {
+              server: {
+                url: this.config.serverUrl
+              },
+              activeTools: this.config.activeTools
+            }
+          }
+        };
+        const toolDataForCreate = {
+          ...toolDataForUpdate
+        };
+        logger3.info({ toolDataForCreate }, "toolDataForCreate");
+        const updateResponse = await fetch(
+          `${this.baseURL}/tenants/${this.tenantId}/crud/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/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) {
+    __publicField(this, "config");
+    __publicField(this, "baseURL");
+    __publicField(this, "tenantId");
+    __publicField(this, "projectId");
+    __publicField(this, "initialized", false);
+    __publicField(this, "id");
+    this.id = agentsCore.generateIdFromName(config.name);
+    this.config = {
+      ...config,
+      id: this.id,
+      tenantId: config.tenantId || "default",
+      projectId: config.projectId || "default"
+    };
+    this.baseURL = process.env.INKEEP_API_URL || "http://localhost:3002";
+    this.tenantId = this.config.tenantId;
+    this.projectId = this.config.projectId;
+    logger.info(
+      {
+        artifactComponentId: this.getId(),
+        artifactComponentName: config.name
+      },
+      "ArtifactComponent constructor initialized"
+    );
+  }
+  // Compute ID from name using same slug transformation as agents
+  getId() {
+    return this.id;
+  }
+  getName() {
+    return this.config.name;
+  }
+  getDescription() {
+    return this.config.description;
+  }
+  getSummaryProps() {
+    return this.config.summaryProps;
+  }
+  getFullProps() {
+    return this.config.fullProps;
+  }
+  // Public method to ensure artifact component exists in backend (with upsert behavior)
+  async init() {
+    if (this.initialized) return;
+    try {
+      await this.upsertArtifactComponent();
+      logger.info(
+        {
+          artifactComponentId: this.getId()
+        },
+        "ArtifactComponent initialized successfully"
+      );
+      this.initialized = true;
+    } catch (error) {
+      logger.error(
+        {
+          artifactComponentId: this.getId(),
+          error: error instanceof Error ? error.message : "Unknown error"
+        },
+        "Failed to initialize artifact component"
+      );
+      throw error;
+    }
+  }
+  // Private method to upsert artifact component (create or update)
+  async upsertArtifactComponent() {
+    const artifactComponentData = {
+      id: this.getId(),
+      name: this.config.name,
+      description: this.config.description,
+      summaryProps: this.config.summaryProps,
+      fullProps: this.config.fullProps
+    };
+    logger.info(
+      { artifactComponentData },
+      "artifactComponentData for create/update"
+    );
+    const updateResponse = await fetch(
+      `${this.baseURL}/tenants/${this.tenantId}/crud/artifact-components/${this.getId()}`,
+      {
+        method: "PUT",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify(artifactComponentData)
+      }
+    );
+    logger.info(
+      {
+        status: updateResponse.status,
+        artifactComponentId: this.getId()
+      },
+      "artifact component updateResponse"
+    );
+    if (updateResponse.ok) {
+      logger.info(
+        {
+          artifactComponentId: this.getId()
+        },
+        "ArtifactComponent updated successfully"
+      );
+      return;
+    }
+    if (updateResponse.status === 404) {
+      logger.info(
+        {
+          artifactComponentId: this.getId()
+        },
+        "ArtifactComponent not found, creating new artifact component"
+      );
+      const createResponse = await fetch(
+        `${this.baseURL}/tenants/${this.tenantId}/crud/artifact-components`,
+        {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json"
+          },
+          body: JSON.stringify(artifactComponentData)
+        }
+      );
+      if (!createResponse.ok) {
+        const errorText2 = await createResponse.text().catch(() => "Unknown error");
+        throw new Error(
+          `Failed to create artifact component: ${createResponse.status} ${createResponse.statusText} - ${errorText2}`
+        );
+      }
+      logger.info(
+        {
+          artifactComponentId: this.getId()
+        },
+        "ArtifactComponent created successfully"
+      );
+      return;
+    }
+    const errorText = await updateResponse.text().catch(() => "Unknown error");
+    throw new Error(
+      `Failed to update artifact component: ${updateResponse.status} ${updateResponse.statusText} - ${errorText}`
+    );
+  }
+};
+var logger2 = agentsCore.getLogger("dataComponent");
+var DataComponent = class {
+  constructor(config) {
+    __publicField(this, "config");
+    __publicField(this, "baseURL");
+    __publicField(this, "tenantId");
+    __publicField(this, "projectId");
+    __publicField(this, "initialized", false);
+    __publicField(this, "id");
+    this.id = agentsCore.generateIdFromName(config.name);
+    this.config = {
+      ...config,
+      id: this.id,
+      tenantId: config.tenantId || "default",
+      projectId: config.projectId || "default"
+    };
+    this.baseURL = process.env.INKEEP_API_URL || "http://localhost:3002";
+    this.tenantId = this.config.tenantId;
+    this.projectId = this.config.projectId;
+    logger2.info(
+      {
+        dataComponentId: this.getId(),
+        dataComponentName: config.name
+      },
+      "DataComponent constructor initialized"
+    );
+  }
+  // Compute ID from name using same slug transformation as agents
+  getId() {
+    return this.id;
+  }
+  getName() {
+    return this.config.name;
+  }
+  getDescription() {
+    return this.config.description;
+  }
+  getProps() {
+    return this.config.props;
+  }
+  // Public method to ensure data component exists in backend (with upsert behavior)
+  async init() {
+    if (this.initialized) return;
+    try {
+      await this.upsertDataComponent();
+      logger2.info(
+        {
+          dataComponentId: this.getId()
+        },
+        "DataComponent initialized successfully"
+      );
+      this.initialized = true;
+    } catch (error) {
+      logger2.error(
+        {
+          dataComponentId: this.getId(),
+          error: error instanceof Error ? error.message : "Unknown error"
+        },
+        "Failed to initialize data component"
+      );
+      throw error;
+    }
+  }
+  // Private method to upsert data component (create or update)
+  async upsertDataComponent() {
+    const dataComponentData = {
+      id: this.getId(),
+      name: this.config.name,
+      description: this.config.description,
+      props: this.config.props
+    };
+    logger2.info({ dataComponentData }, "dataComponentData for create/update");
+    const updateResponse = await fetch(
+      `${this.baseURL}/tenants/${this.tenantId}/crud/data-components/${this.getId()}`,
+      {
+        method: "PUT",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify(dataComponentData)
+      }
+    );
+    logger2.info(
+      {
+        status: updateResponse.status,
+        dataComponentId: this.getId()
+      },
+      "data component updateResponse"
+    );
+    if (updateResponse.ok) {
+      logger2.info(
+        {
+          dataComponentId: this.getId()
+        },
+        "DataComponent updated successfully"
+      );
+      return;
+    }
+    if (updateResponse.status === 404) {
+      logger2.info(
+        {
+          dataComponentId: this.getId()
+        },
+        "DataComponent not found, creating new data component"
+      );
+      const createResponse = await fetch(
+        `${this.baseURL}/tenants/${this.tenantId}/crud/data-components`,
+        {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json"
+          },
+          body: JSON.stringify(dataComponentData)
+        }
+      );
+      if (!createResponse.ok) {
+        const errorText2 = await createResponse.text().catch(() => "Unknown error");
+        throw new Error(
+          `Failed to create data component: ${createResponse.status} ${createResponse.statusText} - ${errorText2}`
+        );
+      }
+      logger2.info(
+        {
+          dataComponentId: this.getId()
+        },
+        "DataComponent created successfully"
+      );
+      return;
+    }
+    const errorText = await updateResponse.text().catch(() => "Unknown error");
+    throw new Error(
+      `Failed to update data component: ${updateResponse.status} ${updateResponse.statusText} - ${errorText}`
+    );
+  }
+};
+
+// src/agent.ts
+var logger4 = agentsCore.getLogger("agent");
+function resolveGetter(value) {
+  if (typeof value === "function") {
+    return value();
+  }
+  return value;
+}
+var Agent = class {
+  constructor(config) {
+    __publicField(this, "config");
+    __publicField(this, "type", "internal");
+    __publicField(this, "baseURL");
+    __publicField(this, "tenantId");
+    __publicField(this, "projectId");
+    __publicField(this, "initialized", false);
+    this.config = { ...config, type: "internal" };
+    this.baseURL = process.env.INKEEP_API_URL || "http://localhost:3002";
+    this.tenantId = config.tenantId || "default";
+    this.projectId = config.projectId || "default";
+    logger4.info(
+      {
+        tenantId: this.tenantId,
+        agentId: this.config.id,
+        agentName: config.name
+      },
+      "Agent constructor initialized"
+    );
+  }
+  // Return the configured ID
+  getId() {
+    return this.config.id;
+  }
+  // Agent introspection methods
+  getName() {
+    return this.config.name;
+  }
+  getInstructions() {
+    return this.config.prompt;
+  }
+  getTools() {
+    const tools = resolveGetter(this.config.tools);
+    if (!tools) {
+      return {};
+    }
+    if (!Array.isArray(tools)) {
+      throw new Error("tools getter must return an array");
+    }
+    const toolRecord = {};
+    for (const tool2 of tools) {
+      if (tool2 && typeof tool2 === "object") {
+        const id = tool2.id || tool2.getId?.() || tool2.name;
+        if (id) {
+          toolRecord[id] = tool2;
+        }
+      }
+    }
+    return toolRecord;
+  }
+  getModels() {
+    return this.config.models;
+  }
+  setModels(models) {
+    this.config.models = models;
+  }
+  getTransfers() {
+    return typeof this.config.canTransferTo === "function" ? this.config.canTransferTo() : [];
+  }
+  getDelegates() {
+    return typeof this.config.canDelegateTo === "function" ? this.config.canDelegateTo() : [];
+  }
+  getDataComponents() {
+    return resolveGetter(this.config.dataComponents) || [];
+  }
+  getArtifactComponents() {
+    return resolveGetter(this.config.artifactComponents) || [];
+  }
+  addTool(_name, tool2) {
+    const existingTools = this.config.tools ? this.config.tools() : [];
+    this.config.tools = () => [...existingTools, tool2];
+  }
+  addTransfer(...agents) {
+    if (typeof this.config.canTransferTo === "function") {
+      const existingTransfers = this.config.canTransferTo;
+      this.config.canTransferTo = () => [...existingTransfers(), ...agents];
+    } else {
+      this.config.canTransferTo = () => agents;
+    }
+  }
+  addDelegate(...agents) {
+    if (typeof this.config.canDelegateTo === "function") {
+      const existingDelegates = this.config.canDelegateTo;
+      this.config.canDelegateTo = () => [...existingDelegates(), ...agents];
+    } else {
+      this.config.canDelegateTo = () => agents;
+    }
+  }
+  // Public method to ensure agent exists in backend (with upsert behavior)
+  async init() {
+    if (this.initialized) return;
+    try {
+      await this.upsertAgent();
+      await this.loadDataComponents();
+      await this.loadArtifactComponents();
+      await this.saveToolsAndRelations();
+      await this.saveDataComponents();
+      await this.saveArtifactComponents();
+      logger4.info(
+        {
+          agentId: this.getId()
+        },
+        "Agent initialized successfully"
+      );
+      this.initialized = true;
+    } catch (error) {
+      logger4.error(
+        {
+          agentId: this.getId(),
+          error: error instanceof Error ? error.message : "Unknown error"
+        },
+        "Failed to initialize agent"
+      );
+      throw error;
+    }
+  }
+  // Private method to upsert agent (create or update)
+  async upsertAgent() {
+    const agentData = {
+      id: this.getId(),
+      name: this.config.name,
+      description: this.config.description || "",
+      prompt: this.config.prompt,
+      conversationHistoryConfig: this.config.conversationHistoryConfig,
+      models: this.config.models,
+      stopWhen: this.config.stopWhen
+    };
+    const updateResponse = await fetch(
+      `${this.baseURL}/tenants/${this.tenantId}/crud/agents/${this.getId()}`,
+      {
+        method: "PUT",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify(agentData)
+      }
+    );
+    if (updateResponse.ok) {
+      logger4.info(
+        {
+          agentId: this.getId()
+        },
+        "Agent updated successfully"
+      );
+      return;
+    }
+    if (updateResponse.status === 404) {
+      logger4.info(
+        {
+          agentId: this.getId()
+        },
+        "Agent not found, creating new agent"
+      );
+      const createResponse = await fetch(
+        `${this.baseURL}/tenants/${this.tenantId}/crud/agents`,
+        {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json"
+          },
+          body: JSON.stringify(agentData)
+        }
+      );
+      if (!createResponse.ok) {
+        const errorText2 = await createResponse.text().catch(() => "Unknown error");
+        throw new Error(
+          `Failed to create agent: ${createResponse.status} ${createResponse.statusText} - ${errorText2}`
+        );
+      }
+      logger4.info(
+        {
+          agentId: this.getId()
+        },
+        "Agent created successfully"
+      );
+      return;
+    }
+    const errorText = await updateResponse.text().catch(() => "Unknown error");
+    throw new Error(
+      `Failed to update agent: ${updateResponse.status} ${updateResponse.statusText} - ${errorText}`
+    );
+  }
+  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);
+      }
+    }
+  }
+  async saveDataComponents() {
+    logger4.info(
+      { dataComponents: this.config.dataComponents },
+      "dataComponents and config"
+    );
+    const components = resolveGetter(this.config.dataComponents);
+    if (components) {
+      for (const dataComponent2 of components) {
+        await this.createDataComponent(dataComponent2);
+      }
+    }
+  }
+  async saveArtifactComponents() {
+    logger4.info(
+      { artifactComponents: this.config.artifactComponents },
+      "artifactComponents and config"
+    );
+    const components = resolveGetter(this.config.artifactComponents);
+    if (components) {
+      for (const artifactComponent2 of components) {
+        await this.createArtifactComponent(artifactComponent2);
+      }
+    }
+  }
+  async loadDataComponents() {
+    try {
+      const existingComponents = [];
+      const dbDataComponents = existingComponents.map((component) => ({
+        id: component.id,
+        tenantId: component.tenantId || this.tenantId,
+        projectId: component.projectId || this.projectId,
+        name: component.name,
+        description: component.description,
+        props: component.props,
+        createdAt: component.createdAt,
+        updatedAt: component.updatedAt
+      }));
+      const configComponents = resolveGetter(this.config.dataComponents) || [];
+      const allComponents = [...dbDataComponents, ...configComponents];
+      const uniqueComponents = allComponents.reduce((acc, component) => {
+        const existingIndex = acc.findIndex((c) => c.id === component.id);
+        if (existingIndex >= 0) {
+          acc[existingIndex] = component;
+        } else {
+          acc.push(component);
+        }
+        return acc;
+      }, []);
+      this.config.dataComponents = uniqueComponents;
+      logger4.info(
+        {
+          agentId: this.getId(),
+          dbComponentCount: dbDataComponents.length,
+          configComponentCount: configComponents.length,
+          totalComponentCount: uniqueComponents.length
+        },
+        "Loaded and merged data components"
+      );
+    } catch (error) {
+      logger4.error(
+        {
+          agentId: this.getId(),
+          error: error instanceof Error ? error.message : "Unknown error"
+        },
+        "Failed to load data components from database"
+      );
+    }
+  }
+  async loadArtifactComponents() {
+    try {
+      const existingComponents = [];
+      const dbArtifactComponents = existingComponents.map((component) => ({
+        id: component.id,
+        tenantId: component.tenantId || this.tenantId,
+        projectId: component.projectId || this.projectId,
+        name: component.name,
+        description: component.description,
+        summaryProps: component.summaryProps,
+        fullProps: component.fullProps,
+        createdAt: component.createdAt,
+        updatedAt: component.updatedAt
+      }));
+      const configComponents = resolveGetter(this.config.artifactComponents) || [];
+      const allComponents = [...dbArtifactComponents, ...configComponents];
+      const uniqueComponents = allComponents.reduce((acc, component) => {
+        const existingIndex = acc.findIndex((c) => c.id === component.id);
+        if (existingIndex >= 0) {
+          acc[existingIndex] = component;
+        } else {
+          acc.push(component);
+        }
+        return acc;
+      }, []);
+      this.config.artifactComponents = uniqueComponents;
+      logger4.info(
+        {
+          agentId: this.getId(),
+          dbComponentCount: dbArtifactComponents.length,
+          configComponentCount: configComponents.length,
+          totalComponentCount: uniqueComponents.length
+        },
+        "Loaded and merged artifact components"
+      );
+    } catch (error) {
+      logger4.error(
+        {
+          agentId: this.getId(),
+          error: error instanceof Error ? error.message : "Unknown error"
+        },
+        "Failed to load artifact components from database"
+      );
+    }
+  }
+  async createTool(toolId, toolConfig) {
+    try {
+      if (toolConfig.type === "function") {
+        logger4.info(
+          {
+            agentId: this.getId(),
+            toolId,
+            toolType: "function"
+          },
+          "Skipping function tool creation - will be handled at runtime"
+        );
+        return;
+      }
+      const { Tool: Tool2 } = await Promise.resolve().then(() => (init_tool(), tool_exports));
+      let tool2;
+      if (toolConfig instanceof Tool2) {
+        logger4.info(
+          {
+            agentId: this.getId(),
+            toolId,
+            toolType: "Tool"
+          },
+          "Initializing Tool instance"
+        );
+        tool2 = toolConfig;
+        await tool2.init();
+      } else {
+        logger4.info(
+          {
+            agentId: this.getId(),
+            toolId,
+            toolType: "legacy-config"
+          },
+          "Creating Tool from config"
+        );
+        tool2 = new Tool2({
+          id: toolId,
+          tenantId: this.tenantId,
+          name: toolConfig.name || toolId,
+          description: toolConfig.description || `MCP tool: ${toolId}`,
+          serverUrl: toolConfig.config?.serverUrl || toolConfig.serverUrl || "http://localhost:3000",
+          activeTools: toolConfig.config?.mcp?.activeTools,
+          credential: toolConfig.credential
+        });
+        await tool2.init();
+      }
+      await this.createAgentToolRelation(tool2.getId());
+      logger4.info(
+        {
+          agentId: this.getId(),
+          toolId: tool2.getId()
+        },
+        "Tool created and linked to agent"
+      );
+    } catch (error) {
+      logger4.error(
+        {
+          agentId: this.getId(),
+          toolId,
+          error: error instanceof Error ? error.message : "Unknown error"
+        },
+        "Failed to create tool"
+      );
+    }
+  }
+  async createDataComponent(dataComponent2) {
+    try {
+      const dc = new DataComponent({
+        tenantId: this.tenantId,
+        projectId: this.projectId,
+        name: dataComponent2.name,
+        description: dataComponent2.description,
+        props: dataComponent2.props
+      });
+      await dc.init();
+      await this.createAgentDataComponentRelation(dc.getId());
+      logger4.info(
+        {
+          agentId: this.getId(),
+          dataComponentId: dc.getId()
+        },
+        "DataComponent created and linked to agent"
+      );
+    } catch (error) {
+      logger4.error(
+        {
+          agentId: this.getId(),
+          dataComponentName: dataComponent2.name,
+          error: error instanceof Error ? error.message : "Unknown error"
+        },
+        "Failed to create data component"
+      );
+      throw error;
+    }
+  }
+  async createArtifactComponent(artifactComponent2) {
+    try {
+      const ac = new ArtifactComponent({
+        tenantId: this.tenantId,
+        projectId: this.projectId,
+        name: artifactComponent2.name,
+        description: artifactComponent2.description,
+        summaryProps: artifactComponent2.summaryProps,
+        fullProps: artifactComponent2.fullProps
+      });
+      await ac.init();
+      await this.createAgentArtifactComponentRelation(ac.getId());
+      logger4.info(
+        {
+          agentId: this.getId(),
+          artifactComponentId: ac.getId()
+        },
+        "ArtifactComponent created and linked to agent"
+      );
+    } catch (error) {
+      logger4.error(
+        {
+          agentId: this.getId(),
+          artifactComponentName: artifactComponent2.name,
+          error: error instanceof Error ? error.message : "Unknown error"
+        },
+        "Failed to create artifact component"
+      );
+      throw error;
+    }
+  }
+  async createAgentDataComponentRelation(dataComponentId) {
+    const relationResponse = await fetch(
+      `${this.baseURL}/tenants/${this.tenantId}/crud/agent-data-components`,
+      {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({
+          id: `${this.getId()}-dc-${dataComponentId}`,
+          tenantId: this.tenantId,
+          agentId: this.getId(),
+          dataComponentId
+        })
+      }
+    );
+    if (!relationResponse.ok) {
+      throw new Error(
+        `Failed to create agent-dataComponent relation: ${relationResponse.status} ${relationResponse.statusText}`
+      );
+    }
+    logger4.info(
+      {
+        agentId: this.getId(),
+        dataComponentId
+      },
+      "Created agent-dataComponent relation"
+    );
+  }
+  async createAgentArtifactComponentRelation(artifactComponentId) {
+    const relationResponse = await fetch(
+      `${this.baseURL}/tenants/${this.tenantId}/crud/agent-artifact-components`,
+      {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({
+          id: crypto.randomUUID(),
+          tenantId: this.tenantId,
+          agentId: this.getId(),
+          artifactComponentId
+        })
+      }
+    );
+    if (!relationResponse.ok) {
+      throw new Error(
+        `Failed to create agent-artifactComponent relation: ${relationResponse.status} ${relationResponse.statusText}`
+      );
+    }
+    logger4.info(
+      {
+        agentId: this.getId(),
+        artifactComponentId
+      },
+      "Created agent-artifactComponent relation"
+    );
+  }
+  async createAgentToolRelation(toolId) {
+    const relationResponse = await fetch(
+      `${this.baseURL}/tenants/${this.tenantId}/crud/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
+        })
+      }
+    );
+    if (!relationResponse.ok) {
+      const errorBody = await relationResponse.text().catch(() => "Unknown error");
+      throw new Error(
+        `Failed to create agent-tool relation: ${relationResponse.status} - ${errorBody}`
+      );
+    }
+  }
+};
+init_tool();
+function agent(config) {
+  return new Agent(config);
+}
+function credential(config) {
+  return agentsCore.CredentialReferenceApiInsertSchema.parse(config);
+}
+var ToolConfigSchema = zod.z.object({
+  id: zod.z.string().optional(),
+  name: zod.z.string(),
+  description: zod.z.string(),
+  parameters: zod.z.record(zod.z.string(), zod.z.any()).optional(),
+  schema: zod.z.unknown().optional()
+});
+ToolConfigSchema.extend({
+  execute: zod.z.any()
+  // Function - validated separately at runtime
+});
+function tool(config) {
+  if (typeof config.execute !== "function") {
+    throw new Error("execute must be a function");
+  }
+  const { execute, ...configWithoutFunction } = config;
+  const validatedConfig = ToolConfigSchema.parse(configWithoutFunction);
+  const fullConfig = { ...validatedConfig, execute };
+  const computedId = fullConfig.name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+  return {
+    id: computedId,
+    name: fullConfig.name,
+    description: fullConfig.description,
+    execute: fullConfig.execute,
+    parameters: fullConfig.parameters,
+    schema: fullConfig.schema,
+    type: "function"
+  };
+}
+zod.z.object({
+  id: zod.z.string().optional(),
+  name: zod.z.string(),
+  description: zod.z.string(),
+  tenantId: zod.z.string().optional(),
+  // Deployment configuration
+  deployment: zod.z.enum(["local", "remote"]).optional(),
+  // For local MCP servers
+  port: zod.z.number().optional(),
+  // For remote MCP servers
+  serverUrl: zod.z.string().optional(),
+  credential: agentsCore.CredentialReferenceApiInsertSchema.optional(),
+  // Additional configuration
+  parameters: zod.z.record(zod.z.string(), zod.z.any()).optional(),
+  transport: zod.z.enum(["ipc", "http", "sse"]).optional(),
+  activeTools: zod.z.array(zod.z.string()).optional(),
+  headers: zod.z.record(zod.z.string(), zod.z.string()).optional()
+});
+function mcpServer(config) {
+  const deployment = config.deployment || (config.execute ? "local" : "remote");
+  const id = config.id || config.name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+  if (deployment === "local") {
+    if (!config.execute) {
+      throw new Error("Local MCP server requires an execute function");
+    }
+    throw new Error(
+      "Local MCP servers are no longer supported. Please use remote MCP servers instead."
+    );
+  } else {
+    if (!config.serverUrl) {
+      throw new Error("Remote MCP server requires a serverUrl");
+    }
+    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
+    });
+  }
+}
+function mcpTool(config) {
+  const validatedConfig = agentsCore.MCPToolConfigSchema.parse(config);
+  return new exports.Tool(validatedConfig);
+}
+var TransferConfigSchema = zod.z.object({
+  agent: zod.z.instanceof(Agent),
+  description: zod.z.string().optional()
+});
+var TransferSchema = TransferConfigSchema.extend({
+  condition: zod.z.any().optional()
+  // Function - validated separately at runtime when present
+});
+function transfer(targetAgent, description, condition) {
+  if (condition !== void 0 && typeof condition !== "function") {
+    throw new Error("condition must be a function when provided");
+  }
+  const config = {
+    agent: targetAgent,
+    description: description || `Hand off to ${targetAgent.getName()}`,
+    condition
+  };
+  return TransferSchema.parse(config);
+}
+function artifactComponent(config) {
+  return new ArtifactComponent({
+    ...config,
+    tenantId: config.tenantId || "default",
+    projectId: config.projectId || "default"
+  });
+}
+function dataComponent(config) {
+  return new DataComponent({
+    ...config,
+    tenantId: config.tenantId || "default",
+    projectId: config.projectId || "default"
+  });
+}
+
+// src/environment-settings.ts
+var globalSettingKeys = /* @__PURE__ */ new Set();
+function registerSettingKeys(settingIds) {
+  settingIds.forEach((id) => globalSettingKeys.add(id));
+}
+function getAllEnvironmentSettingKeys() {
+  return Array.from(globalSettingKeys);
+}
+function createEnvironmentSettings(environments) {
+  const environmentMap = environments;
+  const environmentNames = Object.keys(environments);
+  const allEnvironments = Object.values(environments);
+  return {
+    getEnvironmentSetting: async (key) => {
+      if (environmentNames.length === 0) {
+        throw new Error(
+          `No environments provided to createEnvironmentSettings().
+
+You must pass environments as an object: createEnvironmentSettings({ development, production })`
+        );
+      }
+      const currentEnv = process.env.NODE_ENV || "development";
+      const matchingEnv = environmentMap[currentEnv];
+      if (!matchingEnv) {
+        throw new Error(
+          `Environment '${currentEnv}' not found.
+
+Available environments: ${environmentNames.join(", ")}
+Set NODE_ENV to one of the available environments or add a '${currentEnv}' environment.`
+        );
+      }
+      if (!matchingEnv.credentials?.[key]) {
+        throw new Error(
+          `Credential environment setting '${key}' not found in environment '${currentEnv}'.
+
+`
+        );
+      }
+      return matchingEnv.credentials[key];
+    },
+    getEnvironmentSettingKeys: () => {
+      if (allEnvironments.length === 0) return [];
+      if (allEnvironments.length === 1)
+        return Object.keys(allEnvironments[0].credentials || {});
+      let commonKeys = new Set(
+        Object.keys(allEnvironments[0].credentials || {})
+      );
+      for (let i = 1; i < allEnvironments.length; i++) {
+        const envKeys = new Set(
+          Object.keys(allEnvironments[i].credentials || {})
+        );
+        commonKeys = new Set([...commonKeys].filter((key) => envKeys.has(key)));
+      }
+      return Array.from(commonKeys);
+    },
+    hasEnvironmentSetting: (key) => {
+      if (allEnvironments.length === 0) return false;
+      if (allEnvironments.length === 1)
+        return !!(allEnvironments[0].credentials && key in allEnvironments[0].credentials);
+      return allEnvironments.every(
+        (env) => env.credentials && key in env.credentials
+      );
+    }
+  };
+}
+function registerEnvironmentSettings(config) {
+  if (config.credentials) {
+    const settingIds = Object.keys(config.credentials);
+    registerSettingKeys(settingIds);
+  }
+  return config;
+}
+var logger5 = agentsCore.getLogger("external-agent-builder");
+var ExternalAgent = class {
+  constructor(config) {
+    __publicField(this, "config");
+    __publicField(this, "type", "external");
+    __publicField(this, "initialized", false);
+    __publicField(this, "tenantId");
+    __publicField(this, "baseURL");
+    this.config = { ...config, type: "external" };
+    this.tenantId = config.tenantId || "default";
+    this.baseURL = process.env.INKEEP_API_URL || "http://localhost:3002";
+    logger5.debug(
+      {
+        externalAgentName: this.config.name,
+        baseUrl: this.config.baseUrl,
+        tenantId: this.config.tenantId
+      },
+      "External Agent constructor initialized"
+    );
+  }
+  /**
+   * Initialize the external agent by upserting it in the database
+   */
+  async init() {
+    if (this.initialized) return;
+    try {
+      await this.upsertExternalAgent();
+      logger5.info(
+        {
+          externalAgentId: this.getId()
+        },
+        "External agent initialized successfully"
+      );
+      this.initialized = true;
+    } catch (error) {
+      logger5.error(
+        {
+          externalAgentId: this.getId(),
+          error: error instanceof Error ? error.message : "Unknown error"
+        },
+        "Failed to initialize external agent"
+      );
+      throw error;
+    }
+  }
+  // Compute ID from name using a simple slug transformation
+  getId() {
+    return this.config.id;
+  }
+  // Private method to upsert external agent (create or update)
+  async upsertExternalAgent() {
+    const externalAgentData = {
+      id: this.getId(),
+      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
+    };
+    const updateResponse = await fetch(
+      `${this.baseURL}/tenants/${this.tenantId}/crud/external-agents/${this.getId()}`,
+      {
+        method: "PUT",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify(externalAgentData)
+      }
+    );
+    if (updateResponse.ok) {
+      logger5.info(
+        {
+          externalAgentId: this.getId()
+        },
+        "External agent updated successfully"
+      );
+      return;
+    }
+    if (updateResponse.status === 404) {
+      logger5.info(
+        {
+          externalAgentId: this.getId()
+        },
+        "External agent not found, creating new external agent"
+      );
+      const createResponse = await fetch(
+        `${this.baseURL}/tenants/${this.tenantId}/crud/external-agents`,
+        {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json"
+          },
+          body: JSON.stringify(externalAgentData)
+        }
+      );
+      if (!createResponse.ok) {
+        const errorText2 = await createResponse.text().catch(() => "Unknown error");
+        throw new Error(
+          `Failed to create external agent: ${createResponse.status} ${createResponse.statusText} - ${errorText2}`
+        );
+      }
+      logger5.info(
+        {
+          externalAgentId: this.getId()
+        },
+        "External agent created successfully"
+      );
+      return;
+    }
+    const errorText = await updateResponse.text().catch(() => "Unknown error");
+    throw new Error(
+      `Failed to update external agent: ${updateResponse.status} ${updateResponse.statusText} - ${errorText}`
+    );
+  }
+  /**
+   * Get the external agent configuration
+   */
+  getConfig() {
+    return { ...this.config };
+  }
+  /**
+   * Get the external agent name
+   */
+  getName() {
+    return this.config.name;
+  }
+  /**
+   * Get the external agent base URL
+   */
+  getBaseUrl() {
+    return this.config.baseUrl;
+  }
+  /**
+   * Get the tenant ID
+   */
+  getTenantId() {
+    return this.tenantId;
+  }
+  getDescription() {
+    return this.config.description || "";
+  }
+  getCredentialReferenceId() {
+    return this.config.credentialReference?.id || void 0;
+  }
+  getHeaders() {
+    return this.config.headers;
+  }
+};
+function externalAgent(config) {
+  return new ExternalAgent(config);
+}
+function externalAgents(configs) {
+  const builders = {};
+  for (const [name, config] of Object.entries(configs)) {
+    builders[name] = externalAgent(config);
+  }
+  return builders;
+}
+var logger6 = agentsCore.getLogger("graphFullClient");
+async function updateFullGraphViaAPI(tenantId, projectId, apiUrl, graphId, graphData) {
+  logger6.info(
+    {
+      tenantId,
+      projectId,
+      graphId,
+      apiUrl
+    },
+    "Updating full graph via API"
+  );
+  const url = `${apiUrl}/tenants/${tenantId}/crud/projects/${projectId}/graph/${graphId}`;
+  const response = await fetch(url, {
+    method: "PUT",
+    headers: {
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify(graphData)
+  });
+  if (!response.ok) {
+    const errorText = await response.text();
+    let errorMessage = `Failed to update graph: ${response.status} ${response.statusText}`;
+    try {
+      const errorJson = JSON.parse(errorText);
+      if (errorJson.error) {
+        errorMessage = errorJson.error;
+      }
+    } catch {
+      if (errorText) {
+        errorMessage = errorText;
+      }
+    }
+    logger6.error(
+      {
+        status: response.status,
+        error: errorMessage
+      },
+      "Failed to update graph via API"
+    );
+    throw new Error(errorMessage);
+  }
+  const result = await response.json();
+  logger6.info(
+    {
+      graphId
+    },
+    "Successfully updated graph via API"
+  );
+  return result.data;
+}
+
+// src/graph.ts
+var logger7 = agentsCore.getLogger("graph");
+function resolveGetter2(value) {
+  if (typeof value === "function") {
+    return value();
+  }
+  return value;
+}
+var AgentGraph = class {
+  constructor(config) {
+    __publicField(this, "agents", []);
+    __publicField(this, "agentMap", /* @__PURE__ */ new Map());
+    __publicField(this, "defaultAgent");
+    __publicField(this, "baseURL");
+    __publicField(this, "tenantId");
+    __publicField(this, "projectId");
+    __publicField(this, "graphId");
+    __publicField(this, "graphName");
+    __publicField(this, "graphDescription");
+    __publicField(this, "initialized", false);
+    __publicField(this, "contextConfig");
+    // ContextConfigBuilder
+    __publicField(this, "credentials");
+    __publicField(this, "models");
+    __publicField(this, "statusUpdateSettings");
+    __publicField(this, "graphPrompt");
+    __publicField(this, "stopWhen");
+    __publicField(this, "dbClient");
+    this.defaultAgent = config.defaultAgent;
+    this.tenantId = config.tenantId || "default";
+    this.projectId = "default";
+    this.graphId = config.id;
+    this.graphName = config.name || this.graphId;
+    this.graphDescription = config.description;
+    this.baseURL = process.env.INKEEP_API_URL || "http://localhost:3002";
+    this.contextConfig = config.contextConfig;
+    this.credentials = resolveGetter2(config.credentials);
+    this.models = config.models;
+    const dbUrl = process.env.ENVIRONMENT === "test" ? ":memory:" : process.env.DB_FILE_NAME || process.env.DATABASE_URL || ":memory:";
+    this.dbClient = agentsCore.createDatabaseClient({
+      url: dbUrl
+    });
+    this.statusUpdateSettings = config.statusUpdates;
+    this.graphPrompt = config.graphPrompt;
+    this.stopWhen = config.stopWhen ? {
+      transferCountIs: config.stopWhen.transferCountIs
+    } : void 0;
+    this.agents = resolveGetter2(config.agents) || [];
+    this.agentMap = new Map(this.agents.map((agent2) => [agent2.getId(), agent2]));
+    if (this.defaultAgent) {
+      this.agents.push(this.defaultAgent);
+      this.agentMap.set(this.defaultAgent.getId(), this.defaultAgent);
+    }
+    if (this.models) {
+      this.propagateImmediateModelSettings();
+    }
+    logger7.info(
+      {
+        graphId: this.graphId,
+        tenantId: this.tenantId,
+        agentCount: this.agents.length,
+        defaultAgent: this.defaultAgent?.getName()
+      },
+      "AgentGraph created"
+    );
+  }
+  /**
+   * Set or update the configuration (tenantId, projectId and apiUrl)
+   * This is used by the CLI to inject configuration from inkeep.config.ts
+   */
+  setConfig(tenantId, projectId, apiUrl) {
+    if (this.initialized) {
+      throw new Error("Cannot set config after graph has been initialized");
+    }
+    this.tenantId = tenantId;
+    this.projectId = projectId;
+    this.baseURL = apiUrl;
+    for (const agent2 of this.agents) {
+      if (this.isInternalAgent(agent2)) {
+        const internalAgent = agent2;
+        if (!internalAgent.config.tenantId) {
+          internalAgent.config.tenantId = tenantId;
+        }
+        const tools = internalAgent.getTools();
+        for (const [_, toolInstance] of Object.entries(tools)) {
+          if (toolInstance && typeof toolInstance === "object" && toolInstance.config) {
+            if (!toolInstance.config.tenantId) {
+              toolInstance.config.tenantId = tenantId;
+            }
+            if ("baseURL" in toolInstance && !toolInstance.baseURL) {
+              toolInstance.baseURL = apiUrl;
+            }
+          }
+        }
+      }
+    }
+    if (this.contextConfig && !this.contextConfig.tenantId) {
+      this.contextConfig.tenantId = tenantId;
+    }
+    logger7.info(
+      {
+        graphId: this.graphId,
+        tenantId: this.tenantId,
+        projectId: this.projectId,
+        apiUrl: this.baseURL
+      },
+      "Graph configuration updated"
+    );
+  }
+  /**
+   * Convert the AgentGraph to FullGraphDefinition format for the new graph endpoint
+   */
+  async toFullGraphDefinition() {
+    const agentsObject = {};
+    for (const agent2 of this.agents) {
+      if (this.isInternalAgent(agent2)) {
+        const internalAgent = agent2;
+        const transfers = internalAgent.getTransfers();
+        const delegates = internalAgent.getDelegates();
+        const tools = [];
+        const agentTools = internalAgent.getTools();
+        for (const [toolName, toolInstance] of Object.entries(agentTools)) {
+          if (toolInstance && typeof toolInstance === "object") {
+            const toolId = toolInstance.getId?.() || toolInstance.id || toolName;
+            tools.push(toolId);
+          }
+        }
+        const dataComponents = [];
+        const agentDataComponents = internalAgent.getDataComponents();
+        if (agentDataComponents) {
+          for (const dataComponent2 of agentDataComponents) {
+            const dataComponentId = dataComponent2.id || dataComponent2.name.toLowerCase().replace(/\s+/g, "-");
+            dataComponents.push(dataComponentId);
+          }
+        }
+        const artifactComponents = [];
+        const agentArtifactComponents = internalAgent.getArtifactComponents();
+        if (agentArtifactComponents) {
+          for (const artifactComponent2 of agentArtifactComponents) {
+            const artifactComponentId = artifactComponent2.id || artifactComponent2.name.toLowerCase().replace(/\s+/g, "-");
+            artifactComponents.push(artifactComponentId);
+          }
+        }
+        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()),
+          tools,
+          dataComponents: dataComponents.length > 0 ? dataComponents : void 0,
+          artifactComponents: artifactComponents.length > 0 ? artifactComponents : void 0,
+          type: "internal"
+        };
+      } else {
+        const externalAgent2 = agent2;
+        agentsObject[externalAgent2.getId()] = {
+          id: externalAgent2.getId(),
+          name: externalAgent2.getName(),
+          description: externalAgent2.getDescription(),
+          baseUrl: externalAgent2.getBaseUrl(),
+          credentialReferenceId: externalAgent2.getCredentialReferenceId(),
+          headers: externalAgent2.getHeaders(),
+          tools: [],
+          // External agents don't have tools in this context
+          type: "external"
+        };
+      }
+    }
+    const toolsObject = {};
+    for (const agent2 of this.agents) {
+      if (!agent2.getTransfers) {
+        continue;
+      }
+      const internalAgent = agent2;
+      const agentTools = internalAgent.getTools();
+      for (const [toolName, toolInstance] of Object.entries(agentTools)) {
+        if (toolInstance && typeof toolInstance === "object") {
+          const toolId = toolInstance.getId?.() || toolInstance.id || toolName;
+          if (!toolsObject[toolId]) {
+            let toolConfig;
+            if (toolInstance.config?.serverUrl) {
+              toolConfig = {
+                type: "mcp",
+                mcp: {
+                  server: {
+                    url: toolInstance.config.serverUrl
+                  }
+                }
+              };
+            } else if (toolInstance.config?.type === "mcp") {
+              toolConfig = toolInstance.config;
+            } else {
+              toolConfig = {
+                type: "function",
+                parameters: toolInstance.parameters || {}
+              };
+            }
+            const toolData = {
+              id: toolId,
+              name: toolInstance.config?.name || toolInstance.name || toolName,
+              config: toolConfig,
+              status: toolInstance.getStatus?.() || toolInstance.status || "unknown"
+            };
+            if (toolInstance.config?.imageUrl) {
+              toolData.imageUrl = toolInstance.config.imageUrl;
+            }
+            if (toolInstance.config?.headers) {
+              toolData.headers = toolInstance.config.headers;
+            }
+            if (toolInstance.capabilities) {
+              toolData.capabilities = toolInstance.capabilities;
+            }
+            if (toolInstance.lastHealthCheck) {
+              toolData.lastHealthCheck = toolInstance.lastHealthCheck;
+            }
+            if (toolInstance.availableTools) {
+              toolData.availableTools = toolInstance.availableTools;
+            }
+            if (toolInstance.lastError) {
+              toolData.lastError = toolInstance.lastError;
+            }
+            if (toolInstance.lastToolsSync) {
+              toolData.lastToolsSync = toolInstance.lastToolsSync;
+            }
+            if (toolInstance.getCredentialReferenceId?.()) {
+              toolData.credentialReferenceId = toolInstance.getCredentialReferenceId();
+            }
+            toolsObject[toolId] = toolData;
+          }
+        }
+      }
+    }
+    const dataComponentsObject = {};
+    for (const agent2 of this.agents) {
+      if (!this.isInternalAgent(agent2)) {
+        continue;
+      }
+      const internalAgent = agent2;
+      const agentDataComponents = internalAgent.getDataComponents();
+      if (agentDataComponents) {
+        for (const dataComponent2 of agentDataComponents) {
+          const dataComponentId = dataComponent2.id || dataComponent2.name.toLowerCase().replace(/\s+/g, "-");
+          if (!dataComponentsObject[dataComponentId]) {
+            dataComponentsObject[dataComponentId] = {
+              id: dataComponentId,
+              name: dataComponent2.name,
+              description: dataComponent2.description || "",
+              props: dataComponent2.props || {}
+            };
+          }
+        }
+      }
+    }
+    const artifactComponentsObject = {};
+    for (const agent2 of this.agents) {
+      if (!this.isInternalAgent(agent2)) {
+        continue;
+      }
+      const internalAgent = agent2;
+      const agentArtifactComponents = internalAgent.getArtifactComponents();
+      if (agentArtifactComponents) {
+        for (const artifactComponent2 of agentArtifactComponents) {
+          const artifactComponentId = artifactComponent2.id || artifactComponent2.name.toLowerCase().replace(/\s+/g, "-");
+          if (!artifactComponentsObject[artifactComponentId]) {
+            artifactComponentsObject[artifactComponentId] = {
+              id: artifactComponentId,
+              name: artifactComponent2.name,
+              description: artifactComponent2.description || "",
+              summaryProps: artifactComponent2.summaryProps || {},
+              fullProps: artifactComponent2.fullProps || {}
+            };
+          }
+        }
+      }
+    }
+    return {
+      id: this.graphId,
+      name: this.graphName,
+      description: this.graphDescription,
+      defaultAgentId: this.defaultAgent?.getId() || "",
+      agents: agentsObject,
+      tools: toolsObject,
+      contextConfig: this.contextConfig?.toObject(),
+      credentialReferences: this.credentials?.map((credentialReference) => ({
+        type: credentialReference.type,
+        id: credentialReference.id,
+        credentialStoreId: credentialReference.credentialStoreId,
+        retrievalParams: credentialReference.retrievalParams || {}
+      })),
+      models: this.models,
+      statusUpdates: this.statusUpdateSettings,
+      graphPrompt: this.graphPrompt,
+      dataComponents: Object.keys(dataComponentsObject).length > 0 ? dataComponentsObject : void 0,
+      artifactComponents: Object.keys(artifactComponentsObject).length > 0 ? artifactComponentsObject : void 0,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  /**
+   * Initialize all tools in all agents (especially IPCTools that need MCP server URLs)
+   */
+  async initializeAllTools() {
+    logger7.info({ graphId: this.graphId }, "Initializing all tools in graph");
+    const toolInitPromises = [];
+    for (const agent2 of this.agents) {
+      if (!agent2.getTools) {
+        continue;
+      }
+      const internalAgent = agent2;
+      const agentTools = internalAgent.getTools();
+      for (const [toolName, toolInstance] of Object.entries(agentTools)) {
+        if (toolInstance && typeof toolInstance === "object") {
+          if (typeof toolInstance.init === "function") {
+            toolInitPromises.push(
+              (async () => {
+                try {
+                  const skipDbRegistration = toolInstance.constructor.name === "IPCTool" || toolInstance.constructor.name === "HostedTool" || toolInstance.constructor.name === "Tool";
+                  if (typeof toolInstance.init === "function") {
+                    if (skipDbRegistration) {
+                      await toolInstance.init({
+                        skipDatabaseRegistration: true
+                      });
+                    } else {
+                      await toolInstance.init();
+                    }
+                  }
+                  logger7.debug(
+                    {
+                      agentId: agent2.getId(),
+                      toolName,
+                      toolType: toolInstance.constructor.name,
+                      skipDbRegistration
+                    },
+                    "Tool initialized successfully"
+                  );
+                } catch (error) {
+                  logger7.error(
+                    {
+                      agentId: agent2.getId(),
+                      toolName,
+                      error: error instanceof Error ? error.message : "Unknown error"
+                    },
+                    "Failed to initialize tool"
+                  );
+                  throw error;
+                }
+              })()
+            );
+          }
+        }
+      }
+    }
+    await Promise.all(toolInitPromises);
+    logger7.info(
+      { graphId: this.graphId, toolCount: toolInitPromises.length },
+      "All tools initialized successfully"
+    );
+  }
+  /**
+   * Initialize the graph and all agents in the backend using the new graph endpoint
+   */
+  async init() {
+    if (this.initialized) {
+      logger7.info({ graphId: this.graphId }, "Graph already initialized");
+      return;
+    }
+    logger7.info(
+      {
+        graphId: this.graphId,
+        agentCount: this.agents.length
+      },
+      "Initializing agent graph using new graph endpoint"
+    );
+    try {
+      await this.initializeAllTools();
+      await this.applyModelInheritance();
+      const graphDefinition = await this.toFullGraphDefinition();
+      logger7.info(
+        {
+          graphId: this.graphId,
+          mode: "api-client",
+          apiUrl: this.baseURL
+        },
+        "Using API client to create/update graph"
+      );
+      const createdGraph = await updateFullGraphViaAPI(
+        this.tenantId,
+        this.projectId,
+        this.baseURL,
+        this.graphId,
+        graphDefinition
+      );
+      logger7.info(
+        {
+          graphId: this.graphId,
+          agentCount: Object.keys(createdGraph.agents || {}).length
+        },
+        "Agent graph initialized successfully using graph endpoint"
+      );
+      this.initialized = true;
+    } catch (error) {
+      logger7.error(
+        {
+          graphId: this.graphId,
+          error: error instanceof Error ? error.message : "Unknown error"
+        },
+        "Failed to initialize agent graph using graph endpoint"
+      );
+      throw error;
+    }
+  }
+  /**
+   * Legacy initialization method - kept for backward compatibility
+   * Initialize the graph and all agents in the backend using individual endpoints
+   */
+  async initLegacy() {
+    if (this.initialized) {
+      logger7.info({ graphId: this.graphId }, "Graph already initialized");
+      return;
+    }
+    logger7.info(
+      {
+        graphId: this.graphId,
+        agentCount: this.agents.length
+      },
+      "Initializing agent graph"
+    );
+    try {
+      if (this.contextConfig) {
+        await this.contextConfig.init();
+        logger7.info(
+          {
+            graphId: this.graphId,
+            contextConfigId: this.contextConfig.getId()
+          },
+          "Context configuration initialized for graph"
+        );
+      }
+      const initPromises = this.agents.map(async (agent2) => {
+        try {
+          agent2.config.graphId = this.graphId;
+          await agent2.init();
+          logger7.debug(
+            {
+              agentId: agent2.getId(),
+              graphId: this.graphId
+            },
+            "Agent initialized in graph"
+          );
+        } catch (error) {
+          logger7.error(
+            {
+              agentId: agent2.getId(),
+              graphId: this.graphId,
+              error: error instanceof Error ? error.message : "Unknown error"
+            },
+            "Failed to initialize agent in graph"
+          );
+          throw error;
+        }
+      });
+      await Promise.all(initPromises);
+      await this.saveToDatabase();
+      await this.createExternalAgents();
+      await this.createAgentRelations();
+      await this.saveRelations();
+      this.initialized = true;
+      logger7.info(
+        {
+          graphId: this.graphId,
+          agentCount: this.agents.length
+        },
+        "Agent graph initialized successfully"
+      );
+    } catch (error) {
+      logger7.error(
+        {
+          graphId: this.graphId,
+          error: error instanceof Error ? error.message : "Unknown error"
+        },
+        "Failed to initialize agent graph"
+      );
+      throw error;
+    }
+  }
+  /**
+   * Generate a response using the default agent
+   */
+  async generate(input, options) {
+    await this._init();
+    if (!this.defaultAgent) {
+      throw new Error("No default agent configured for this graph");
+    }
+    logger7.info(
+      {
+        graphId: this.graphId,
+        defaultAgent: this.defaultAgent.getName(),
+        conversationId: options?.conversationId
+      },
+      "Generating response with default agent"
+    );
+    const response = await this.executeWithBackend(input, options);
+    return response;
+  }
+  /**
+   * Stream a response using the default agent
+   */
+  async stream(input, options) {
+    await this._init();
+    if (!this.defaultAgent) {
+      throw new Error("No default agent configured for this graph");
+    }
+    logger7.info(
+      {
+        graphId: this.graphId,
+        defaultAgent: this.defaultAgent.getName(),
+        conversationId: options?.conversationId
+      },
+      "Streaming response with default agent"
+    );
+    const textStream = async function* (graph) {
+      const response = await graph.executeWithBackend(input, options);
+      const words = response.split(" ");
+      for (const word of words) {
+        yield `${word} `;
+      }
+    };
+    return {
+      textStream: textStream(this)
+    };
+  }
+  /**
+   * Alias for stream() method for consistency with naming patterns
+   */
+  async generateStream(input, options) {
+    return await this.stream(input, options);
+  }
+  /**
+   * Run with a specific agent from the graph
+   */
+  async runWith(agentId, input, options) {
+    await this._init();
+    const agent2 = this.getAgent(agentId);
+    if (!agent2) {
+      throw new Error(`Agent '${agentId}' not found in graph`);
+    }
+    if (!this.isInternalAgent(agent2)) {
+      throw new Error(
+        `Agent '${agentId}' is an external agent and cannot be run directly. External agents are only accessible via delegation.`
+      );
+    }
+    logger7.info(
+      {
+        graphId: this.graphId,
+        agentId,
+        conversationId: options?.conversationId
+      },
+      "Running with specific agent"
+    );
+    const response = await this.executeWithBackend(input, options);
+    return {
+      finalOutput: response,
+      agent: agent2,
+      turnCount: 1,
+      usage: { inputTokens: 0, outputTokens: 0 },
+      metadata: {
+        toolCalls: [],
+        transfers: []
+      }
+    };
+  }
+  /**
+   * Get an agent by name (unified method for all agent types)
+   */
+  getAgent(name) {
+    return this.agentMap.get(name);
+  }
+  /**
+   * Add an agent to the graph
+   */
+  addAgent(agent2) {
+    this.agents.push(agent2);
+    this.agentMap.set(agent2.getId(), agent2);
+    if (this.models && this.isInternalAgent(agent2)) {
+      this.propagateModelSettingsToAgent(agent2);
+    }
+    logger7.info(
+      {
+        graphId: this.graphId,
+        agentId: agent2.getId(),
+        agentType: this.isInternalAgent(agent2) ? "internal" : "external"
+      },
+      "Agent added to graph"
+    );
+  }
+  /**
+   * Remove an agent from the graph
+   */
+  removeAgent(id) {
+    const agentToRemove = this.agentMap.get(id);
+    if (agentToRemove) {
+      this.agentMap.delete(agentToRemove.getId());
+      this.agents = this.agents.filter(
+        (agent2) => agent2.getId() !== agentToRemove.getId()
+      );
+      logger7.info(
+        {
+          graphId: this.graphId,
+          agentId: agentToRemove.getId()
+        },
+        "Agent removed from graph"
+      );
+      return true;
+    }
+    return false;
+  }
+  /**
+   * Get all agents in the graph
+   */
+  getAgents() {
+    return this.agents;
+  }
+  /**
+   * Get all agent ids (unified method for all agent types)
+   */
+  getAgentIds() {
+    return Array.from(this.agentMap.keys());
+  }
+  /**
+   * Set the default agent
+   */
+  setDefaultAgent(agent2) {
+    this.defaultAgent = agent2;
+    this.addAgent(agent2);
+    logger7.info(
+      {
+        graphId: this.graphId,
+        defaultAgent: agent2.getId()
+      },
+      "Default agent updated"
+    );
+  }
+  /**
+   * Get the default agent
+   */
+  getDefaultAgent() {
+    return this.defaultAgent;
+  }
+  /**
+   * Get the graph ID
+   */
+  getId() {
+    return this.graphId;
+  }
+  getName() {
+    return this.graphName;
+  }
+  getDescription() {
+    return this.graphDescription;
+  }
+  getTenantId() {
+    return this.tenantId;
+  }
+  /**
+   * Get the graph's model settingsuration
+   */
+  getModels() {
+    return this.models;
+  }
+  /**
+   * Set the graph's model settingsuration
+   */
+  setModels(models) {
+    this.models = models;
+  }
+  /**
+   * Get the graph's prompt configuration
+   */
+  getGraphPrompt() {
+    return this.graphPrompt;
+  }
+  /**
+   * Get the graph's stopWhen configuration
+   */
+  getStopWhen() {
+    return this.stopWhen || { transferCountIs: 10 };
+  }
+  /**
+   * Get the graph's status updates configuration
+   */
+  getStatusUpdateSettings() {
+    return this.statusUpdateSettings;
+  }
+  /**
+   * Get the summarizer model from the graph's model settings
+   */
+  getSummarizerModel() {
+    return this.models?.summarizer;
+  }
+  /**
+   * Get graph statistics
+   */
+  getStats() {
+    return {
+      agentCount: this.agents.length,
+      defaultAgent: this.defaultAgent?.getName() || null,
+      initialized: this.initialized,
+      graphId: this.graphId,
+      tenantId: this.tenantId
+    };
+  }
+  /**
+   * Validate the graph configuration
+   */
+  validate() {
+    const errors = [];
+    if (this.agents.length === 0) {
+      errors.push("Graph must contain at least one agent");
+    }
+    if (!this.defaultAgent) {
+      errors.push("Graph must have a default agent");
+    }
+    const names = /* @__PURE__ */ new Set();
+    for (const agent2 of this.agents) {
+      const name = agent2.getName();
+      if (names.has(name)) {
+        errors.push(`Duplicate agent name: ${name}`);
+      }
+      names.add(name);
+    }
+    for (const agent2 of this.agents) {
+      if (!this.isInternalAgent(agent2)) continue;
+      const transfers = agent2.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 graph`
+          );
+        }
+      }
+      const delegates = agent2.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 graph`
+          );
+        }
+      }
+    }
+    return {
+      valid: errors.length === 0,
+      errors
+    };
+  }
+  // Private helper methods
+  async _init() {
+    if (!this.initialized) {
+      await this.init();
+    }
+  }
+  /**
+   * Type guard to check if an agent is an internal AgentInterface
+   */
+  isInternalAgent(agent2) {
+    return "getTransfers" in agent2 && typeof agent2.getTransfers === "function";
+  }
+  /**
+   * Get project-level model settingsuration defaults
+   */
+  async getProjectModelDefaults() {
+    try {
+      const project = await agentsCore.getProject(this.dbClient)({
+        scopes: { tenantId: this.tenantId, projectId: this.projectId }
+      });
+      return project?.models;
+    } catch (error) {
+      logger7.warn(
+        {
+          tenantId: this.tenantId,
+          projectId: this.projectId,
+          error: error instanceof Error ? error.message : "Unknown error"
+        },
+        "Failed to get project model defaults"
+      );
+      return void 0;
+    }
+  }
+  /**
+   * Get project-level stopWhen configuration defaults
+   */
+  async getProjectStopWhenDefaults() {
+    try {
+      const project = await agentsCore.getProject(this.dbClient)({
+        scopes: { tenantId: this.tenantId, projectId: this.projectId }
+      });
+      return project?.stopWhen;
+    } catch (error) {
+      logger7.warn(
+        {
+          tenantId: this.tenantId,
+          projectId: this.projectId,
+          error: error instanceof Error ? error.message : "Unknown error"
+        },
+        "Failed to get project stopWhen defaults"
+      );
+      return void 0;
+    }
+  }
+  /**
+   * Apply model inheritance hierarchy: Project -> Graph -> Agent
+   */
+  async applyModelInheritance() {
+    const projectModels = await this.getProjectModelDefaults();
+    if (projectModels) {
+      if (!this.models) {
+        this.models = {};
+      }
+      if (!this.models.base && projectModels.base) {
+        this.models.base = projectModels.base;
+      }
+      if (!this.models.structuredOutput && projectModels.structuredOutput) {
+        this.models.structuredOutput = projectModels.structuredOutput;
+      }
+      if (!this.models.summarizer && projectModels.summarizer) {
+        this.models.summarizer = projectModels.summarizer;
+      }
+    }
+    await this.applyStopWhenInheritance();
+    for (const agent2 of this.agents) {
+      if (this.isInternalAgent(agent2)) {
+        this.propagateModelSettingsToAgent(agent2);
+      }
+    }
+  }
+  /**
+   * Apply stopWhen inheritance hierarchy: Project -> Graph -> Agent
+   */
+  async applyStopWhenInheritance() {
+    const projectStopWhen = await this.getProjectStopWhenDefaults();
+    if (!this.stopWhen) {
+      this.stopWhen = {};
+    }
+    if (this.stopWhen.transferCountIs === void 0 && projectStopWhen?.transferCountIs !== void 0) {
+      this.stopWhen.transferCountIs = projectStopWhen.transferCountIs;
+    }
+    if (this.stopWhen.transferCountIs === void 0) {
+      this.stopWhen.transferCountIs = 10;
+    }
+    if (projectStopWhen?.stepCountIs !== void 0) {
+      for (const agent2 of this.agents) {
+        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;
+          }
+        }
+      }
+    }
+    logger7.debug(
+      {
+        graphId: this.graphId,
+        graphStopWhen: this.stopWhen,
+        projectStopWhen
+      },
+      "Applied stopWhen inheritance from project to graph"
+    );
+  }
+  /**
+   * Propagate graph-level model settings to agents (supporting partial inheritance)
+   */
+  propagateModelSettingsToAgent(agent2) {
+    if (this.models) {
+      if (!agent2.config.models) {
+        agent2.config.models = {};
+      }
+      if (!agent2.config.models.base && this.models.base) {
+        agent2.config.models.base = this.models.base;
+      }
+      if (!agent2.config.models.structuredOutput && this.models.structuredOutput) {
+        agent2.config.models.structuredOutput = this.models.structuredOutput;
+      }
+      if (!agent2.config.models.summarizer && this.models.summarizer) {
+        agent2.config.models.summarizer = this.models.summarizer;
+      }
+    }
+  }
+  /**
+   * Immediately propagate graph-level models to all agents during construction
+   */
+  propagateImmediateModelSettings() {
+    for (const agent2 of this.agents) {
+      if (this.isInternalAgent(agent2)) {
+        this.propagateModelSettingsToAgent(agent2);
+      }
+    }
+  }
+  /**
+   * 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
+   */
+  async executeWithBackend(input, options) {
+    const normalizedMessages = this.normalizeMessages(input);
+    const url = `${this.baseURL}/tenants/${this.tenantId}/graphs/${this.graphId}/v1/chat/completions`;
+    logger7.info({ url }, "Executing with backend");
+    const requestBody = {
+      model: "gpt-4o-mini",
+      messages: normalizedMessages.map((msg) => ({
+        role: msg.role,
+        content: msg.content
+      })),
+      ...options,
+      // Include conversationId for multi-turn support
+      ...options?.conversationId && {
+        conversationId: options.conversationId
+      },
+      // Include context data if available
+      ...options?.customBodyParams && { ...options.customBodyParams },
+      stream: false
+      // Explicitly disable streaming - must come after options to override
+    };
+    try {
+      const response = await fetch(url, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Accept: "application/json"
+        },
+        body: JSON.stringify(requestBody)
+      });
+      if (!response.ok) {
+        throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+      }
+      const responseText = await response.text();
+      if (responseText.startsWith("data:")) {
+        return this.parseStreamingResponse(responseText);
+      }
+      const data = JSON.parse(responseText);
+      return data.result || data.choices?.[0]?.message?.content || "";
+    } catch (error) {
+      throw new Error(
+        `Graph execution failed: ${error.message || "Unknown error"}`
+      );
+    }
+  }
+  /**
+   * Parse streaming response in SSE format
+   */
+  parseStreamingResponse(text) {
+    const lines = text.split("\n");
+    let content = "";
+    for (const line of lines) {
+      if (line.startsWith("data: ")) {
+        const dataStr = line.slice(6);
+        if (dataStr === "[DONE]") break;
+        try {
+          const data = JSON.parse(dataStr);
+          const delta = data.choices?.[0]?.delta?.content;
+          if (delta) {
+            content += delta;
+          }
+        } catch (_e) {
+        }
+      }
+    }
+    return content;
+  }
+  /**
+   * Normalize input messages to the expected format
+   */
+  normalizeMessages(input) {
+    if (typeof input === "string") {
+      return [{ role: "user", content: input }];
+    }
+    if (Array.isArray(input)) {
+      return input.map(
+        (msg) => typeof msg === "string" ? { role: "user", content: msg } : msg
+      );
+    }
+    return [input];
+  }
+  async saveToDatabase() {
+    try {
+      const getUrl = `${this.baseURL}/tenants/${this.tenantId}/crud/agent-graphs/${this.graphId}`;
+      try {
+        const getResponse = await fetch(getUrl, {
+          method: "GET",
+          headers: {
+            "Content-Type": "application/json"
+          }
+        });
+        if (getResponse.ok) {
+          logger7.info(
+            { graphId: this.graphId },
+            "Graph already exists in backend"
+          );
+          return;
+        }
+        if (getResponse.status !== 404) {
+          throw new Error(
+            `HTTP ${getResponse.status}: ${getResponse.statusText}`
+          );
+        }
+      } catch (error) {
+        if (!error.message.includes("404")) {
+          throw error;
+        }
+      }
+      logger7.info({ graphId: this.graphId }, "Creating graph in backend");
+      const createUrl = `${this.baseURL}/tenants/${this.tenantId}/crud/agent-graphs`;
+      const createResponse = await fetch(createUrl, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({
+          id: this.graphId,
+          name: this.graphName,
+          defaultAgentId: this.defaultAgent?.getId() || "",
+          contextConfigId: this.contextConfig?.getId(),
+          models: this.models
+        })
+      });
+      if (!createResponse.ok) {
+        throw new Error(
+          `HTTP ${createResponse.status}: ${createResponse.statusText}`
+        );
+      }
+      const createData = await createResponse.json();
+      this.graphId = createData.data.id;
+      logger7.info({ graph: createData.data }, "Graph created in backend");
+    } catch (error) {
+      throw new Error(
+        `Failed to save graph to database: ${error instanceof Error ? error.message : "Unknown error"}`
+      );
+    }
+  }
+  async saveRelations() {
+    if (this.defaultAgent) {
+      try {
+        const updateUrl = `${this.baseURL}/tenants/${this.tenantId}/crud/agent-graphs/${this.graphId}`;
+        const updateResponse = await fetch(updateUrl, {
+          method: "PUT",
+          headers: {
+            "Content-Type": "application/json"
+          },
+          body: JSON.stringify({
+            id: this.graphId,
+            defaultAgentId: this.defaultAgent.getId(),
+            contextConfigId: this.contextConfig?.getId()
+          })
+        });
+        if (!updateResponse.ok) {
+          throw new Error(
+            `HTTP ${updateResponse.status}: ${updateResponse.statusText}`
+          );
+        }
+        logger7.debug(
+          {
+            graphId: this.graphId,
+            defaultAgent: this.defaultAgent.getName()
+          },
+          "Graph relationships configured"
+        );
+      } catch (error) {
+        logger7.error(
+          {
+            graphId: this.graphId,
+            error: error instanceof Error ? error.message : "Unknown error"
+          },
+          "Failed to update graph relationships"
+        );
+        throw error;
+      }
+    }
+  }
+  async createAgentRelations() {
+    const allRelationPromises = [];
+    for (const agent2 of this.agents) {
+      if (this.isInternalAgent(agent2)) {
+        const transfers = agent2.getTransfers();
+        for (const transferAgent of transfers) {
+          allRelationPromises.push(
+            this.createInternalAgentRelation(agent2, transferAgent, "transfer")
+          );
+        }
+        const delegates = agent2.getDelegates();
+        for (const delegate of delegates) {
+          if (delegate instanceof ExternalAgent) {
+            allRelationPromises.push(
+              this.createExternalAgentRelation(agent2, delegate, "delegate")
+            );
+          } else {
+            allRelationPromises.push(
+              this.createInternalAgentRelation(
+                agent2,
+                delegate,
+                "delegate"
+              )
+            );
+          }
+        }
+      }
+    }
+    const results = await Promise.allSettled(allRelationPromises);
+    const errors = [];
+    let successCount = 0;
+    for (const result of results) {
+      if (result.status === "fulfilled") {
+        successCount++;
+      } else {
+        errors.push(result.reason);
+        logger7.error(
+          {
+            error: result.reason instanceof Error ? result.reason.message : "Unknown error",
+            graphId: this.graphId
+          },
+          "Failed to create agent relation"
+        );
+      }
+    }
+    logger7.info(
+      {
+        graphId: this.graphId,
+        totalRelations: allRelationPromises.length,
+        successCount,
+        errorCount: errors.length
+      },
+      "Completed agent relation creation batch"
+    );
+    if (errors.length > 0 && successCount === 0) {
+      throw new Error(`All ${errors.length} agent relation creations failed`);
+    }
+  }
+  async createInternalAgentRelation(sourceAgent, targetAgent, relationType) {
+    try {
+      const response = await fetch(
+        `${this.baseURL}/tenants/${this.tenantId}/crud/agent-relations`,
+        {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json"
+          },
+          body: JSON.stringify({
+            graphId: this.graphId,
+            sourceAgentId: sourceAgent.getId(),
+            targetAgentId: targetAgent.getId(),
+            relationType
+          })
+        }
+      );
+      if (!response.ok) {
+        const errorText = await response.text().catch(() => "Unknown error");
+        if (response.status === 422 && errorText.includes("already exists")) {
+          logger7.info(
+            {
+              sourceAgentId: sourceAgent.getId(),
+              targetAgentId: targetAgent.getId(),
+              graphId: this.graphId,
+              relationType
+            },
+            `${relationType} relation already exists, skipping creation`
+          );
+          return;
+        }
+        throw new Error(
+          `Failed to create agent relation: ${response.status} - ${errorText}`
+        );
+      }
+      logger7.info(
+        {
+          sourceAgentId: sourceAgent.getId(),
+          targetAgentId: targetAgent.getId(),
+          graphId: this.graphId,
+          relationType
+        },
+        `${relationType} relation created successfully`
+      );
+    } catch (error) {
+      logger7.error(
+        {
+          sourceAgentId: sourceAgent.getId(),
+          targetAgentId: targetAgent.getId(),
+          graphId: this.graphId,
+          relationType,
+          error: error instanceof Error ? error.message : "Unknown error"
+        },
+        `Failed to create ${relationType} relation`
+      );
+      throw error;
+    }
+  }
+  // enableComponentMode removed – feature deprecated
+  async createExternalAgentRelation(sourceAgent, externalAgent2, relationType) {
+    try {
+      const response = await fetch(
+        `${this.baseURL}/tenants/${this.tenantId}/crud/agent-relations`,
+        {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json"
+          },
+          body: JSON.stringify({
+            graphId: this.graphId,
+            sourceAgentId: sourceAgent.getId(),
+            externalAgentId: externalAgent2.getId(),
+            relationType
+          })
+        }
+      );
+      if (!response.ok) {
+        const errorText = await response.text().catch(() => "Unknown error");
+        if (response.status === 422 && errorText.includes("already exists")) {
+          logger7.info(
+            {
+              sourceAgentId: sourceAgent.getId(),
+              externalAgentId: externalAgent2.getId(),
+              graphId: this.graphId,
+              relationType
+            },
+            `${relationType} relation already exists, skipping creation`
+          );
+          return;
+        }
+        throw new Error(
+          `Failed to create external agent relation: ${response.status} - ${errorText}`
+        );
+      }
+      logger7.info(
+        {
+          sourceAgentId: sourceAgent.getId(),
+          externalAgentId: externalAgent2.getId(),
+          graphId: this.graphId,
+          relationType
+        },
+        `${relationType} relation created successfully`
+      );
+    } catch (error) {
+      logger7.error(
+        {
+          sourceAgentId: sourceAgent.getId(),
+          externalAgentId: externalAgent2.getId(),
+          graphId: this.graphId,
+          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.agents.filter(
+      (agent2) => this.isExternalAgent(agent2)
+    );
+    logger7.info(
+      {
+        graphId: this.graphId,
+        externalAgentCount: externalAgents2.length
+      },
+      "Creating external agents in database"
+    );
+    const initPromises = externalAgents2.map(async (externalAgent2) => {
+      try {
+        await externalAgent2.init();
+        logger7.debug(
+          {
+            externalAgentId: externalAgent2.getId(),
+            graphId: this.graphId
+          },
+          "External agent created in database"
+        );
+      } catch (error) {
+        logger7.error(
+          {
+            externalAgentId: externalAgent2.getId(),
+            graphId: this.graphId,
+            error: error instanceof Error ? error.message : "Unknown error"
+          },
+          "Failed to create external agent in database"
+        );
+        throw error;
+      }
+    });
+    try {
+      await Promise.all(initPromises);
+      logger7.info(
+        {
+          graphId: this.graphId,
+          externalAgentCount: externalAgents2.length
+        },
+        "All external agents created successfully"
+      );
+    } catch (error) {
+      logger7.error(
+        {
+          graphId: this.graphId,
+          error: error instanceof Error ? error.message : "Unknown error"
+        },
+        "Failed to create some external agents"
+      );
+      throw error;
+    }
+  }
+};
+function agentGraph(config) {
+  return new AgentGraph(config);
+}
+async function generateGraph(configPath) {
+  logger7.info({ configPath }, "Loading graph configuration");
+  try {
+    const config = await import(configPath);
+    const graphConfig = config.default || config;
+    const graph = agentGraph(graphConfig);
+    await graph.init();
+    logger7.info(
+      {
+        configPath,
+        graphId: graph.getStats().graphId,
+        agentCount: graph.getStats().agentCount
+      },
+      "Graph generated successfully"
+    );
+    return graph;
+  } catch (error) {
+    logger7.error(
+      {
+        configPath,
+        error: error instanceof Error ? error.message : "Unknown error"
+      },
+      "Failed to generate graph from configuration"
+    );
+    throw error;
+  }
+}
+zod.z.object({
+  model: zod.z.string().optional(),
+  providerOptions: zod.z.record(zod.z.string(), zod.z.record(zod.z.string(), zod.z.unknown())).optional()
+});
+var AgentError = class extends Error {
+  constructor(message, code, details) {
+    super(message);
+    this.code = code;
+    this.details = details;
+    this.name = "AgentError";
+  }
+};
+var MaxTurnsExceededError = class extends AgentError {
+  constructor(maxTurns) {
+    super(`Maximum turns (${maxTurns}) exceeded`);
+    this.code = "MAX_TURNS_EXCEEDED";
+  }
+};
+
+// src/runner.ts
+var logger8 = agentsCore.getLogger("runner");
+var Runner = class _Runner {
+  /**
+   * Run a graph until completion, handling transfers and tool calls
+   * Similar to OpenAI's Runner.run() pattern
+   * NOTE: This now requires a graph instead of an agent
+   */
+  static async run(graph, messages, options) {
+    const maxTurns = options?.maxTurns || 10;
+    let turnCount = 0;
+    const messageHistory = _Runner.normalizeToMessageHistory(messages);
+    const allToolCalls = [];
+    logger8.info(
+      {
+        graphId: graph.getId(),
+        defaultAgent: graph.getDefaultAgent()?.getName(),
+        maxTurns,
+        initialMessageCount: messageHistory.length
+      },
+      "Starting graph run"
+    );
+    while (turnCount < maxTurns) {
+      logger8.debug(
+        {
+          graphId: graph.getId(),
+          turnCount,
+          messageHistoryLength: messageHistory.length
+        },
+        "Starting turn"
+      );
+      const response = await graph.generate(messageHistory, options);
+      turnCount++;
+      logger8.info(
+        {
+          graphId: graph.getId(),
+          turnCount,
+          responseLength: response.length
+        },
+        "Graph generation completed"
+      );
+      return {
+        finalOutput: response,
+        agent: graph.getDefaultAgent() || {},
+        turnCount,
+        usage: { inputTokens: 0, outputTokens: 0 },
+        metadata: {
+          toolCalls: allToolCalls,
+          transfers: []
+          // Graph handles transfers internally
+        }
+      };
+    }
+    logger8.error(
+      {
+        graphId: graph.getId(),
+        maxTurns,
+        finalTurnCount: turnCount
+      },
+      "Maximum turns exceeded"
+    );
+    throw new MaxTurnsExceededError(maxTurns);
+  }
+  /**
+   * Stream a graph's response
+   */
+  static async stream(graph, messages, options) {
+    logger8.info(
+      {
+        graphId: graph.getId(),
+        defaultAgent: graph.getDefaultAgent()?.getName()
+      },
+      "Starting graph stream"
+    );
+    return graph.stream(messages, options);
+  }
+  /**
+   * Execute multiple graphs in parallel and return the first successful result
+   */
+  static async raceGraphs(graphs, messages, options) {
+    if (graphs.length === 0) {
+      throw new Error("No graphs provided for race");
+    }
+    logger8.info(
+      {
+        graphCount: graphs.length,
+        graphIds: graphs.map((g) => g.getId())
+      },
+      "Starting graph race"
+    );
+    const promises = graphs.map(async (graph, index) => {
+      try {
+        const result2 = await _Runner.run(graph, messages, options);
+        return { ...result2, raceIndex: index };
+      } catch (error) {
+        logger8.error(
+          {
+            graphId: graph.getId(),
+            error: error instanceof Error ? error.message : "Unknown error"
+          },
+          "Graph failed in race"
+        );
+        throw error;
+      }
+    });
+    const result = await Promise.race(promises);
+    logger8.info(
+      {
+        winningGraphId: result.graphId || "unknown",
+        raceIndex: result.raceIndex
+      },
+      "Graph race completed"
+    );
+    return result;
+  }
+  // Private helper methods
+  static normalizeToMessageHistory(messages) {
+    if (typeof messages === "string") {
+      return [{ role: "user", content: messages }];
+    }
+    if (Array.isArray(messages)) {
+      return messages.map(
+        (msg) => typeof msg === "string" ? { role: "user", content: msg } : msg
+      );
+    }
+    return [messages];
+  }
+  /**
+   * Validate graph configuration before running
+   */
+  static validateGraph(graph) {
+    const errors = [];
+    if (!graph.getId()) {
+      errors.push("Graph ID is required");
+    }
+    const defaultAgent = graph.getDefaultAgent();
+    if (!defaultAgent) {
+      errors.push("Default agent is required");
+    } else {
+      if (!defaultAgent.getName()) {
+        errors.push("Default agent name is required");
+      }
+      if (!defaultAgent.getInstructions()) {
+        errors.push("Default agent instructions are required");
+      }
+    }
+    const agents = graph.getAgents();
+    if (agents.length === 0) {
+      errors.push("Graph must contain at least one agent");
+    }
+    for (const agent2 of agents) {
+      if (!agent2.getName()) {
+        errors.push(`Agent missing name`);
+      }
+    }
+    return {
+      valid: errors.length === 0,
+      errors
+    };
+  }
+  /**
+   * Get execution statistics for a graph
+   */
+  static async getExecutionStats(graph, messages, options) {
+    const agents = graph.getAgents();
+    const defaultAgent = graph.getDefaultAgent();
+    const messageCount = Array.isArray(messages) ? messages.length : 1;
+    return {
+      estimatedTurns: Math.min(
+        Math.max(messageCount, 1),
+        options?.maxTurns || 10
+      ),
+      estimatedTokens: messageCount * 100,
+      // Rough estimate
+      agentCount: agents.length,
+      defaultAgent: defaultAgent?.getName()
+    };
+  }
+};
+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.agent = agent;
+exports.agentGraph = agentGraph;
+exports.artifactComponent = artifactComponent;
+exports.createEnvironmentSettings = createEnvironmentSettings;
+exports.credential = credential;
+exports.dataComponent = dataComponent;
+exports.externalAgent = externalAgent;
+exports.externalAgents = externalAgents;
+exports.generateGraph = generateGraph;
+exports.getAllEnvironmentSettingKeys = getAllEnvironmentSettingKeys;
+exports.mcpServer = mcpServer;
+exports.mcpTool = mcpTool;
+exports.raceGraphs = raceGraphs;
+exports.registerEnvironmentSettings = registerEnvironmentSettings;
+exports.run = run;
+exports.stream = stream;
+exports.tool = tool;
+exports.transfer = transfer;