@inkeep/agents-sdk 0.18.0 → 0.19.0

package/dist/index.cjs

@@ -56,9 +56,16 @@ var ArtifactComponent = class {
     __publicField(this, "initialized", false);
     __publicField(this, "id");
     this.id = config.id || generateIdFromName(config.name);
+    let processedProps;
+    if (config.props && schemaConversion.isZodSchema(config.props)) {
+      processedProps = schemaConversion.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";
@@ -71,7 +78,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;
@@ -197,9 +204,16 @@ var DataComponent = class {
     __publicField(this, "initialized", false);
     __publicField(this, "id");
     this.id = config.id || generateIdFromName(config.name);
+    let processedProps;
+    if (config.props && schemaConversion.isZodSchema(config.props)) {
+      processedProps = schemaConversion.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";
@@ -212,7 +226,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;
@@ -488,8 +502,8 @@ var FunctionTool = class {
       for (const dep in deps) {
         if (deps[dep] === false) {
           delete deps[dep];
+          throw new Error(`Dependency \x1B[1;32m${dep}\x1B[0m used in function tool \x1B[1;32m${config.name}\x1B[0m is neither installed nor in dependencies object.`);
         }
-        throw new Error(`Dependency \x1B[1;32m${dep}\x1B[0m used in function tool \x1B[1;32m${config.name}\x1B[0m is neither installed nor in dependencies object.`);
       }
       this.config.dependencies = deps;
     }
@@ -565,7 +579,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;
@@ -720,7 +734,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 = agentsCore.getLogger("agent");
 function resolveGetter(value) {
   if (typeof value === "function") {
@@ -749,7 +763,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;
@@ -1467,28 +1481,28 @@ var SubAgent = class {
     }
   }
 };
-var logger7 = agentsCore.getLogger("graphFullClient");
-async function updateFullGraphViaAPI(tenantId, projectId, apiUrl, graphId, graphData) {
+var logger7 = agentsCore.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) {
@@ -1504,29 +1518,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 = agentsCore.getLogger("graph");
+// src/agent.ts
+var logger8 = agentsCore.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());
@@ -1534,24 +1548,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);
@@ -1561,12 +1575,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);
@@ -1576,12 +1590,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"
     );
   }
   /**
@@ -1590,14 +1604,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);
         }
@@ -1610,35 +1624,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 = [];
@@ -1666,8 +1680,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
               };
             }
           }
@@ -1708,7 +1722,7 @@ var AgentGraph = class {
           type: "internal"
         };
       } else {
-        const externalAgent2 = agent;
+        const externalAgent2 = agent2;
         agentsObject[externalAgent2.getId()] = {
           id: externalAgent2.getId(),
           name: externalAgent2.getName(),
@@ -1721,9 +1735,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(),
@@ -1731,7 +1745,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()
     };
@@ -1740,13 +1754,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") {
@@ -1766,7 +1780,7 @@ var AgentGraph = class {
                   }
                   logger8.debug(
                     {
-                      subAgentId: agent.getId(),
+                      subAgentId: agent2.getId(),
                       toolName,
                       toolType: toolInstance.constructor.name,
                       skipDbRegistration
@@ -1776,7 +1790,7 @@ var AgentGraph = class {
                 } catch (error) {
                   logger8.error(
                     {
-                      subAgentId: agent.getId(),
+                      subAgentId: agent2.getId(),
                       toolName,
                       error: error instanceof Error ? error.message : "Unknown error"
                     },
@@ -1792,109 +1806,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;
         }
@@ -1907,18 +1921,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;
     }
@@ -1929,11 +1943,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
       },
@@ -1948,18 +1962,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} `;
@@ -1976,22 +1990,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
       },
@@ -2000,7 +2014,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: {
@@ -2012,48 +2026,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;
@@ -2067,13 +2081,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"
     );
@@ -2081,106 +2095,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`
           );
         }
       }
@@ -2199,8 +2213,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
@@ -2245,7 +2259,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();
@@ -2264,14 +2278,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();
@@ -2285,9 +2299,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 = {};
           }
@@ -2299,54 +2313,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",
@@ -2383,7 +2397,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"}`);
     }
   }
   /**
@@ -2422,7 +2436,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",
@@ -2431,7 +2445,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) {
@@ -2442,16 +2456,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
@@ -2461,25 +2475,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()
           })
@@ -2489,18 +2503,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;
       }
@@ -2508,21 +2522,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")
             );
           }
         }
@@ -2539,7 +2553,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"
         );
@@ -2547,7 +2561,7 @@ var AgentGraph = class {
     }
     logger8.info(
       {
-        graphId: this.graphId,
+        agentId: this.agentId,
         totalRelations: allRelationPromises.length,
         successCount,
         errorCount: errors.length
@@ -2566,7 +2580,7 @@ var AgentGraph = class {
           "Content-Type": "application/json"
         },
         body: JSON.stringify({
-          graphId: this.graphId,
+          agentId: this.agentId,
           sourceSubAgentId: sourceAgent.getId(),
           targetSubAgentId: targetAgent.getId(),
           relationType
@@ -2579,7 +2593,7 @@ var AgentGraph = class {
             {
               sourceSubAgentId: sourceAgent.getId(),
               targetSubAgentId: targetAgent.getId(),
-              graphId: this.graphId,
+              agentId: this.agentId,
               relationType
             },
             `${relationType} relation already exists, skipping creation`
@@ -2592,7 +2606,7 @@ var AgentGraph = class {
         {
           sourceSubAgentId: sourceAgent.getId(),
           targetSubAgentId: targetAgent.getId(),
-          graphId: this.graphId,
+          agentId: this.agentId,
           relationType
         },
         `${relationType} relation created successfully`
@@ -2602,7 +2616,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"
         },
@@ -2619,7 +2633,7 @@ var AgentGraph = class {
           "Content-Type": "application/json"
         },
         body: JSON.stringify({
-          graphId: this.graphId,
+          agentId: this.agentId,
           sourceSubAgentId: sourceAgent.getId(),
           externalSubAgentId: externalAgent2.getId(),
           relationType
@@ -2632,7 +2646,7 @@ var AgentGraph = class {
             {
               sourceSubAgentId: sourceAgent.getId(),
               externalSubAgentId: externalAgent2.getId(),
-              graphId: this.graphId,
+              agentId: this.agentId,
               relationType
             },
             `${relationType} relation already exists, skipping creation`
@@ -2647,7 +2661,7 @@ var AgentGraph = class {
         {
           sourceSubAgentId: sourceAgent.getId(),
           externalSubAgentId: externalAgent2.getId(),
-          graphId: this.graphId,
+          agentId: this.agentId,
           relationType
         },
         `${relationType} relation created successfully`
@@ -2657,7 +2671,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"
         },
@@ -2670,10 +2684,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"
@@ -2684,7 +2698,7 @@ var AgentGraph = class {
         logger8.debug(
           {
             externalSubAgentId: externalAgent2.getId(),
-            graphId: this.graphId
+            agentId: this.agentId
           },
           "External agent created in database"
         );
@@ -2692,7 +2706,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"
@@ -2704,7 +2718,7 @@ var AgentGraph = class {
       await Promise.all(initPromises);
       logger8.info(
         {
-          graphId: this.graphId,
+          agentId: this.agentId,
           externalAgentCount: externalAgents2.length
         },
         "All external agents created successfully"
@@ -2712,7 +2726,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"
@@ -2971,8 +2985,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", []);
@@ -2985,11 +2999,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) {
@@ -3008,7 +3022,7 @@ var Project = class {
       {
         projectId: this.projectId,
         tenantId: this.tenantId,
-        graphCount: this.graphs.length
+        agentCount: this.agents.length
       },
       "Project created"
     );
@@ -3027,8 +3041,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(
       {
@@ -3067,7 +3081,7 @@ var Project = class {
       {
         projectId: this.projectId,
         tenantId: this.tenantId,
-        graphCount: this.graphs.length
+        agentCount: this.agents.length
       },
       "Initializing project using full project endpoint"
     );
@@ -3093,7 +3107,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"
       );
@@ -3170,47 +3184,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;
     }
@@ -3223,7 +3240,7 @@ var Project = class {
     return {
       projectId: this.projectId,
       tenantId: this.tenantId,
-      graphCount: this.graphs.length,
+      agentCount: this.agents.length,
       initialized: this.initialized
     };
   }
@@ -3238,18 +3255,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 {
@@ -3261,7 +3278,7 @@ var Project = class {
    * Convert the Project to FullProjectDefinition format
    */
   async toFullProjectDefinition() {
-    const graphsObject = {};
+    const agentsObject = {};
     const toolsObject = {};
     const functionToolsObject = {};
     const functionsObject = {};
@@ -3269,12 +3286,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;
           }
@@ -3289,15 +3306,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) {
@@ -3326,7 +3343,7 @@ var Project = class {
                 credentialUsageMap[credId].push({
                   type: "contextVariable",
                   id: key,
-                  graphId: graph.getId()
+                  agentId: agent2.getId()
                 });
               }
             } else if (variable?.credentialReferenceId) {
@@ -3337,17 +3354,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();
@@ -3401,7 +3418,7 @@ var Project = class {
             }
           }
         }
-        const subAgentDataComponents = agent.getDataComponents?.();
+        const subAgentDataComponents = subAgent2.getDataComponents?.();
         if (subAgentDataComponents) {
           for (const dataComponent2 of subAgentDataComponents) {
             let dataComponentId;
@@ -3429,18 +3446,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 || "";
@@ -3540,7 +3558,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,
@@ -3553,8 +3571,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);
@@ -3726,7 +3744,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) {
@@ -3867,58 +3885,58 @@ var MaxTurnsExceededError = class extends AgentError {
 var logger12 = agentsCore.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
       },
@@ -3927,43 +3945,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;
       }
@@ -3971,10 +3989,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;
   }
@@ -3991,14 +4009,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 {
@@ -4009,12 +4027,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`);
       }
     }
@@ -4024,35 +4042,46 @@ 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);
 
-exports.Agent = SubAgent;
+Object.defineProperty(exports, "ANTHROPIC_MODELS", {
+  enumerable: true,
+  get: function () { return agentsCore.ANTHROPIC_MODELS; }
+});
+Object.defineProperty(exports, "GOOGLE_MODELS", {
+  enumerable: true,
+  get: function () { return agentsCore.GOOGLE_MODELS; }
+});
+Object.defineProperty(exports, "OPENAI_MODELS", {
+  enumerable: true,
+  get: function () { return agentsCore.OPENAI_MODELS; }
+});
 exports.ArtifactComponent = ArtifactComponent;
 exports.DataComponent = DataComponent;
 exports.ExternalAgent = ExternalAgent;
 exports.FunctionTool = FunctionTool;
 exports.Project = Project;
 exports.Runner = Runner;
+exports.SubAgent = SubAgent;
 exports.Tool = Tool;
-exports.agent = subAgent;
-exports.agentGraph = agentGraph;
+exports.agent = agent;
 exports.agentMcp = agentMcp;
 exports.artifactComponent = artifactComponent;
 exports.createEnvironmentSettings = createEnvironmentSettings;
@@ -4069,9 +4098,10 @@ exports.isCredentialReference = isCredentialReference;
 exports.mcpServer = mcpServer;
 exports.mcpTool = mcpTool;
 exports.project = project;
-exports.raceGraphs = raceGraphs;
+exports.raceAgents = raceAgents;
 exports.registerEnvironmentSettings = registerEnvironmentSettings;
 exports.run = run;
 exports.stream = stream;
+exports.subAgent = subAgent;
 exports.transfer = transfer;
 exports.updateFullProjectViaAPI = updateFullProjectViaAPI;