@inkeep/agents-sdk 0.1.1 → 0.1.7

package/dist/index.cjs

@@ -0,0 +1,3334 @@
+'use strict';
+
+var agentsCore = require('@inkeep/agents-core');
+var zod = require('zod');
+
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+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}`
+    );
+  }
+};
+var logger3 = agentsCore.getLogger("tool");
+var Tool = class {
+  constructor(config) {
+    __publicField(this, "config");
+    __publicField(this, "baseURL");
+    __publicField(this, "tenantId");
+    __publicField(this, "initialized", false);
+    __publicField(this, "projectId");
+    this.config = config;
+    this.baseURL = process.env.INKEEP_API_URL || "http://localhost:3002";
+    this.tenantId = config.tenantId || "default";
+    this.projectId = config.projectId || "default";
+    logger3.info(
+      {
+        Id: this.getId(),
+        Name: config.name
+      },
+      "Tool constructor initialized"
+    );
+  }
+  // Compute ID from name using same slug transformation as agents
+  getId() {
+    return this.config.id;
+  }
+  getName() {
+    return this.config.name;
+  }
+  getDescription() {
+    return this.config.description || "";
+  }
+  getServerUrl() {
+    return this.config.serverUrl;
+  }
+  getActiveTools() {
+    return this.config.activeTools;
+  }
+  getCredentialReferenceId() {
+    return this.config.credential?.id;
+  }
+  // Public method to ensure tool exists in backend (with upsert behavior)
+  async init(options) {
+    if (this.initialized) return;
+    try {
+      if (!options?.skipDatabaseRegistration) {
+        await this.upsertTool();
+      }
+      logger3.info(
+        {
+          toolId: this.getId()
+        },
+        "Tool initialized successfully"
+      );
+      this.initialized = true;
+    } catch (error) {
+      logger3.error(
+        {
+          toolId: this.getId(),
+          error: error instanceof Error ? error.message : "Unknown error"
+        },
+        "Failed to initialize tool"
+      );
+      throw error;
+    }
+  }
+  // Private method to upsert tool (create or update)
+  async upsertTool() {
+    const toolDataForUpdate = {
+      id: this.getId(),
+      name: this.config.name,
+      credentialReferenceId: this.config.credential?.id ?? null,
+      headers: this.config.headers ?? null,
+      imageUrl: this.config.imageUrl,
+      config: {
+        type: "mcp",
+        mcp: {
+          server: {
+            url: this.config.serverUrl
+          },
+          transport: this.config.transport,
+          activeTools: this.config.activeTools
+        }
+      }
+    };
+    const toolDataForCreate = {
+      ...toolDataForUpdate
+    };
+    logger3.info({ toolDataForCreate }, "toolDataForCreate");
+    const updateResponse = await fetch(
+      `${this.baseURL}/tenants/${this.tenantId}/crud/projects/${this.projectId}/tools/${this.getId()}`,
+      {
+        method: "PUT",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify(toolDataForUpdate)
+      }
+    );
+    logger3.info({ updateResponse }, "tool updateResponse");
+    if (updateResponse.ok) {
+      logger3.info(
+        {
+          toolId: this.getId()
+        },
+        "Tool updated successfully"
+      );
+      return;
+    }
+    if (updateResponse.status === 404) {
+      logger3.info(
+        {
+          toolId: this.getId()
+        },
+        "Tool not found, creating new tool"
+      );
+      const createResponse = await fetch(
+        `${this.baseURL}/tenants/${this.tenantId}/crud/projects/${this.projectId}/tools`,
+        {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json"
+          },
+          body: JSON.stringify(toolDataForCreate)
+        }
+      );
+      if (!createResponse.ok) {
+        throw new Error(`Failed to create tool: ${createResponse.status}`);
+      }
+      logger3.info(
+        {
+          toolId: this.getId()
+        },
+        "Tool created successfully"
+      );
+      return;
+    }
+    throw new Error(`Failed to update tool: ${updateResponse.status}`);
+  }
+};
+
+// src/agent.ts
+var logger4 = agentsCore.getLogger("agent");
+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;
+  }
+  // adjust
+  getTools() {
+    const tools = resolveGetter(this.config.canUse);
+    if (!tools) {
+      return {};
+    }
+    if (!Array.isArray(tools)) {
+      throw new Error("tools getter must return an array");
+    }
+    const toolRecord = {};
+    for (const tool of tools) {
+      if (tool && typeof tool === "object") {
+        let id;
+        let toolInstance;
+        if ("server" in tool && "selectedTools" in tool) {
+          const agentMcpConfig = tool;
+          id = agentMcpConfig.server.getId();
+          toolInstance = agentMcpConfig.server;
+          toolInstance.selectedTools = agentMcpConfig.selectedTools;
+        } else {
+          id = tool.id || tool.getId?.() || tool.name;
+          toolInstance = tool;
+        }
+        if (id) {
+          toolRecord[id] = toolInstance;
+        }
+      }
+    }
+    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) || [];
+  }
+  // adjust
+  addTool(_name, tool) {
+    const existingTools = this.config.canUse ? this.config.canUse() : [];
+    this.config.canUse = () => [...existingTools, tool];
+  }
+  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() {
+    if (this.config.canUse) {
+      const tools = resolveGetter(this.config.canUse);
+      if (tools && Array.isArray(tools)) {
+        for (let i = 0; i < tools.length; i++) {
+          const toolConfig = tools[i];
+          let toolId;
+          if (toolConfig instanceof Tool) {
+            toolId = toolConfig.getId();
+          } else if (toolConfig && typeof toolConfig === "object" && "server" in toolConfig) {
+            toolId = toolConfig.server.getId();
+          } else {
+            toolId = `tool-${i}`;
+          }
+          try {
+            await this.createTool(toolId, toolConfig);
+          } catch (error) {
+            logger4.error(
+              {
+                toolId,
+                error: error instanceof Error ? error.message : "Unknown error"
+              },
+              "Tool creation failed"
+            );
+            throw error;
+          }
+        }
+      }
+    }
+  }
+  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
+          },
+          "Skipping function tool creation - will be handled at runtime"
+        );
+        return;
+      }
+      let tool;
+      let selectedTools;
+      if (toolConfig && typeof toolConfig === "object" && "server" in toolConfig && "selectedTools" in toolConfig) {
+        const mcpConfig = toolConfig;
+        tool = mcpConfig.server;
+        selectedTools = mcpConfig.selectedTools;
+        await tool.init();
+      } else if (toolConfig instanceof Tool) {
+        tool = toolConfig;
+        await tool.init();
+      } else {
+        tool = new Tool({
+          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 tool.init();
+      }
+      await this.createAgentToolRelation(tool.getId(), selectedTools);
+      logger4.info(
+        {
+          agentId: this.getId(),
+          toolId: tool.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"
+      );
+      throw error;
+    }
+  }
+  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, selectedTools) {
+    const relationData = {
+      id: `${this.getId()}-tool-${toolId}`,
+      tenantId: this.tenantId,
+      projectId: this.projectId,
+      agentId: this.getId(),
+      toolId
+    };
+    if (selectedTools !== void 0) {
+      relationData.selectedTools = selectedTools;
+    }
+    const relationResponse = await fetch(
+      `${this.baseURL}/tenants/${this.tenantId}/crud/projects/${this.projectId}/agent-tool-relations`,
+      {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify(relationData)
+      }
+    );
+    if (!relationResponse.ok) {
+      const errorBody = await relationResponse.text().catch(() => "Unknown error");
+      throw new Error(
+        `Failed to create agent-tool relation: ${relationResponse.status} - ${errorBody}`
+      );
+    }
+  }
+};
+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 selectedToolsMapping = {};
+        const agentTools = internalAgent.getTools();
+        for (const [toolName, toolInstance] of Object.entries(agentTools)) {
+          if (toolInstance && typeof toolInstance === "object") {
+            let toolId;
+            toolId = toolInstance.getId?.() || toolInstance.id;
+            if ("selectedTools" in toolInstance && toolInstance.selectedTools !== void 0) {
+              logger7.info({ toolId, selectedTools: toolInstance.selectedTools }, "Selected tools");
+              selectedToolsMapping[toolId] = toolInstance.selectedTools;
+            }
+            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,
+          selectedTools: Object.keys(selectedToolsMapping).length > 0 ? selectedToolsMapping : void 0,
+          dataComponents: dataComponents.length > 0 ? dataComponents : void 0,
+          artifactComponents: artifactComponents.length > 0 ? artifactComponents : void 0,
+          type: "internal"
+        };
+      } 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") {
+          let actualTool;
+          let toolId;
+          if ("server" in toolInstance && "selectedTools" in toolInstance) {
+            const mcpConfig = toolInstance;
+            actualTool = mcpConfig.server;
+            toolId = actualTool.getId();
+          } else {
+            actualTool = toolInstance;
+            toolId = actualTool.getId?.() || actualTool.id || toolName;
+          }
+          if (!toolsObject[toolId]) {
+            let toolConfig;
+            if (actualTool.config?.serverUrl) {
+              toolConfig = {
+                type: "mcp",
+                mcp: {
+                  server: {
+                    url: actualTool.config.serverUrl
+                  }
+                }
+              };
+            } else if (actualTool.config?.type === "mcp") {
+              toolConfig = actualTool.config;
+            } else {
+              toolConfig = {
+                type: "function",
+                parameters: actualTool.parameters || {}
+              };
+            }
+            const toolData = {
+              id: toolId,
+              name: actualTool.config?.name || actualTool.name || toolName,
+              config: toolConfig,
+              status: actualTool.getStatus?.() || actualTool.status || "unknown"
+            };
+            if (actualTool.config?.imageUrl) {
+              toolData.imageUrl = actualTool.config.imageUrl;
+            }
+            if (actualTool.config?.headers) {
+              toolData.headers = actualTool.config.headers;
+            }
+            if (actualTool.capabilities) {
+              toolData.capabilities = actualTool.capabilities;
+            }
+            if (actualTool.lastHealthCheck) {
+              toolData.lastHealthCheck = actualTool.lastHealthCheck;
+            }
+            if (actualTool.availableTools) {
+              toolData.availableTools = actualTool.availableTools;
+            }
+            if (actualTool.lastError) {
+              toolData.lastError = actualTool.lastError;
+            }
+            if (actualTool.lastToolsSync) {
+              toolData.lastToolsSync = actualTool.lastToolsSync;
+            }
+            if (actualTool.getCredentialReferenceId?.()) {
+              toolData.credentialReferenceId = actualTool.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 project2 = await agentsCore.getProject(this.dbClient)({
+        scopes: { tenantId: this.tenantId, projectId: this.projectId }
+      });
+      return project2?.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 project2 = await agentsCore.getProject(this.dbClient)({
+        scopes: { tenantId: this.tenantId, projectId: this.projectId }
+      });
+      return project2?.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;
+    }
+  }
+};
+var logger8 = agentsCore.getLogger("projectFullClient");
+async function createFullProjectViaAPI(tenantId, apiUrl, projectData) {
+  logger8.info(
+    {
+      tenantId,
+      projectId: projectData.id,
+      apiUrl
+    },
+    "Creating full project via API"
+  );
+  const url = `${apiUrl}/tenants/${tenantId}/project-full`;
+  const response = await fetch(url, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify(projectData)
+  });
+  if (!response.ok) {
+    const errorText = await response.text();
+    let errorMessage = `Failed to create project: ${response.status} ${response.statusText}`;
+    try {
+      const errorJson = JSON.parse(errorText);
+      if (errorJson.error) {
+        errorMessage = errorJson.error;
+      }
+    } catch {
+      if (errorText) {
+        errorMessage = errorText;
+      }
+    }
+    logger8.error(
+      {
+        status: response.status,
+        error: errorMessage
+      },
+      "Failed to create project via API"
+    );
+    throw new Error(errorMessage);
+  }
+  const result = await response.json();
+  logger8.info(
+    {
+      projectId: projectData.id
+    },
+    "Successfully created project via API"
+  );
+  return result.data;
+}
+async function updateFullProjectViaAPI(tenantId, apiUrl, projectId, projectData) {
+  logger8.info(
+    {
+      tenantId,
+      projectId,
+      apiUrl
+    },
+    "Updating full project via API"
+  );
+  const url = `${apiUrl}/tenants/${tenantId}/project-full/${projectId}`;
+  const response = await fetch(url, {
+    method: "PUT",
+    headers: {
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify(projectData)
+  });
+  if (!response.ok) {
+    const errorText = await response.text();
+    let errorMessage = `Failed to update project: ${response.status} ${response.statusText}`;
+    try {
+      const errorJson = JSON.parse(errorText);
+      if (errorJson.error) {
+        errorMessage = errorJson.error;
+      }
+    } catch {
+      if (errorText) {
+        errorMessage = errorText;
+      }
+    }
+    logger8.error(
+      {
+        status: response.status,
+        error: errorMessage
+      },
+      "Failed to update project via API"
+    );
+    throw new Error(errorMessage);
+  }
+  const result = await response.json();
+  logger8.info(
+    {
+      projectId
+    },
+    "Successfully updated project via API"
+  );
+  return result.data;
+}
+async function getFullProjectViaAPI(tenantId, apiUrl, projectId) {
+  logger8.info(
+    {
+      tenantId,
+      projectId,
+      apiUrl
+    },
+    "Getting full project via API"
+  );
+  const url = `${apiUrl}/tenants/${tenantId}/project-full/${projectId}`;
+  const response = await fetch(url, {
+    method: "GET",
+    headers: {
+      "Content-Type": "application/json"
+    }
+  });
+  if (!response.ok) {
+    if (response.status === 404) {
+      logger8.info(
+        {
+          projectId
+        },
+        "Project not found"
+      );
+      return null;
+    }
+    const errorText = await response.text();
+    let errorMessage = `Failed to get project: ${response.status} ${response.statusText}`;
+    try {
+      const errorJson = JSON.parse(errorText);
+      if (errorJson.error) {
+        errorMessage = errorJson.error;
+      }
+    } catch {
+      if (errorText) {
+        errorMessage = errorText;
+      }
+    }
+    logger8.error(
+      {
+        status: response.status,
+        error: errorMessage
+      },
+      "Failed to get project via API"
+    );
+    throw new Error(errorMessage);
+  }
+  const result = await response.json();
+  logger8.info(
+    {
+      projectId
+    },
+    "Successfully retrieved project via API"
+  );
+  return result.data;
+}
+async function deleteFullProjectViaAPI(tenantId, apiUrl, projectId) {
+  logger8.info(
+    {
+      tenantId,
+      projectId,
+      apiUrl
+    },
+    "Deleting full project via API"
+  );
+  const url = `${apiUrl}/tenants/${tenantId}/project-full/${projectId}`;
+  const response = await fetch(url, {
+    method: "DELETE",
+    headers: {
+      "Content-Type": "application/json"
+    }
+  });
+  if (!response.ok) {
+    const errorText = await response.text();
+    let errorMessage = `Failed to delete project: ${response.status} ${response.statusText}`;
+    try {
+      const errorJson = JSON.parse(errorText);
+      if (errorJson.error) {
+        errorMessage = errorJson.error;
+      }
+    } catch {
+      if (errorText) {
+        errorMessage = errorText;
+      }
+    }
+    logger8.error(
+      {
+        status: response.status,
+        error: errorMessage
+      },
+      "Failed to delete project via API"
+    );
+    throw new Error(errorMessage);
+  }
+  logger8.info(
+    {
+      projectId
+    },
+    "Successfully deleted project via API"
+  );
+}
+
+// src/project.ts
+var logger9 = agentsCore.getLogger("project");
+var Project = class {
+  constructor(config) {
+    __publicField(this, "projectId");
+    __publicField(this, "projectName");
+    __publicField(this, "projectDescription");
+    __publicField(this, "tenantId");
+    __publicField(this, "baseURL");
+    __publicField(this, "initialized", false);
+    __publicField(this, "models");
+    __publicField(this, "stopWhen");
+    __publicField(this, "graphs", []);
+    __publicField(this, "graphMap", /* @__PURE__ */ new Map());
+    this.projectId = config.id;
+    this.projectName = config.name;
+    this.projectDescription = config.description;
+    this.tenantId = config.tenantId || "default";
+    this.baseURL = process.env.INKEEP_API_URL || "http://localhost:3002";
+    this.models = config.models;
+    this.stopWhen = config.stopWhen;
+    if (config.graphs) {
+      this.graphs = config.graphs();
+      this.graphMap = new Map(this.graphs.map((graph) => [graph.getId(), graph]));
+      for (const graph of this.graphs) {
+        graph.setConfig(this.tenantId, this.projectId, this.baseURL);
+      }
+    }
+    logger9.info(
+      {
+        projectId: this.projectId,
+        tenantId: this.tenantId,
+        graphCount: this.graphs.length
+      },
+      "Project created"
+    );
+  }
+  /**
+   * Set or update the configuration (tenantId and apiUrl)
+   * This is used by the CLI to inject configuration from inkeep.config.ts
+   */
+  setConfig(tenantId, apiUrl) {
+    if (this.initialized) {
+      throw new Error("Cannot set config after project has been initialized");
+    }
+    this.tenantId = tenantId;
+    this.baseURL = apiUrl;
+    for (const graph of this.graphs) {
+      graph.setConfig(tenantId, this.projectId, apiUrl);
+    }
+    logger9.info(
+      {
+        projectId: this.projectId,
+        tenantId: this.tenantId,
+        apiUrl: this.baseURL
+      },
+      "Project configuration updated"
+    );
+  }
+  /**
+   * Initialize the project and create/update it in the backend using full project approach
+   */
+  async init() {
+    if (this.initialized) {
+      logger9.info({ projectId: this.projectId }, "Project already initialized");
+      return;
+    }
+    logger9.info(
+      {
+        projectId: this.projectId,
+        tenantId: this.tenantId,
+        graphCount: this.graphs.length
+      },
+      "Initializing project using full project endpoint"
+    );
+    try {
+      const initPromises = this.graphs.map(async (graph) => {
+        try {
+          await graph.init();
+          logger9.debug(
+            {
+              projectId: this.projectId,
+              graphId: graph.getId()
+            },
+            "Graph initialized in project"
+          );
+        } catch (error) {
+          logger9.error(
+            {
+              projectId: this.projectId,
+              graphId: graph.getId(),
+              error: error instanceof Error ? error.message : "Unknown error"
+            },
+            "Failed to initialize graph in project"
+          );
+          throw error;
+        }
+      });
+      await Promise.all(initPromises);
+      const projectDefinition = await this.toFullProjectDefinition();
+      logger9.info(
+        {
+          projectId: this.projectId,
+          mode: "api-client",
+          apiUrl: this.baseURL
+        },
+        "Using API client to create/update full project"
+      );
+      const createdProject = await updateFullProjectViaAPI(
+        this.tenantId,
+        this.baseURL,
+        this.projectId,
+        projectDefinition
+      );
+      this.initialized = true;
+      logger9.info(
+        {
+          projectId: this.projectId,
+          tenantId: this.tenantId,
+          graphCount: Object.keys(createdProject.graphs || {}).length
+        },
+        "Project initialized successfully using full project endpoint"
+      );
+    } catch (error) {
+      logger9.error(
+        {
+          projectId: this.projectId,
+          error: error instanceof Error ? error.message : "Unknown error"
+        },
+        "Failed to initialize project using full project endpoint"
+      );
+      throw error;
+    }
+  }
+  /**
+   * Get the project ID
+   */
+  getId() {
+    return this.projectId;
+  }
+  /**
+   * Get the project name
+   */
+  getName() {
+    return this.projectName;
+  }
+  /**
+   * Get the project description
+   */
+  getDescription() {
+    return this.projectDescription;
+  }
+  /**
+   * Get the tenant ID
+   */
+  getTenantId() {
+    return this.tenantId;
+  }
+  /**
+   * Get the project's model configuration
+   */
+  getModels() {
+    return this.models;
+  }
+  /**
+   * Set the project's model configuration
+   */
+  setModels(models) {
+    this.models = models;
+  }
+  /**
+   * Get the project's stopWhen configuration
+   */
+  getStopWhen() {
+    return this.stopWhen;
+  }
+  /**
+   * Set the project's stopWhen configuration
+   */
+  setStopWhen(stopWhen) {
+    this.stopWhen = stopWhen;
+  }
+  /**
+   * Get all graphs in the project
+   */
+  getGraphs() {
+    return this.graphs;
+  }
+  /**
+   * Get a graph by ID
+   */
+  getGraph(id) {
+    return this.graphMap.get(id);
+  }
+  /**
+   * Add a graph to the project
+   */
+  addGraph(graph) {
+    this.graphs.push(graph);
+    this.graphMap.set(graph.getId(), graph);
+    graph.setConfig(this.tenantId, this.projectId, this.baseURL);
+    logger9.info(
+      {
+        projectId: this.projectId,
+        graphId: graph.getId()
+      },
+      "Graph added to project"
+    );
+  }
+  /**
+   * Remove a graph from the project
+   */
+  removeGraph(id) {
+    const graphToRemove = this.graphMap.get(id);
+    if (graphToRemove) {
+      this.graphMap.delete(id);
+      this.graphs = this.graphs.filter((graph) => graph.getId() !== id);
+      logger9.info(
+        {
+          projectId: this.projectId,
+          graphId: id
+        },
+        "Graph removed from project"
+      );
+      return true;
+    }
+    return false;
+  }
+  /**
+   * Get project statistics
+   */
+  getStats() {
+    return {
+      projectId: this.projectId,
+      tenantId: this.tenantId,
+      graphCount: this.graphs.length,
+      initialized: this.initialized
+    };
+  }
+  /**
+   * Validate the project configuration
+   */
+  validate() {
+    const errors = [];
+    if (!this.projectId) {
+      errors.push("Project must have an ID");
+    }
+    if (!this.projectName) {
+      errors.push("Project must have a name");
+    }
+    const graphIds = /* @__PURE__ */ new Set();
+    for (const graph of this.graphs) {
+      const id = graph.getId();
+      if (graphIds.has(id)) {
+        errors.push(`Duplicate graph ID: ${id}`);
+      }
+      graphIds.add(id);
+    }
+    for (const graph of this.graphs) {
+      const graphValidation = graph.validate();
+      if (!graphValidation.valid) {
+        errors.push(...graphValidation.errors.map((error) => `Graph '${graph.getId()}': ${error}`));
+      }
+    }
+    return {
+      valid: errors.length === 0,
+      errors
+    };
+  }
+  /**
+   * Convert the Project to FullProjectDefinition format
+   */
+  async toFullProjectDefinition() {
+    const graphsObject = {};
+    for (const graph of this.graphs) {
+      const graphDefinition = await graph.toFullGraphDefinition();
+      graphsObject[graph.getId()] = graphDefinition;
+    }
+    return {
+      id: this.projectId,
+      name: this.projectName,
+      description: this.projectDescription || "",
+      models: this.models,
+      stopWhen: this.stopWhen,
+      graphs: graphsObject,
+      tools: {},
+      // Empty tools object as SDK doesn't manage tools directly yet
+      credentialReferences: void 0,
+      // Projects don't directly hold credentials yet
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  /**
+   * Convert project configuration to API format
+   */
+  toApiFormat() {
+    return {
+      id: this.projectId,
+      name: this.projectName,
+      description: this.projectDescription || "",
+      models: this.models,
+      stopWhen: this.stopWhen
+    };
+  }
+};
+
+// src/utils/generateIdFromName.ts
+function generateIdFromName3(name) {
+  return name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+}
+
+// src/builderFunctions.ts
+function agentGraph(config) {
+  return new AgentGraph(config);
+}
+function project(config) {
+  return new Project(config);
+}
+function agent(config) {
+  if (!config.id) {
+    throw new Error(
+      "Agent ID is required. Agents must have stable IDs for consistency across deployments."
+    );
+  }
+  return new Agent(config);
+}
+function credential(config) {
+  return agentsCore.CredentialReferenceApiInsertSchema.parse(config);
+}
+function mcpServer(config) {
+  if (!config.serverUrl) {
+    throw new Error("MCP server requires a serverUrl");
+  }
+  const id = config.id || generateIdFromName3(config.name);
+  return new Tool({
+    id,
+    name: config.name,
+    description: config.description,
+    serverUrl: config.serverUrl,
+    tenantId: config.tenantId,
+    credential: config.credential,
+    activeTools: config.activeTools,
+    headers: config.headers,
+    imageUrl: config.imageUrl,
+    transport: config.transport ? { type: config.transport } : void 0
+  });
+}
+function mcpTool(config) {
+  const configWithId = {
+    ...config,
+    id: config.id || generateIdFromName3(config.name)
+  };
+  const validatedConfig = agentsCore.MCPToolConfigSchema.parse(configWithId);
+  return new Tool(validatedConfig);
+}
+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"
+  });
+}
+function agentMcp(config) {
+  return {
+    server: config.server,
+    selectedTools: config.selectedTools
+  };
+}
+
+// src/utils/validateFunction.ts
+function validateFunction(value, name) {
+  if (typeof value !== "function") {
+    throw new Error(`${name} must be a function`);
+  }
+}
+
+// src/builders.ts
+var TransferConfigSchema = zod.z.object({
+  agent: zod.z.instanceof(Agent),
+  description: zod.z.string().optional()
+});
+function transfer(targetAgent, description, condition) {
+  if (condition !== void 0) {
+    validateFunction(condition, "condition");
+  }
+  const config = {
+    agent: targetAgent,
+    description: description || `Hand off to ${targetAgent.getName()}`,
+    condition
+  };
+  TransferConfigSchema.parse({
+    agent: config.agent,
+    description: config.description
+  });
+  return config;
+}
+
+// src/environment-settings.ts
+function createEnvironmentSettings(environments) {
+  return {
+    getEnvironmentSetting: async (key) => {
+      const currentEnv = process.env.INKEEP_ENV || "development";
+      const env = environments[currentEnv];
+      if (!env) {
+        throw new Error(
+          `Environment '${currentEnv}' not found. Available: ${Object.keys(environments).join(", ")}`
+        );
+      }
+      const credential2 = env.credentials?.[key];
+      if (!credential2) {
+        throw new Error(`Credential '${String(key)}' not found in environment '${currentEnv}'`);
+      }
+      return credential2;
+    }
+  };
+}
+function registerEnvironmentSettings(config) {
+  return config;
+}
+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 logger10 = 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 = [];
+    logger10.info(
+      {
+        graphId: graph.getId(),
+        defaultAgent: graph.getDefaultAgent()?.getName(),
+        maxTurns,
+        initialMessageCount: messageHistory.length
+      },
+      "Starting graph run"
+    );
+    while (turnCount < maxTurns) {
+      logger10.debug(
+        {
+          graphId: graph.getId(),
+          turnCount,
+          messageHistoryLength: messageHistory.length
+        },
+        "Starting turn"
+      );
+      const response = await graph.generate(messageHistory, options);
+      turnCount++;
+      logger10.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
+        }
+      };
+    }
+    logger10.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) {
+    logger10.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");
+    }
+    logger10.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) {
+        logger10.error(
+          {
+            graphId: graph.getId(),
+            error: error instanceof Error ? error.message : "Unknown error"
+          },
+          "Graph failed in race"
+        );
+        throw error;
+      }
+    });
+    const result = await Promise.race(promises);
+    logger10.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);
+
+exports.Agent = Agent;
+exports.ArtifactComponent = ArtifactComponent;
+exports.DataComponent = DataComponent;
+exports.ExternalAgent = ExternalAgent;
+exports.Project = Project;
+exports.Runner = Runner;
+exports.Tool = Tool;
+exports.agent = agent;
+exports.agentGraph = agentGraph;
+exports.agentMcp = agentMcp;
+exports.artifactComponent = artifactComponent;
+exports.createEnvironmentSettings = createEnvironmentSettings;
+exports.createFullProjectViaAPI = createFullProjectViaAPI;
+exports.credential = credential;
+exports.dataComponent = dataComponent;
+exports.deleteFullProjectViaAPI = deleteFullProjectViaAPI;
+exports.externalAgent = externalAgent;
+exports.externalAgents = externalAgents;
+exports.getFullProjectViaAPI = getFullProjectViaAPI;
+exports.mcpServer = mcpServer;
+exports.mcpTool = mcpTool;
+exports.project = project;
+exports.raceGraphs = raceGraphs;
+exports.registerEnvironmentSettings = registerEnvironmentSettings;
+exports.run = run;
+exports.stream = stream;
+exports.transfer = transfer;
+exports.updateFullProjectViaAPI = updateFullProjectViaAPI;