@inkeep/agents-sdk 0.18.1 → 0.19.0

package/dist/index.js

@@ -1,5 +1,6 @@
 import { getLogger, apiFetch, CredentialReferenceApiInsertSchema, MCPToolConfigSchema, createDatabaseClient, getProject } from '@inkeep/agents-core';
-import { isZodSchema, convertZodToJsonSchemaWithPreview } from '@inkeep/agents-core/utils/schema-conversion';
+export { ANTHROPIC_MODELS, GOOGLE_MODELS, OPENAI_MODELS } from '@inkeep/agents-core';
+import { isZodSchema, convertZodToJsonSchemaWithPreview, convertZodToJsonSchema } from '@inkeep/agents-core/utils/schema-conversion';
 import fs from 'fs';
 import { builtinModules } from 'module';
 import path from 'path';
@@ -28,9 +29,16 @@ var ArtifactComponent = class {
     __publicField(this, "initialized", false);
     __publicField(this, "id");
     this.id = config.id || generateIdFromName(config.name);
+    let processedProps;
+    if (config.props && isZodSchema(config.props)) {
+      processedProps = convertZodToJsonSchemaWithPreview(config.props);
+    } else {
+      processedProps = config.props;
+    }
     this.config = {
       ...config,
-      id: this.id
+      id: this.id,
+      props: processedProps
     };
     this.baseURL = process.env.INKEEP_API_URL || "http://localhost:3002";
     this.tenantId = "default";
@@ -43,7 +51,7 @@ var ArtifactComponent = class {
       "ArtifactComponent constructor initialized"
     );
   }
-  // Set context (tenantId, projectId, and baseURL) from external source (agent, graph, CLI, etc)
+  // Set context (tenantId, projectId, and baseURL) from external source (agent, agent, CLI, etc)
   setContext(tenantId, projectId, baseURL) {
     this.tenantId = tenantId;
     this.projectId = projectId;
@@ -169,9 +177,16 @@ var DataComponent = class {
     __publicField(this, "initialized", false);
     __publicField(this, "id");
     this.id = config.id || generateIdFromName(config.name);
+    let processedProps;
+    if (config.props && isZodSchema(config.props)) {
+      processedProps = convertZodToJsonSchema(config.props);
+    } else {
+      processedProps = config.props;
+    }
     this.config = {
       ...config,
-      id: this.id
+      id: this.id,
+      props: processedProps
     };
     this.baseURL = process.env.INKEEP_API_URL || "http://localhost:3002";
     this.tenantId = "default";
@@ -184,7 +199,7 @@ var DataComponent = class {
       "DataComponent constructor initialized"
     );
   }
-  // Set context (tenantId, projectId, and baseURL) from external source (sub-agent, graph, CLI, etc)
+  // Set context (tenantId, projectId, and baseURL) from external source (sub-agent, agent, CLI, etc)
   setContext(tenantId, projectId, baseURL) {
     this.tenantId = tenantId;
     this.projectId = projectId;
@@ -537,7 +552,7 @@ var Tool = class {
       "Tool constructor initialized"
     );
   }
-  // Set context (tenantId, projectId, and baseURL) from external source (agent, graph, CLI, etc)
+  // Set context (tenantId, projectId, and baseURL) from external source (agent, agent, CLI, etc)
   setContext(tenantId, projectId, baseURL) {
     this.tenantId = tenantId;
     this.projectId = projectId;
@@ -692,7 +707,7 @@ function normalizeAgentCanUseType(value, fallbackName) {
   throw new Error(`Invalid AgentCanUseType: expected Tool or AgentMcpConfig, got ${typeof value}`);
 }
 
-// src/agent.ts
+// src/subAgent.ts
 var logger6 = getLogger("agent");
 function resolveGetter(value) {
   if (typeof value === "function") {
@@ -721,7 +736,7 @@ var SubAgent = class {
       "Agent constructor initialized"
     );
   }
-  // Set context (tenantId, projectId, and baseURL) from external source (graph, CLI, etc)
+  // Set context (tenantId, projectId, and baseURL) from external source (agent, CLI, etc)
   setContext(tenantId, projectId, baseURL) {
     this.tenantId = tenantId;
     this.projectId = projectId;
@@ -1439,28 +1454,28 @@ var SubAgent = class {
     }
   }
 };
-var logger7 = getLogger("graphFullClient");
-async function updateFullGraphViaAPI(tenantId, projectId, apiUrl, graphId, graphData) {
+var logger7 = getLogger("agentFullClient");
+async function updateFullAgentViaAPI(tenantId, projectId, apiUrl, agentId, agentData) {
   logger7.info(
     {
       tenantId,
       projectId,
-      graphId,
+      agentId,
       apiUrl
     },
-    "Updating full graph via API"
+    "Updating full agent via API"
   );
-  const url = `${apiUrl}/tenants/${tenantId}/projects/${projectId}/graph/${graphId}`;
+  const url = `${apiUrl}/tenants/${tenantId}/projects/${projectId}/agent/${agentId}`;
   const response = await fetch(url, {
     method: "PUT",
     headers: {
       "Content-Type": "application/json"
     },
-    body: JSON.stringify(graphData)
+    body: JSON.stringify(agentData)
   });
   if (!response.ok) {
     const errorText = await response.text();
-    let errorMessage = `Failed to update graph: ${response.status} ${response.statusText}`;
+    let errorMessage = `Failed to update agent: ${response.status} ${response.statusText}`;
     try {
       const errorJson = JSON.parse(errorText);
       if (errorJson.error) {
@@ -1476,29 +1491,29 @@ async function updateFullGraphViaAPI(tenantId, projectId, apiUrl, graphId, graph
         status: response.status,
         error: errorMessage
       },
-      "Failed to update graph via API"
+      "Failed to update agent via API"
     );
     throw new Error(errorMessage);
   }
   const result = await response.json();
   logger7.info(
     {
-      graphId
+      agentId
     },
-    "Successfully updated graph via API"
+    "Successfully updated agent via API"
   );
   return result.data;
 }
 
-// src/graph.ts
-var logger8 = getLogger("graph");
+// src/agent.ts
+var logger8 = getLogger("agent");
 function resolveGetter2(value) {
   if (typeof value === "function") {
     return value();
   }
   return value;
 }
-var AgentGraph = class {
+var Agent = class {
   constructor(config) {
     __publicField(this, "subAgents", []);
     __publicField(this, "agentMap", /* @__PURE__ */ new Map());
@@ -1506,24 +1521,24 @@ var AgentGraph = class {
     __publicField(this, "baseURL");
     __publicField(this, "tenantId");
     __publicField(this, "projectId");
-    __publicField(this, "graphId");
-    __publicField(this, "graphName");
-    __publicField(this, "graphDescription");
+    __publicField(this, "agentId");
+    __publicField(this, "agentName");
+    __publicField(this, "agentDescription");
     __publicField(this, "initialized", false);
     __publicField(this, "contextConfig");
     // ContextConfigBuilder
     __publicField(this, "credentials");
     __publicField(this, "models");
     __publicField(this, "statusUpdateSettings");
-    __publicField(this, "graphPrompt");
+    __publicField(this, "agentPrompt");
     __publicField(this, "stopWhen");
     __publicField(this, "dbClient");
     this.defaultSubAgent = config.defaultSubAgent;
     this.tenantId = "default";
     this.projectId = "default";
-    this.graphId = config.id;
-    this.graphName = config.name || this.graphId;
-    this.graphDescription = config.description;
+    this.agentId = config.id;
+    this.agentName = config.name || this.agentId;
+    this.agentDescription = config.description;
     this.baseURL = process.env.INKEEP_API_URL || "http://localhost:3002";
     this.contextConfig = config.contextConfig;
     this.credentials = resolveGetter2(config.credentials);
@@ -1533,12 +1548,12 @@ var AgentGraph = class {
       url: dbUrl
     });
     this.statusUpdateSettings = config.statusUpdates;
-    this.graphPrompt = config.graphPrompt;
+    this.agentPrompt = config.agentPrompt;
     this.stopWhen = config.stopWhen ? {
       transferCountIs: config.stopWhen.transferCountIs
     } : void 0;
     this.subAgents = resolveGetter2(config.subAgents) || [];
-    this.agentMap = new Map(this.subAgents.map((agent) => [agent.getId(), agent]));
+    this.agentMap = new Map(this.subAgents.map((agent2) => [agent2.getId(), agent2]));
     if (this.defaultSubAgent) {
       this.subAgents.push(this.defaultSubAgent);
       this.agentMap.set(this.defaultSubAgent.getId(), this.defaultSubAgent);
@@ -1548,12 +1563,12 @@ var AgentGraph = class {
     }
     logger8.info(
       {
-        graphId: this.graphId,
+        agentId: this.agentId,
         tenantId: this.tenantId,
         agentCount: this.subAgents.length,
         defaultSubAgent: this.defaultSubAgent?.getName()
       },
-      "AgentGraph created"
+      "Agent created"
     );
   }
   /**
@@ -1562,14 +1577,14 @@ var AgentGraph = class {
    */
   setConfig(tenantId, projectId, apiUrl) {
     if (this.initialized) {
-      throw new Error("Cannot set config after graph has been initialized");
+      throw new Error("Cannot set config after agent has been initialized");
     }
     this.tenantId = tenantId;
     this.projectId = projectId;
     this.baseURL = apiUrl;
-    for (const agent of this.subAgents) {
-      if (this.isInternalAgent(agent)) {
-        const internalAgent = agent;
+    for (const agent2 of this.subAgents) {
+      if (this.isInternalAgent(agent2)) {
+        const internalAgent = agent2;
         if (internalAgent.setContext) {
           internalAgent.setContext(tenantId, projectId, apiUrl);
         }
@@ -1582,35 +1597,35 @@ var AgentGraph = class {
           }
         }
       } else {
-        const externalAgent2 = agent;
+        const externalAgent2 = agent2;
         if (externalAgent2.setContext) {
           externalAgent2.setContext(tenantId, apiUrl);
         }
       }
     }
     if (this.contextConfig?.setContext) {
-      this.contextConfig.setContext(tenantId, projectId, this.graphId, this.baseURL);
+      this.contextConfig.setContext(tenantId, projectId, this.agentId, this.baseURL);
     }
     logger8.info(
       {
-        graphId: this.graphId,
+        agentId: this.agentId,
         tenantId: this.tenantId,
         projectId: this.projectId,
         apiUrl: this.baseURL
       },
-      "Graph configuration updated"
+      "Agent configuration updated"
     );
   }
   /**
-   * Convert the AgentGraph to FullGraphDefinition format for the new graph endpoint
+   * Convert the Agent to FullAgentDefinition format for the new agent endpoint
    */
-  async toFullGraphDefinition() {
+  async toFullAgentDefinition() {
     const agentsObject = {};
     const functionToolsObject = {};
     const functionsObject = {};
-    for (const agent of this.subAgents) {
-      if (this.isInternalAgent(agent)) {
-        const internalAgent = agent;
+    for (const agent2 of this.subAgents) {
+      if (this.isInternalAgent(agent2)) {
+        const internalAgent = agent2;
         const transfers = internalAgent.getTransfers();
         const delegates = internalAgent.getDelegates();
         const tools = [];
@@ -1638,8 +1653,8 @@ var AgentGraph = class {
                 name: toolData.name,
                 description: toolData.description,
                 functionId: toolData.functionId,
-                graphId: this.graphId
-                // Include graphId for graph-scoped function tools
+                agentId: this.agentId
+                // Include agentId for agent-scoped function tools
               };
             }
           }
@@ -1680,7 +1695,7 @@ var AgentGraph = class {
           type: "internal"
         };
       } else {
-        const externalAgent2 = agent;
+        const externalAgent2 = agent2;
         agentsObject[externalAgent2.getId()] = {
           id: externalAgent2.getId(),
           name: externalAgent2.getName(),
@@ -1693,9 +1708,9 @@ var AgentGraph = class {
       }
     }
     return {
-      id: this.graphId,
-      name: this.graphName,
-      description: this.graphDescription,
+      id: this.agentId,
+      name: this.agentName,
+      description: this.agentDescription,
       defaultSubAgentId: this.defaultSubAgent?.getId() || "",
       subAgents: agentsObject,
       contextConfig: this.contextConfig?.toObject(),
@@ -1703,7 +1718,7 @@ var AgentGraph = class {
       ...Object.keys(functionsObject).length > 0 && { functions: functionsObject },
       models: this.models,
       statusUpdates: this.statusUpdateSettings,
-      graphPrompt: this.graphPrompt,
+      prompt: this.agentPrompt,
       createdAt: (/* @__PURE__ */ new Date()).toISOString(),
       updatedAt: (/* @__PURE__ */ new Date()).toISOString()
     };
@@ -1712,13 +1727,13 @@ var AgentGraph = class {
    * Initialize all tools in all agents (especially IPCTools that need MCP server URLs)
    */
   async initializeAllTools() {
-    logger8.info({ graphId: this.graphId }, "Initializing all tools in graph");
+    logger8.info({ agentId: this.agentId }, "Initializing all tools in agent");
     const toolInitPromises = [];
-    for (const agent of this.subAgents) {
-      if (!agent.getTools) {
+    for (const agent2 of this.subAgents) {
+      if (!agent2.getTools) {
         continue;
       }
-      const internalAgent = agent;
+      const internalAgent = agent2;
       const agentTools = internalAgent.getTools();
       for (const [toolName, toolInstance] of Object.entries(agentTools)) {
         if (toolInstance && typeof toolInstance === "object") {
@@ -1738,7 +1753,7 @@ var AgentGraph = class {
                   }
                   logger8.debug(
                     {
-                      subAgentId: agent.getId(),
+                      subAgentId: agent2.getId(),
                       toolName,
                       toolType: toolInstance.constructor.name,
                       skipDbRegistration
@@ -1748,7 +1763,7 @@ var AgentGraph = class {
                 } catch (error) {
                   logger8.error(
                     {
-                      subAgentId: agent.getId(),
+                      subAgentId: agent2.getId(),
                       toolName,
                       error: error instanceof Error ? error.message : "Unknown error"
                     },
@@ -1764,109 +1779,109 @@ var AgentGraph = class {
     }
     await Promise.all(toolInitPromises);
     logger8.info(
-      { graphId: this.graphId, toolCount: toolInitPromises.length },
+      { agentId: this.agentId, toolCount: toolInitPromises.length },
       "All tools initialized successfully"
     );
   }
   /**
-   * Initialize the graph and all agents in the backend using the new graph endpoint
+   * Initialize the agent and all agents in the backend using the new agent endpoint
    */
   async init() {
     if (this.initialized) {
-      logger8.info({ graphId: this.graphId }, "Graph already initialized");
+      logger8.info({ agentId: this.agentId }, "Agent already initialized");
       return;
     }
     logger8.info(
       {
-        graphId: this.graphId,
+        agentId: this.agentId,
         agentCount: this.subAgents.length
       },
-      "Initializing agent graph using new graph endpoint"
+      "Initializing agent using new agent endpoint"
     );
     try {
       await this.initializeAllTools();
       await this.applyModelInheritance();
-      const graphDefinition = await this.toFullGraphDefinition();
+      const agentDefinition = await this.toFullAgentDefinition();
       logger8.info(
         {
-          graphId: this.graphId,
+          agentId: this.agentId,
           mode: "api-client",
           apiUrl: this.baseURL
         },
-        "Using API client to create/update graph"
+        "Using API client to create/update agent"
       );
-      const createdGraph = await updateFullGraphViaAPI(
+      const createdAgent = await updateFullAgentViaAPI(
         this.tenantId,
         this.projectId,
         this.baseURL,
-        this.graphId,
-        graphDefinition
+        this.agentId,
+        agentDefinition
       );
       logger8.info(
         {
-          graphId: this.graphId,
-          agentCount: Object.keys(createdGraph.agents || {}).length
+          agentId: this.agentId,
+          agentCount: Object.keys(createdAgent.subAgents || {}).length
         },
-        "Agent graph initialized successfully using graph endpoint"
+        "Agent initialized successfully using agent endpoint"
       );
       this.initialized = true;
     } catch (error) {
       logger8.error(
         {
-          graphId: this.graphId,
+          agentId: this.agentId,
           error: error instanceof Error ? error.message : "Unknown error"
         },
-        "Failed to initialize agent graph using graph endpoint"
+        "Failed to initialize agent using agent endpoint"
       );
       throw error;
     }
   }
   /**
    * Legacy initialization method - kept for backward compatibility
-   * Initialize the graph and all agents in the backend using individual endpoints
+   * Initialize the agent and all agents in the backend using individual endpoints
    */
   async initLegacy() {
     if (this.initialized) {
-      logger8.info({ graphId: this.graphId }, "Graph already initialized");
+      logger8.info({ agentId: this.agentId }, "Agent already initialized");
       return;
     }
     logger8.info(
       {
-        graphId: this.graphId,
+        agentId: this.agentId,
         agentCount: this.subAgents.length
       },
-      "Initializing agent graph"
+      "Initializing agent"
     );
     try {
       if (this.contextConfig) {
         await this.contextConfig.init();
         logger8.info(
           {
-            graphId: this.graphId,
+            agentId: this.agentId,
             contextConfigId: this.contextConfig.getId()
           },
-          "Context configuration initialized for graph"
+          "Context configuration initialized for agent"
         );
       }
-      const initPromises = this.subAgents.map(async (agent) => {
+      const initPromises = this.subAgents.map(async (agent2) => {
         try {
-          agent.config.graphId = this.graphId;
-          await agent.init();
+          agent2.config.agentId = this.agentId;
+          await agent2.init();
           logger8.debug(
             {
-              subAgentId: agent.getId(),
-              graphId: this.graphId
+              subAgentId: agent2.getId(),
+              agentId: this.agentId
             },
-            "Agent initialized in graph"
+            "Agent initialized in agent"
           );
         } catch (error) {
           logger8.error(
             {
-              subAgentId: agent.getId(),
-              graphId: this.graphId,
+              subAgentId: agent2.getId(),
+              agentId: this.agentId,
               error: error instanceof Error ? error.message : "Unknown error"
             },
-            "Failed to initialize agent in graph"
+            "Failed to initialize agent in agent"
           );
           throw error;
         }
@@ -1879,18 +1894,18 @@ var AgentGraph = class {
       this.initialized = true;
       logger8.info(
         {
-          graphId: this.graphId,
+          agentId: this.agentId,
           agentCount: this.subAgents.length
         },
-        "Agent graph initialized successfully"
+        "Agent initialized successfully"
       );
     } catch (error) {
       logger8.error(
         {
-          graphId: this.graphId,
+          agentId: this.agentId,
           error: error instanceof Error ? error.message : "Unknown error"
         },
-        "Failed to initialize agent graph"
+        "Failed to initialize agent"
       );
       throw error;
     }
@@ -1901,11 +1916,11 @@ var AgentGraph = class {
   async generate(input, options) {
     await this._init();
     if (!this.defaultSubAgent) {
-      throw new Error("No default agent configured for this graph");
+      throw new Error("No default agent configured for this agent");
     }
     logger8.info(
       {
-        graphId: this.graphId,
+        agentId: this.agentId,
         defaultSubAgent: this.defaultSubAgent.getName(),
         conversationId: options?.conversationId
       },
@@ -1920,18 +1935,18 @@ var AgentGraph = class {
   async stream(input, options) {
     await this._init();
     if (!this.defaultSubAgent) {
-      throw new Error("No default agent configured for this graph");
+      throw new Error("No default agent configured for this agent");
     }
     logger8.info(
       {
-        graphId: this.graphId,
+        agentId: this.agentId,
         defaultSubAgent: this.defaultSubAgent.getName(),
         conversationId: options?.conversationId
       },
       "Streaming response with default agent"
     );
-    const textStream = async function* (graph) {
-      const response = await graph.executeWithBackend(input, options);
+    const textStream = async function* (agent2) {
+      const response = await agent2.executeWithBackend(input, options);
       const words = response.split(" ");
       for (const word of words) {
         yield `${word} `;
@@ -1948,22 +1963,22 @@ var AgentGraph = class {
     return await this.stream(input, options);
   }
   /**
-   * Run with a specific agent from the graph
+   * Run with a specific agent from the agent
    */
   async runWith(subAgentId, input, options) {
     await this._init();
-    const agent = this.getAgent(subAgentId);
-    if (!agent) {
-      throw new Error(`Agent '${subAgentId}' not found in graph`);
+    const agent2 = this.getSubAgent(subAgentId);
+    if (!agent2) {
+      throw new Error(`Agent '${subAgentId}' not found in agent`);
     }
-    if (!this.isInternalAgent(agent)) {
+    if (!this.isInternalAgent(agent2)) {
       throw new Error(
         `Agent '${subAgentId}' is an external agent and cannot be run directly. External agents are only accessible via delegation.`
       );
     }
     logger8.info(
       {
-        graphId: this.graphId,
+        agentId: this.agentId,
         subAgentId,
         conversationId: options?.conversationId
       },
@@ -1972,7 +1987,7 @@ var AgentGraph = class {
     const response = await this.executeWithBackend(input, options);
     return {
       finalOutput: response,
-      agent,
+      agent: agent2,
       turnCount: 1,
       usage: { inputTokens: 0, outputTokens: 0 },
       metadata: {
@@ -1984,48 +1999,48 @@ var AgentGraph = class {
   /**
    * Get an agent by name (unified method for all agent types)
    */
-  getAgent(name) {
+  getSubAgent(name) {
     return this.agentMap.get(name);
   }
   /**
-   * Add an agent to the graph
+   * Add an agent to the agent
    */
-  addSubAgent(agent) {
-    this.subAgents.push(agent);
-    this.agentMap.set(agent.getId(), agent);
-    if (this.models && this.isInternalAgent(agent)) {
-      this.propagateModelSettingsToAgent(agent);
+  addSubAgent(agent2) {
+    this.subAgents.push(agent2);
+    this.agentMap.set(agent2.getId(), agent2);
+    if (this.models && this.isInternalAgent(agent2)) {
+      this.propagateModelSettingsToAgent(agent2);
     }
     logger8.info(
       {
-        graphId: this.graphId,
-        subAgentId: agent.getId(),
-        agentType: this.isInternalAgent(agent) ? "internal" : "external"
+        agentId: this.agentId,
+        subAgentId: agent2.getId(),
+        agentType: this.isInternalAgent(agent2) ? "internal" : "external"
       },
-      "Agent added to graph"
+      "Agent added to agent"
     );
   }
   /**
-   * Remove an agent from the graph
+   * Remove an agent from the agent
    */
   removeSubAgent(id) {
     const agentToRemove = this.agentMap.get(id);
     if (agentToRemove) {
       this.agentMap.delete(agentToRemove.getId());
-      this.subAgents = this.subAgents.filter((agent) => agent.getId() !== agentToRemove.getId());
+      this.subAgents = this.subAgents.filter((agent2) => agent2.getId() !== agentToRemove.getId());
       logger8.info(
         {
-          graphId: this.graphId,
+          agentId: this.agentId,
           subAgentId: agentToRemove.getId()
         },
-        "Agent removed from graph"
+        "Agent removed from agent"
       );
       return true;
     }
     return false;
   }
   /**
-   * Get all agents in the graph
+   * Get all agents in the agent
    */
   getSubAgents() {
     return this.subAgents;
@@ -2039,13 +2054,13 @@ var AgentGraph = class {
   /**
    * Set the default agent
    */
-  setdefaultSubAgent(agent) {
-    this.defaultSubAgent = agent;
-    this.addSubAgent(agent);
+  setDefaultSubAgent(agent2) {
+    this.defaultSubAgent = agent2;
+    this.addSubAgent(agent2);
     logger8.info(
       {
-        graphId: this.graphId,
-        defaultSubAgent: agent.getId()
+        agentId: this.agentId,
+        defaultSubAgent: agent2.getId()
       },
       "Default agent updated"
     );
@@ -2053,106 +2068,106 @@ var AgentGraph = class {
   /**
    * Get the default agent
    */
-  getdefaultSubAgent() {
+  getDefaultSubAgent() {
     return this.defaultSubAgent;
   }
   /**
-   * Get the graph ID
+   * Get the agent ID
    */
   getId() {
-    return this.graphId;
+    return this.agentId;
   }
   getName() {
-    return this.graphName;
+    return this.agentName;
   }
   getDescription() {
-    return this.graphDescription;
+    return this.agentDescription;
   }
   getTenantId() {
     return this.tenantId;
   }
   /**
-   * Get the graph's model settingsuration
+   * Get the agent's model settingsuration
    */
   getModels() {
     return this.models;
   }
   /**
-   * Set the graph's model settingsuration
+   * Set the agent's model settingsuration
    */
   setModels(models) {
     this.models = models;
   }
   /**
-   * Get the graph's prompt configuration
+   * Get the agent's prompt configuration
    */
-  getGraphPrompt() {
-    return this.graphPrompt;
+  getAgentPrompt() {
+    return this.agentPrompt;
   }
   /**
-   * Get the graph's stopWhen configuration
+   * Get the agent's stopWhen configuration
    */
   getStopWhen() {
     return this.stopWhen || { transferCountIs: 10 };
   }
   /**
-   * Get the graph's status updates configuration
+   * Get the agent's status updates configuration
    */
   getStatusUpdateSettings() {
     return this.statusUpdateSettings;
   }
   /**
-   * Get the summarizer model from the graph's model settings
+   * Get the summarizer model from the agent's model settings
    */
   getSummarizerModel() {
     return this.models?.summarizer;
   }
   /**
-   * Get graph statistics
+   * Get agent statistics
    */
   getStats() {
     return {
       agentCount: this.subAgents.length,
       defaultSubAgent: this.defaultSubAgent?.getName() || null,
       initialized: this.initialized,
-      graphId: this.graphId,
+      agentId: this.agentId,
       tenantId: this.tenantId
     };
   }
   /**
-   * Validate the graph configuration
+   * Validate the agent configuration
    */
   validate() {
     const errors = [];
     if (this.subAgents.length === 0) {
-      errors.push("Graph must contain at least one agent");
+      errors.push("Agent must contain at least one agent");
     }
     if (!this.defaultSubAgent) {
-      errors.push("Graph must have a default agent");
+      errors.push("Agent must have a default agent");
     }
     const names = /* @__PURE__ */ new Set();
-    for (const agent of this.subAgents) {
-      const name = agent.getName();
+    for (const agent2 of this.subAgents) {
+      const name = agent2.getName();
       if (names.has(name)) {
         errors.push(`Duplicate agent name: ${name}`);
       }
       names.add(name);
     }
-    for (const agent of this.subAgents) {
-      if (!this.isInternalAgent(agent)) continue;
-      const transfers = agent.getTransfers();
+    for (const agent2 of this.subAgents) {
+      if (!this.isInternalAgent(agent2)) continue;
+      const transfers = agent2.getTransfers();
       for (const transferAgent of transfers) {
         if (!this.agentMap.has(transferAgent.getName())) {
           errors.push(
-            `Agent '${agent.getName()}' has transfer to '${transferAgent.getName()}' which is not in the graph`
+            `Agent '${agent2.getName()}' has transfer to '${transferAgent.getName()}' which is not in the agent`
           );
         }
       }
-      const delegates = agent.getDelegates();
+      const delegates = agent2.getDelegates();
       for (const delegateAgent of delegates) {
         if (!this.agentMap.has(delegateAgent.getName())) {
           errors.push(
-            `Agent '${agent.getName()}' has delegation to '${delegateAgent.getName()}' which is not in the graph`
+            `Agent '${agent2.getName()}' has delegation to '${delegateAgent.getName()}' which is not in the agent`
           );
         }
       }
@@ -2171,8 +2186,8 @@ var AgentGraph = class {
   /**
    * Type guard to check if an agent is an internal AgentInterface
    */
-  isInternalAgent(agent) {
-    return "getTransfers" in agent && typeof agent.getTransfers === "function";
+  isInternalAgent(agent2) {
+    return "getTransfers" in agent2 && typeof agent2.getTransfers === "function";
   }
   /**
    * Get project-level model settingsuration defaults
@@ -2217,7 +2232,7 @@ var AgentGraph = class {
     }
   }
   /**
-   * Apply model inheritance hierarchy: Project -> Graph -> Agent
+   * Apply model inheritance hierarchy: Project -> Agent -> Agent
    */
   async applyModelInheritance() {
     const projectModels = await this.getProjectModelDefaults();
@@ -2236,14 +2251,14 @@ var AgentGraph = class {
       }
     }
     await this.applyStopWhenInheritance();
-    for (const agent of this.subAgents) {
-      if (this.isInternalAgent(agent)) {
-        this.propagateModelSettingsToAgent(agent);
+    for (const agent2 of this.subAgents) {
+      if (this.isInternalAgent(agent2)) {
+        this.propagateModelSettingsToAgent(agent2);
       }
     }
   }
   /**
-   * Apply stopWhen inheritance hierarchy: Project -> Graph -> Agent
+   * Apply stopWhen inheritance hierarchy: Project -> Agent -> Agent
    */
   async applyStopWhenInheritance() {
     const projectStopWhen = await this.getProjectStopWhenDefaults();
@@ -2257,9 +2272,9 @@ var AgentGraph = class {
       this.stopWhen.transferCountIs = 10;
     }
     if (projectStopWhen?.stepCountIs !== void 0) {
-      for (const agent of this.subAgents) {
-        if (this.isInternalAgent(agent)) {
-          const internalAgent = agent;
+      for (const agent2 of this.subAgents) {
+        if (this.isInternalAgent(agent2)) {
+          const internalAgent = agent2;
           if (!internalAgent.config.stopWhen) {
             internalAgent.config.stopWhen = {};
           }
@@ -2271,54 +2286,54 @@ var AgentGraph = class {
     }
     logger8.debug(
       {
-        graphId: this.graphId,
-        graphStopWhen: this.stopWhen,
+        agentId: this.agentId,
+        agentStopWhen: this.stopWhen,
         projectStopWhen
       },
-      "Applied stopWhen inheritance from project to graph"
+      "Applied stopWhen inheritance from project to agent"
     );
   }
   /**
-   * Propagate graph-level model settings to agents (supporting partial inheritance)
+   * Propagate agent-level model settings to agents (supporting partial inheritance)
    */
-  propagateModelSettingsToAgent(agent) {
+  propagateModelSettingsToAgent(agent2) {
     if (this.models) {
-      if (!agent.config.models) {
-        agent.config.models = {};
+      if (!agent2.config.models) {
+        agent2.config.models = {};
       }
-      if (!agent.config.models.base && this.models.base) {
-        agent.config.models.base = this.models.base;
+      if (!agent2.config.models.base && this.models.base) {
+        agent2.config.models.base = this.models.base;
       }
-      if (!agent.config.models.structuredOutput && this.models.structuredOutput) {
-        agent.config.models.structuredOutput = this.models.structuredOutput;
+      if (!agent2.config.models.structuredOutput && this.models.structuredOutput) {
+        agent2.config.models.structuredOutput = this.models.structuredOutput;
       }
-      if (!agent.config.models.summarizer && this.models.summarizer) {
-        agent.config.models.summarizer = this.models.summarizer;
+      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
+   * Immediately propagate agent-level models to all agents during construction
    */
   propagateImmediateModelSettings() {
-    for (const agent of this.subAgents) {
-      if (this.isInternalAgent(agent)) {
-        this.propagateModelSettingsToAgent(agent);
+    for (const agent2 of this.subAgents) {
+      if (this.isInternalAgent(agent2)) {
+        this.propagateModelSettingsToAgent(agent2);
       }
     }
   }
   /**
    * Type guard to check if an agent is an external AgentInterface
    */
-  isExternalAgent(agent) {
-    return !this.isInternalAgent(agent);
+  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`;
+    const url = `${this.baseURL}/tenants/${this.tenantId}/agent/${this.agentId}/v1/chat/completions`;
     logger8.info({ url }, "Executing with backend");
     const requestBody = {
       model: "gpt-4o-mini",
@@ -2355,7 +2370,7 @@ var AgentGraph = class {
       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"}`);
+      throw new Error(`Agent execution failed: ${error.message || "Unknown error"}`);
     }
   }
   /**
@@ -2394,7 +2409,7 @@ var AgentGraph = class {
   }
   async saveToDatabase() {
     try {
-      const getUrl = `${this.baseURL}/tenants/${this.tenantId}/agent-graphs/${this.graphId}`;
+      const getUrl = `${this.baseURL}/tenants/${this.tenantId}/agents/${this.agentId}`;
       try {
         const getResponse = await fetch(getUrl, {
           method: "GET",
@@ -2403,7 +2418,7 @@ var AgentGraph = class {
           }
         });
         if (getResponse.ok) {
-          logger8.info({ graphId: this.graphId }, "Graph already exists in backend");
+          logger8.info({ agentId: this.agentId }, "Agent already exists in backend");
           return;
         }
         if (getResponse.status !== 404) {
@@ -2414,16 +2429,16 @@ var AgentGraph = class {
           throw error;
         }
       }
-      logger8.info({ graphId: this.graphId }, "Creating graph in backend");
-      const createUrl = `${this.baseURL}/tenants/${this.tenantId}/agent-graphs`;
+      logger8.info({ agentId: this.agentId }, "Creating agent in backend");
+      const createUrl = `${this.baseURL}/tenants/${this.tenantId}/agents`;
       const createResponse = await fetch(createUrl, {
         method: "POST",
         headers: {
           "Content-Type": "application/json"
         },
         body: JSON.stringify({
-          id: this.graphId,
-          name: this.graphName,
+          id: this.agentId,
+          name: this.agentName,
           defaultSubAgentId: this.defaultSubAgent?.getId() || "",
           contextConfigId: this.contextConfig?.getId(),
           models: this.models
@@ -2433,25 +2448,25 @@ var AgentGraph = class {
         throw new Error(`HTTP ${createResponse.status}: ${createResponse.statusText}`);
       }
       const createData = await createResponse.json();
-      this.graphId = createData.data.id;
-      logger8.info({ graph: createData.data }, "Graph created in backend");
+      this.agentId = createData.data.id;
+      logger8.info({ agent: createData.data }, "Agent created in backend");
     } catch (error) {
       throw new Error(
-        `Failed to save graph to database: ${error instanceof Error ? error.message : "Unknown error"}`
+        `Failed to save agent to database: ${error instanceof Error ? error.message : "Unknown error"}`
       );
     }
   }
   async saveRelations() {
     if (this.defaultSubAgent) {
       try {
-        const updateUrl = `${this.baseURL}/tenants/${this.tenantId}/agent-graphs/${this.graphId}`;
+        const updateUrl = `${this.baseURL}/tenants/${this.tenantId}/agents/${this.agentId}`;
         const updateResponse = await fetch(updateUrl, {
           method: "PUT",
           headers: {
             "Content-Type": "application/json"
           },
           body: JSON.stringify({
-            id: this.graphId,
+            id: this.agentId,
             defaultSubAgentId: this.defaultSubAgent.getId(),
             contextConfigId: this.contextConfig?.getId()
           })
@@ -2461,18 +2476,18 @@ var AgentGraph = class {
         }
         logger8.debug(
           {
-            graphId: this.graphId,
+            agentId: this.agentId,
             defaultSubAgent: this.defaultSubAgent.getName()
           },
-          "Graph relationships configured"
+          "Agent relationships configured"
         );
       } catch (error) {
         logger8.error(
           {
-            graphId: this.graphId,
+            agentId: this.agentId,
             error: error instanceof Error ? error.message : "Unknown error"
           },
-          "Failed to update graph relationships"
+          "Failed to update agent relationships"
         );
         throw error;
       }
@@ -2480,21 +2495,21 @@ var AgentGraph = class {
   }
   async createAgentRelations() {
     const allRelationPromises = [];
-    for (const agent of this.subAgents) {
-      if (this.isInternalAgent(agent)) {
-        const transfers = agent.getTransfers();
+    for (const agent2 of this.subAgents) {
+      if (this.isInternalAgent(agent2)) {
+        const transfers = agent2.getTransfers();
         for (const transferAgent of transfers) {
           allRelationPromises.push(
-            this.createInternalAgentRelation(agent, transferAgent, "transfer")
+            this.createInternalAgentRelation(agent2, transferAgent, "transfer")
           );
         }
-        const delegates = agent.getDelegates();
+        const delegates = agent2.getDelegates();
         for (const delegate of delegates) {
           if (delegate.type === "external") {
-            allRelationPromises.push(this.createExternalAgentRelation(agent, delegate, "delegate"));
+            allRelationPromises.push(this.createExternalAgentRelation(agent2, delegate, "delegate"));
           } else {
             allRelationPromises.push(
-              this.createInternalAgentRelation(agent, delegate, "delegate")
+              this.createInternalAgentRelation(agent2, delegate, "delegate")
             );
           }
         }
@@ -2511,7 +2526,7 @@ var AgentGraph = class {
         logger8.error(
           {
             error: result.reason instanceof Error ? result.reason.message : "Unknown error",
-            graphId: this.graphId
+            agentId: this.agentId
           },
           "Failed to create agent relation"
         );
@@ -2519,7 +2534,7 @@ var AgentGraph = class {
     }
     logger8.info(
       {
-        graphId: this.graphId,
+        agentId: this.agentId,
         totalRelations: allRelationPromises.length,
         successCount,
         errorCount: errors.length
@@ -2538,7 +2553,7 @@ var AgentGraph = class {
           "Content-Type": "application/json"
         },
         body: JSON.stringify({
-          graphId: this.graphId,
+          agentId: this.agentId,
           sourceSubAgentId: sourceAgent.getId(),
           targetSubAgentId: targetAgent.getId(),
           relationType
@@ -2551,7 +2566,7 @@ var AgentGraph = class {
             {
               sourceSubAgentId: sourceAgent.getId(),
               targetSubAgentId: targetAgent.getId(),
-              graphId: this.graphId,
+              agentId: this.agentId,
               relationType
             },
             `${relationType} relation already exists, skipping creation`
@@ -2564,7 +2579,7 @@ var AgentGraph = class {
         {
           sourceSubAgentId: sourceAgent.getId(),
           targetSubAgentId: targetAgent.getId(),
-          graphId: this.graphId,
+          agentId: this.agentId,
           relationType
         },
         `${relationType} relation created successfully`
@@ -2574,7 +2589,7 @@ var AgentGraph = class {
         {
           sourceSubAgentId: sourceAgent.getId(),
           targetSubAgentId: targetAgent.getId(),
-          graphId: this.graphId,
+          agentId: this.agentId,
           relationType,
           error: error instanceof Error ? error.message : "Unknown error"
         },
@@ -2591,7 +2606,7 @@ var AgentGraph = class {
           "Content-Type": "application/json"
         },
         body: JSON.stringify({
-          graphId: this.graphId,
+          agentId: this.agentId,
           sourceSubAgentId: sourceAgent.getId(),
           externalSubAgentId: externalAgent2.getId(),
           relationType
@@ -2604,7 +2619,7 @@ var AgentGraph = class {
             {
               sourceSubAgentId: sourceAgent.getId(),
               externalSubAgentId: externalAgent2.getId(),
-              graphId: this.graphId,
+              agentId: this.agentId,
               relationType
             },
             `${relationType} relation already exists, skipping creation`
@@ -2619,7 +2634,7 @@ var AgentGraph = class {
         {
           sourceSubAgentId: sourceAgent.getId(),
           externalSubAgentId: externalAgent2.getId(),
-          graphId: this.graphId,
+          agentId: this.agentId,
           relationType
         },
         `${relationType} relation created successfully`
@@ -2629,7 +2644,7 @@ var AgentGraph = class {
         {
           sourceSubAgentId: sourceAgent.getId(),
           externalSubAgentId: externalAgent2.getId(),
-          graphId: this.graphId,
+          agentId: this.agentId,
           relationType,
           error: error instanceof Error ? error.message : "Unknown error"
         },
@@ -2642,10 +2657,10 @@ var AgentGraph = class {
    * Create external agents in the database
    */
   async createExternalAgents() {
-    const externalAgents2 = this.subAgents.filter((agent) => this.isExternalAgent(agent));
+    const externalAgents2 = this.subAgents.filter((agent2) => this.isExternalAgent(agent2));
     logger8.info(
       {
-        graphId: this.graphId,
+        agentId: this.agentId,
         externalAgentCount: externalAgents2.length
       },
       "Creating external agents in database"
@@ -2656,7 +2671,7 @@ var AgentGraph = class {
         logger8.debug(
           {
             externalSubAgentId: externalAgent2.getId(),
-            graphId: this.graphId
+            agentId: this.agentId
           },
           "External agent created in database"
         );
@@ -2664,7 +2679,7 @@ var AgentGraph = class {
         logger8.error(
           {
             externalSubAgentId: externalAgent2.getId(),
-            graphId: this.graphId,
+            agentId: this.agentId,
             error: error instanceof Error ? error.message : "Unknown error"
           },
           "Failed to create external agent in database"
@@ -2676,7 +2691,7 @@ var AgentGraph = class {
       await Promise.all(initPromises);
       logger8.info(
         {
-          graphId: this.graphId,
+          agentId: this.agentId,
           externalAgentCount: externalAgents2.length
         },
         "All external agents created successfully"
@@ -2684,7 +2699,7 @@ var AgentGraph = class {
     } catch (error) {
       logger8.error(
         {
-          graphId: this.graphId,
+          agentId: this.agentId,
           error: error instanceof Error ? error.message : "Unknown error"
         },
         "Failed to create some external agents"
@@ -2943,8 +2958,8 @@ var Project = class {
     __publicField(this, "models");
     __publicField(this, "stopWhen");
     __publicField(this, "sandboxConfig");
-    __publicField(this, "graphs", []);
-    __publicField(this, "graphMap", /* @__PURE__ */ new Map());
+    __publicField(this, "agents", []);
+    __publicField(this, "agentMap", /* @__PURE__ */ new Map());
     __publicField(this, "credentialReferences", []);
     __publicField(this, "projectTools", []);
     __publicField(this, "projectDataComponents", []);
@@ -2957,11 +2972,11 @@ var Project = class {
     this.models = config.models;
     this.stopWhen = config.stopWhen;
     this.sandboxConfig = config.sandboxConfig;
-    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);
+    if (config.agents) {
+      this.agents = config.agents();
+      this.agentMap = new Map(this.agents.map((agent2) => [agent2.getId(), agent2]));
+      for (const agent2 of this.agents) {
+        agent2.setConfig(this.tenantId, this.projectId, this.baseURL);
       }
     }
     if (config.tools) {
@@ -2980,7 +2995,7 @@ var Project = class {
       {
         projectId: this.projectId,
         tenantId: this.tenantId,
-        graphCount: this.graphs.length
+        agentCount: this.agents.length
       },
       "Project created"
     );
@@ -2999,8 +3014,8 @@ var Project = class {
     if (models) {
       this.models = models;
     }
-    for (const graph of this.graphs) {
-      graph.setConfig(tenantId, this.projectId, apiUrl);
+    for (const agent2 of this.agents) {
+      agent2.setConfig(tenantId, this.projectId, apiUrl);
     }
     logger10.info(
       {
@@ -3039,7 +3054,7 @@ var Project = class {
       {
         projectId: this.projectId,
         tenantId: this.tenantId,
-        graphCount: this.graphs.length
+        agentCount: this.agents.length
       },
       "Initializing project using full project endpoint"
     );
@@ -3065,7 +3080,7 @@ var Project = class {
         {
           projectId: this.projectId,
           tenantId: this.tenantId,
-          graphCount: Object.keys(createdProject.graphs || {}).length
+          agentCount: Object.keys(createdProject.agent || {}).length
         },
         "Project initialized successfully using full project endpoint"
       );
@@ -3142,47 +3157,50 @@ var Project = class {
     }
     return { credentials, usage };
   }
+  async getFullDefinition() {
+    return await this.toFullProjectDefinition();
+  }
   /**
-   * Get all graphs in the project
+   * Get all agent in the project
    */
-  getGraphs() {
-    return this.graphs;
+  getAgents() {
+    return this.agents;
   }
   /**
-   * Get a graph by ID
+   * Get an agent by ID
    */
-  getGraph(id) {
-    return this.graphMap.get(id);
+  getAgent(id) {
+    return this.agentMap.get(id);
   }
   /**
-   * Add a graph to the project
+   * Add an agent to the project
    */
-  addGraph(graph) {
-    this.graphs.push(graph);
-    this.graphMap.set(graph.getId(), graph);
-    graph.setConfig(this.tenantId, this.projectId, this.baseURL);
+  addAgent(agent2) {
+    this.agents.push(agent2);
+    this.agentMap.set(agent2.getId(), agent2);
+    agent2.setConfig(this.tenantId, this.projectId, this.baseURL);
     logger10.info(
       {
         projectId: this.projectId,
-        graphId: graph.getId()
+        agentId: agent2.getId()
       },
-      "Graph added to project"
+      "Agent added to project"
     );
   }
   /**
-   * Remove a graph from the project
+   * Remove an agent 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);
+  removeAgent(id) {
+    const agentToRemove = this.agentMap.get(id);
+    if (agentToRemove) {
+      this.agentMap.delete(id);
+      this.agents = this.agents.filter((agent2) => agent2.getId() !== id);
       logger10.info(
         {
           projectId: this.projectId,
-          graphId: id
+          agentId: id
         },
-        "Graph removed from project"
+        "Agent removed from project"
       );
       return true;
     }
@@ -3195,7 +3213,7 @@ var Project = class {
     return {
       projectId: this.projectId,
       tenantId: this.tenantId,
-      graphCount: this.graphs.length,
+      agentCount: this.agents.length,
       initialized: this.initialized
     };
   }
@@ -3210,18 +3228,18 @@ var Project = class {
     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}`);
+    const agentIds = /* @__PURE__ */ new Set();
+    for (const agent2 of this.agents) {
+      const id = agent2.getId();
+      if (agentIds.has(id)) {
+        errors.push(`Duplicate agent ID: ${id}`);
       }
-      graphIds.add(id);
+      agentIds.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}`));
+    for (const agent2 of this.agents) {
+      const agentValidation = agent2.validate();
+      if (!agentValidation.valid) {
+        errors.push(...agentValidation.errors.map((error) => `Agent '${agent2.getId()}': ${error}`));
       }
     }
     return {
@@ -3233,7 +3251,7 @@ var Project = class {
    * Convert the Project to FullProjectDefinition format
    */
   async toFullProjectDefinition() {
-    const graphsObject = {};
+    const agentsObject = {};
     const toolsObject = {};
     const functionToolsObject = {};
     const functionsObject = {};
@@ -3241,12 +3259,12 @@ var Project = class {
     const artifactComponentsObject = {};
     const credentialReferencesObject = {};
     const credentialUsageMap = {};
-    for (const graph of this.graphs) {
-      const graphDefinition = await graph.toFullGraphDefinition();
-      graphsObject[graph.getId()] = graphDefinition;
-      const graphCredentials = graph.credentials;
-      if (graphCredentials && Array.isArray(graphCredentials)) {
-        for (const credential2 of graphCredentials) {
+    for (const agent2 of this.agents) {
+      const agentDefinition = await agent2.toFullAgentDefinition();
+      agentsObject[agent2.getId()] = agentDefinition;
+      const agentCredentials = agent2.credentials;
+      if (agentCredentials && Array.isArray(agentCredentials)) {
+        for (const credential2 of agentCredentials) {
           if (credential2?.__type === "credential-ref") {
             continue;
           }
@@ -3261,15 +3279,15 @@ var Project = class {
               credentialUsageMap[credential2.id] = [];
             }
             credentialUsageMap[credential2.id].push({
-              type: "graph",
-              id: graph.getId()
+              type: "agent",
+              id: agent2.getId()
             });
           }
         }
       }
-      const graphContextConfig = graph.contextConfig;
-      if (graphContextConfig) {
-        const contextVariables = graphContextConfig.getContextVariables?.() || graphContextConfig.contextVariables;
+      const agentContextConfig = agent2.contextConfig;
+      if (agentContextConfig) {
+        const contextVariables = agentContextConfig.getContextVariables?.() || agentContextConfig.contextVariables;
         if (contextVariables) {
           for (const [key, variable] of Object.entries(contextVariables)) {
             if (variable?.credential) {
@@ -3298,7 +3316,7 @@ var Project = class {
                 credentialUsageMap[credId].push({
                   type: "contextVariable",
                   id: key,
-                  graphId: graph.getId()
+                  agentId: agent2.getId()
                 });
               }
             } else if (variable?.credentialReferenceId) {
@@ -3309,17 +3327,17 @@ var Project = class {
               credentialUsageMap[credId].push({
                 type: "contextVariable",
                 id: key,
-                graphId: graph.getId()
+                agentId: agent2.getId()
               });
             }
           }
         }
       }
-      for (const agent of graph.getSubAgents()) {
-        if (agent.type === "external") {
+      for (const subAgent2 of agent2.getSubAgents()) {
+        if (subAgent2.type === "external") {
           continue;
         }
-        const agentTools = agent.getTools();
+        const agentTools = subAgent2.getTools();
         for (const [, toolInstance] of Object.entries(agentTools)) {
           const actualTool = toolInstance;
           const toolId = actualTool.getId();
@@ -3373,7 +3391,7 @@ var Project = class {
             }
           }
         }
-        const subAgentDataComponents = agent.getDataComponents?.();
+        const subAgentDataComponents = subAgent2.getDataComponents?.();
         if (subAgentDataComponents) {
           for (const dataComponent2 of subAgentDataComponents) {
             let dataComponentId;
@@ -3401,18 +3419,19 @@ var Project = class {
             }
           }
         }
-        const subAgentArtifactComponents = agent.getArtifactComponents?.();
+        const subAgentArtifactComponents = subAgent2.getArtifactComponents();
         if (subAgentArtifactComponents) {
           for (const artifactComponent2 of subAgentArtifactComponents) {
             let artifactComponentId;
             let artifactComponentName;
             let artifactComponentDescription;
             let artifactComponentProps;
-            if (artifactComponent2.getId) {
-              artifactComponentId = artifactComponent2.getId();
-              artifactComponentName = artifactComponent2.getName();
-              artifactComponentDescription = artifactComponent2.getDescription() || "";
-              artifactComponentProps = artifactComponent2.getProps() || {};
+            if ("getId" in artifactComponent2 && typeof artifactComponent2.getId === "function") {
+              const component = artifactComponent2;
+              artifactComponentId = component.getId();
+              artifactComponentName = component.getName();
+              artifactComponentDescription = component.getDescription() || "";
+              artifactComponentProps = component.getProps() || {};
             } else {
               artifactComponentId = artifactComponent2.id || (artifactComponent2.name ? artifactComponent2.name.toLowerCase().replace(/\s+/g, "-") : "");
               artifactComponentName = artifactComponent2.name || "";
@@ -3512,7 +3531,7 @@ var Project = class {
       models: this.models,
       stopWhen: this.stopWhen,
       sandboxConfig: this.sandboxConfig,
-      graphs: graphsObject,
+      agents: agentsObject,
       tools: toolsObject,
       functions: Object.keys(functionsObject).length > 0 ? functionsObject : void 0,
       dataComponents: Object.keys(dataComponentsObject).length > 0 ? dataComponentsObject : void 0,
@@ -3525,8 +3544,8 @@ var Project = class {
 };
 
 // src/builderFunctions.ts
-function agentGraph(config) {
-  return new AgentGraph(config);
+function agent(config) {
+  return new Agent(config);
 }
 function project(config) {
   return new Project(config);
@@ -3698,7 +3717,7 @@ var ExternalAgent = class {
       throw error;
     }
   }
-  // Set context (tenantId and baseURL) from external source (graph, CLI, etc)
+  // Set context (tenantId and baseURL) from external source (agent, CLI, etc)
   setContext(tenantId, baseURL) {
     this.tenantId = tenantId;
     if (baseURL) {
@@ -3839,58 +3858,58 @@ var MaxTurnsExceededError = class extends AgentError {
 var logger12 = getLogger("runner");
 var Runner = class _Runner {
   /**
-   * Run a graph until completion, handling transfers and tool calls
+   * Run an agent until completion, handling transfers and tool calls
    * Similar to OpenAI's Runner.run() pattern
-   * NOTE: This now requires a graph instead of an agent
+   * NOTE: This now requires an agent instead of an agent
    */
-  static async run(graph, messages, options) {
+  static async run(agent2, messages, options) {
     const maxTurns = options?.maxTurns || 10;
     let turnCount = 0;
     const messageHistory = _Runner.normalizeToMessageHistory(messages);
     const allToolCalls = [];
     logger12.info(
       {
-        graphId: graph.getId(),
-        defaultSubAgent: graph.getdefaultSubAgent()?.getName(),
+        agentId: agent2.getId(),
+        defaultSubAgent: agent2.getDefaultSubAgent()?.getName(),
         maxTurns,
         initialMessageCount: messageHistory.length
       },
-      "Starting graph run"
+      "Starting agent run"
     );
     while (turnCount < maxTurns) {
       logger12.debug(
         {
-          graphId: graph.getId(),
+          agentId: agent2.getId(),
           turnCount,
           messageHistoryLength: messageHistory.length
         },
         "Starting turn"
       );
-      const response = await graph.generate(messageHistory, options);
+      const response = await agent2.generate(messageHistory, options);
       turnCount++;
       logger12.info(
         {
-          graphId: graph.getId(),
+          agentId: agent2.getId(),
           turnCount,
           responseLength: response.length
         },
-        "Graph generation completed"
+        "Agent generation completed"
       );
       return {
         finalOutput: response,
-        agent: graph.getdefaultSubAgent() || {},
+        agent: agent2.getDefaultSubAgent() || {},
         turnCount,
         usage: { inputTokens: 0, outputTokens: 0 },
         metadata: {
           toolCalls: allToolCalls,
           transfers: []
-          // Graph handles transfers internally
+          // Agent handles transfers internally
         }
       };
     }
     logger12.error(
       {
-        graphId: graph.getId(),
+        agentId: agent2.getId(),
         maxTurns,
         finalTurnCount: turnCount
       },
@@ -3899,43 +3918,43 @@ var Runner = class _Runner {
     throw new MaxTurnsExceededError(maxTurns);
   }
   /**
-   * Stream a graph's response
+   * Stream an agent's response
    */
-  static async stream(graph, messages, options) {
+  static async stream(agent2, messages, options) {
     logger12.info(
       {
-        graphId: graph.getId(),
-        defaultSubAgent: graph.getdefaultSubAgent()?.getName()
+        agentId: agent2.getId(),
+        defaultSubAgent: agent2.getDefaultSubAgent()?.getName()
       },
-      "Starting graph stream"
+      "Starting agent stream"
     );
-    return graph.stream(messages, options);
+    return agent2.stream(messages, options);
   }
   /**
-   * Execute multiple graphs in parallel and return the first successful result
+   * Execute multiple agent 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");
+  static async raceAgents(agent2, messages, options) {
+    if (agent2.length === 0) {
+      throw new Error("No agent provided for race");
     }
     logger12.info(
       {
-        graphCount: graphs.length,
-        graphIds: graphs.map((g) => g.getId())
+        agentCount: agent2.length,
+        agentIds: agent2.map((g) => g.getId())
       },
-      "Starting graph race"
+      "Starting agent race"
     );
-    const promises = graphs.map(async (graph, index) => {
+    const promises = agent2.map(async (agent3, index) => {
       try {
-        const result2 = await _Runner.run(graph, messages, options);
+        const result2 = await _Runner.run(agent3, messages, options);
         return { ...result2, raceIndex: index };
       } catch (error) {
         logger12.error(
           {
-            graphId: graph.getId(),
+            agentId: agent3.getId(),
             error: error instanceof Error ? error.message : "Unknown error"
           },
-          "Graph failed in race"
+          "Agent failed in race"
         );
         throw error;
       }
@@ -3943,10 +3962,10 @@ var Runner = class _Runner {
     const result = await Promise.race(promises);
     logger12.info(
       {
-        winningGraphId: result.graphId || "unknown",
+        winningAgentId: result.agentId || "unknown",
         raceIndex: result.raceIndex
       },
-      "Graph race completed"
+      "Agent race completed"
     );
     return result;
   }
@@ -3963,14 +3982,14 @@ var Runner = class _Runner {
     return [messages];
   }
   /**
-   * Validate graph configuration before running
+   * Validate agent configuration before running
    */
-  static validateGraph(graph) {
+  static validateAgent(agent2) {
     const errors = [];
-    if (!graph.getId()) {
-      errors.push("Graph ID is required");
+    if (!agent2.getId()) {
+      errors.push("Agent ID is required");
     }
-    const defaultSubAgent = graph.getdefaultSubAgent();
+    const defaultSubAgent = agent2.getDefaultSubAgent();
     if (!defaultSubAgent) {
       errors.push("Default agent is required");
     } else {
@@ -3981,12 +4000,12 @@ var Runner = class _Runner {
         errors.push("Default agent instructions are required");
       }
     }
-    const agents = graph.getSubAgents();
-    if (agents.length === 0) {
-      errors.push("Graph must contain at least one agent");
+    const subAgents = agent2.getSubAgents();
+    if (subAgents.length === 0) {
+      errors.push("Agent must contain at least one subagent");
     }
-    for (const agent of agents) {
-      if (!agent.getName()) {
+    for (const subAgent2 of subAgents) {
+      if (!subAgent2.getName()) {
         errors.push(`Agent missing name`);
       }
     }
@@ -3996,23 +4015,23 @@ var Runner = class _Runner {
     };
   }
   /**
-   * Get execution statistics for a graph
+   * Get execution statistics for an agent
    */
-  static async getExecutionStats(graph, messages, options) {
-    const agents = graph.getSubAgents();
-    const defaultSubAgent = graph.getdefaultSubAgent();
+  static async getExecutionStats(agent2, messages, options) {
+    const subAgents = agent2.getSubAgents();
+    const defaultSubAgent = agent2.getDefaultSubAgent();
     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,
+      subAgentCount: subAgents.length,
       defaultSubAgent: defaultSubAgent?.getName()
     };
   }
 };
 var run = Runner.run.bind(Runner);
 var stream = Runner.stream.bind(Runner);
-var raceGraphs = Runner.raceGraphs.bind(Runner);
+var raceAgents = Runner.raceAgents.bind(Runner);
 
-export { SubAgent as Agent, ArtifactComponent, DataComponent, ExternalAgent, FunctionTool, Project, Runner, Tool, subAgent as agent, agentGraph, agentMcp, artifactComponent, createEnvironmentSettings, createFullProjectViaAPI, credential, credentialRef, dataComponent, deleteFullProjectViaAPI, externalAgent, externalAgents, functionTool, getFullProjectViaAPI, isCredentialReference, mcpServer, mcpTool, project, raceGraphs, registerEnvironmentSettings, run, stream, transfer, updateFullProjectViaAPI };
+export { ArtifactComponent, DataComponent, ExternalAgent, FunctionTool, Project, Runner, SubAgent, Tool, agent, agentMcp, artifactComponent, createEnvironmentSettings, createFullProjectViaAPI, credential, credentialRef, dataComponent, deleteFullProjectViaAPI, externalAgent, externalAgents, functionTool, getFullProjectViaAPI, isCredentialReference, mcpServer, mcpTool, project, raceAgents, registerEnvironmentSettings, run, stream, subAgent, transfer, updateFullProjectViaAPI };