@inkeep/agents-sdk 0.1.6 → 0.1.8

package/dist/index.cjs

@@ -81,10 +81,7 @@ var ArtifactComponent = class {
       summaryProps: this.config.summaryProps,
       fullProps: this.config.fullProps
     };
-    logger.info(
-      { artifactComponentData },
-      "artifactComponentData for create/update"
-    );
+    logger.info({ artifactComponentData }, "artifactComponentData for create/update");
     const updateResponse = await fetch(
       `${this.baseURL}/tenants/${this.tenantId}/crud/artifact-components/${this.getId()}`,
       {
@@ -596,16 +593,13 @@ var Agent = class {
         },
         "Agent not found, creating new agent"
       );
-      const createResponse = await fetch(
-        `${this.baseURL}/tenants/${this.tenantId}/crud/agents`,
-        {
-          method: "POST",
-          headers: {
-            "Content-Type": "application/json"
-          },
-          body: JSON.stringify(agentData)
-        }
-      );
+      const createResponse = await fetch(`${this.baseURL}/tenants/${this.tenantId}/crud/agents`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify(agentData)
+      });
       if (!createResponse.ok) {
         const errorText2 = await createResponse.text().catch(() => "Unknown error");
         throw new Error(
@@ -656,10 +650,7 @@ var Agent = class {
     }
   }
   async saveDataComponents() {
-    logger4.info(
-      { dataComponents: this.config.dataComponents },
-      "dataComponents and config"
-    );
+    logger4.info({ dataComponents: this.config.dataComponents }, "dataComponents and config");
     const components = resolveGetter(this.config.dataComponents);
     if (components) {
       for (const dataComponent2 of components) {
@@ -1304,14 +1295,10 @@ var AgentGraph = class {
         for (const [toolName, toolInstance] of Object.entries(agentTools)) {
           if (toolInstance && typeof toolInstance === "object") {
             let toolId;
-            if ("server" in toolInstance && "selectedTools" in toolInstance) {
-              const mcpConfig = toolInstance;
-              toolId = mcpConfig.server.getId();
-              if (mcpConfig.selectedTools !== void 0) {
-                selectedToolsMapping[toolId] = mcpConfig.selectedTools;
-              }
-            } else {
-              toolId = toolInstance.getId?.() || toolInstance.id || toolName;
+            toolId = toolInstance.getId?.() || toolInstance.id;
+            if ("selectedTools" in toolInstance && toolInstance.selectedTools !== void 0) {
+              logger7.info({ toolId, selectedTools: toolInstance.selectedTools }, "Selected tools");
+              selectedToolsMapping[toolId] = toolInstance.selectedTools;
             }
             tools.push(toolId);
           }
@@ -1804,9 +1791,7 @@ var AgentGraph = class {
     const agentToRemove = this.agentMap.get(id);
     if (agentToRemove) {
       this.agentMap.delete(agentToRemove.getId());
-      this.agents = this.agents.filter(
-        (agent2) => agent2.getId() !== agentToRemove.getId()
-      );
+      this.agents = this.agents.filter((agent2) => agent2.getId() !== agentToRemove.getId());
       logger7.info(
         {
           graphId: this.graphId,
@@ -1973,10 +1958,10 @@ var AgentGraph = class {
    */
   async getProjectModelDefaults() {
     try {
-      const project = await agentsCore.getProject(this.dbClient)({
+      const project2 = await agentsCore.getProject(this.dbClient)({
         scopes: { tenantId: this.tenantId, projectId: this.projectId }
       });
-      return project?.models;
+      return project2?.models;
     } catch (error) {
       logger7.warn(
         {
@@ -1994,10 +1979,10 @@ var AgentGraph = class {
    */
   async getProjectStopWhenDefaults() {
     try {
-      const project = await agentsCore.getProject(this.dbClient)({
+      const project2 = await agentsCore.getProject(this.dbClient)({
         scopes: { tenantId: this.tenantId, projectId: this.projectId }
       });
-      return project?.stopWhen;
+      return project2?.stopWhen;
     } catch (error) {
       logger7.warn(
         {
@@ -2149,9 +2134,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(`Graph execution failed: ${error.message || "Unknown error"}`);
     }
   }
   /**
@@ -2184,9 +2167,7 @@ var AgentGraph = class {
       return [{ role: "user", content: input }];
     }
     if (Array.isArray(input)) {
-      return input.map(
-        (msg) => typeof msg === "string" ? { role: "user", content: msg } : msg
-      );
+      return input.map((msg) => typeof msg === "string" ? { role: "user", content: msg } : msg);
     }
     return [input];
   }
@@ -2201,16 +2182,11 @@ var AgentGraph = class {
           }
         });
         if (getResponse.ok) {
-          logger7.info(
-            { graphId: this.graphId },
-            "Graph already exists in backend"
-          );
+          logger7.info({ graphId: this.graphId }, "Graph already exists in backend");
           return;
         }
         if (getResponse.status !== 404) {
-          throw new Error(
-            `HTTP ${getResponse.status}: ${getResponse.statusText}`
-          );
+          throw new Error(`HTTP ${getResponse.status}: ${getResponse.statusText}`);
         }
       } catch (error) {
         if (!error.message.includes("404")) {
@@ -2233,9 +2209,7 @@ var AgentGraph = class {
         })
       });
       if (!createResponse.ok) {
-        throw new Error(
-          `HTTP ${createResponse.status}: ${createResponse.statusText}`
-        );
+        throw new Error(`HTTP ${createResponse.status}: ${createResponse.statusText}`);
       }
       const createData = await createResponse.json();
       this.graphId = createData.data.id;
@@ -2262,9 +2236,7 @@ var AgentGraph = class {
           })
         });
         if (!updateResponse.ok) {
-          throw new Error(
-            `HTTP ${updateResponse.status}: ${updateResponse.statusText}`
-          );
+          throw new Error(`HTTP ${updateResponse.status}: ${updateResponse.statusText}`);
         }
         logger7.debug(
           {
@@ -2298,16 +2270,10 @@ var AgentGraph = class {
         const delegates = agent2.getDelegates();
         for (const delegate of delegates) {
           if (delegate instanceof ExternalAgent) {
-            allRelationPromises.push(
-              this.createExternalAgentRelation(agent2, delegate, "delegate")
-            );
+            allRelationPromises.push(this.createExternalAgentRelation(agent2, delegate, "delegate"));
           } else {
             allRelationPromises.push(
-              this.createInternalAgentRelation(
-                agent2,
-                delegate,
-                "delegate"
-              )
+              this.createInternalAgentRelation(agent2, delegate, "delegate")
             );
           }
         }
@@ -2374,9 +2340,7 @@ var AgentGraph = class {
           );
           return;
         }
-        throw new Error(
-          `Failed to create agent relation: ${response.status} - ${errorText}`
-        );
+        throw new Error(`Failed to create agent relation: ${response.status} - ${errorText}`);
       }
       logger7.info(
         {
@@ -2464,9 +2428,7 @@ var AgentGraph = class {
    * Create external agents in the database
    */
   async createExternalAgents() {
-    const externalAgents2 = this.agents.filter(
-      (agent2) => this.isExternalAgent(agent2)
-    );
+    const externalAgents2 = this.agents.filter((agent2) => this.isExternalAgent(agent2));
     logger7.info(
       {
         graphId: this.graphId,
@@ -2517,6 +2479,511 @@ var AgentGraph = class {
     }
   }
 };
+var logger8 = agentsCore.getLogger("projectFullClient");
+async function createFullProjectViaAPI(tenantId, apiUrl, projectData) {
+  logger8.info(
+    {
+      tenantId,
+      projectId: projectData.id,
+      apiUrl
+    },
+    "Creating full project via API"
+  );
+  const url = `${apiUrl}/tenants/${tenantId}/project-full`;
+  const response = await fetch(url, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify(projectData)
+  });
+  if (!response.ok) {
+    const errorText = await response.text();
+    let errorMessage = `Failed to create project: ${response.status} ${response.statusText}`;
+    try {
+      const errorJson = JSON.parse(errorText);
+      if (errorJson.error) {
+        errorMessage = errorJson.error;
+      }
+    } catch {
+      if (errorText) {
+        errorMessage = errorText;
+      }
+    }
+    logger8.error(
+      {
+        status: response.status,
+        error: errorMessage
+      },
+      "Failed to create project via API"
+    );
+    throw new Error(errorMessage);
+  }
+  const result = await response.json();
+  logger8.info(
+    {
+      projectId: projectData.id
+    },
+    "Successfully created project via API"
+  );
+  return result.data;
+}
+async function updateFullProjectViaAPI(tenantId, apiUrl, projectId, projectData) {
+  logger8.info(
+    {
+      tenantId,
+      projectId,
+      apiUrl
+    },
+    "Updating full project via API"
+  );
+  const url = `${apiUrl}/tenants/${tenantId}/project-full/${projectId}`;
+  const response = await fetch(url, {
+    method: "PUT",
+    headers: {
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify(projectData)
+  });
+  if (!response.ok) {
+    const errorText = await response.text();
+    let errorMessage = `Failed to update project: ${response.status} ${response.statusText}`;
+    try {
+      const errorJson = JSON.parse(errorText);
+      if (errorJson.error) {
+        errorMessage = errorJson.error;
+      }
+    } catch {
+      if (errorText) {
+        errorMessage = errorText;
+      }
+    }
+    logger8.error(
+      {
+        status: response.status,
+        error: errorMessage
+      },
+      "Failed to update project via API"
+    );
+    throw new Error(errorMessage);
+  }
+  const result = await response.json();
+  logger8.info(
+    {
+      projectId
+    },
+    "Successfully updated project via API"
+  );
+  return result.data;
+}
+async function getFullProjectViaAPI(tenantId, apiUrl, projectId) {
+  logger8.info(
+    {
+      tenantId,
+      projectId,
+      apiUrl
+    },
+    "Getting full project via API"
+  );
+  const url = `${apiUrl}/tenants/${tenantId}/project-full/${projectId}`;
+  const response = await fetch(url, {
+    method: "GET",
+    headers: {
+      "Content-Type": "application/json"
+    }
+  });
+  if (!response.ok) {
+    if (response.status === 404) {
+      logger8.info(
+        {
+          projectId
+        },
+        "Project not found"
+      );
+      return null;
+    }
+    const errorText = await response.text();
+    let errorMessage = `Failed to get project: ${response.status} ${response.statusText}`;
+    try {
+      const errorJson = JSON.parse(errorText);
+      if (errorJson.error) {
+        errorMessage = errorJson.error;
+      }
+    } catch {
+      if (errorText) {
+        errorMessage = errorText;
+      }
+    }
+    logger8.error(
+      {
+        status: response.status,
+        error: errorMessage
+      },
+      "Failed to get project via API"
+    );
+    throw new Error(errorMessage);
+  }
+  const result = await response.json();
+  logger8.info(
+    {
+      projectId
+    },
+    "Successfully retrieved project via API"
+  );
+  return result.data;
+}
+async function deleteFullProjectViaAPI(tenantId, apiUrl, projectId) {
+  logger8.info(
+    {
+      tenantId,
+      projectId,
+      apiUrl
+    },
+    "Deleting full project via API"
+  );
+  const url = `${apiUrl}/tenants/${tenantId}/project-full/${projectId}`;
+  const response = await fetch(url, {
+    method: "DELETE",
+    headers: {
+      "Content-Type": "application/json"
+    }
+  });
+  if (!response.ok) {
+    const errorText = await response.text();
+    let errorMessage = `Failed to delete project: ${response.status} ${response.statusText}`;
+    try {
+      const errorJson = JSON.parse(errorText);
+      if (errorJson.error) {
+        errorMessage = errorJson.error;
+      }
+    } catch {
+      if (errorText) {
+        errorMessage = errorText;
+      }
+    }
+    logger8.error(
+      {
+        status: response.status,
+        error: errorMessage
+      },
+      "Failed to delete project via API"
+    );
+    throw new Error(errorMessage);
+  }
+  logger8.info(
+    {
+      projectId
+    },
+    "Successfully deleted project via API"
+  );
+}
+
+// src/project.ts
+var logger9 = agentsCore.getLogger("project");
+var Project = class {
+  constructor(config) {
+    __publicField(this, "projectId");
+    __publicField(this, "projectName");
+    __publicField(this, "projectDescription");
+    __publicField(this, "tenantId");
+    __publicField(this, "baseURL");
+    __publicField(this, "initialized", false);
+    __publicField(this, "models");
+    __publicField(this, "stopWhen");
+    __publicField(this, "graphs", []);
+    __publicField(this, "graphMap", /* @__PURE__ */ new Map());
+    this.projectId = config.id;
+    this.projectName = config.name;
+    this.projectDescription = config.description;
+    this.tenantId = config.tenantId || "default";
+    this.baseURL = process.env.INKEEP_API_URL || "http://localhost:3002";
+    this.models = config.models;
+    this.stopWhen = config.stopWhen;
+    if (config.graphs) {
+      this.graphs = config.graphs();
+      this.graphMap = new Map(this.graphs.map((graph) => [graph.getId(), graph]));
+      for (const graph of this.graphs) {
+        graph.setConfig(this.tenantId, this.projectId, this.baseURL);
+      }
+    }
+    logger9.info(
+      {
+        projectId: this.projectId,
+        tenantId: this.tenantId,
+        graphCount: this.graphs.length
+      },
+      "Project created"
+    );
+  }
+  /**
+   * Set or update the configuration (tenantId and apiUrl)
+   * This is used by the CLI to inject configuration from inkeep.config.ts
+   */
+  setConfig(tenantId, apiUrl) {
+    if (this.initialized) {
+      throw new Error("Cannot set config after project has been initialized");
+    }
+    this.tenantId = tenantId;
+    this.baseURL = apiUrl;
+    for (const graph of this.graphs) {
+      graph.setConfig(tenantId, this.projectId, apiUrl);
+    }
+    logger9.info(
+      {
+        projectId: this.projectId,
+        tenantId: this.tenantId,
+        apiUrl: this.baseURL
+      },
+      "Project configuration updated"
+    );
+  }
+  /**
+   * Initialize the project and create/update it in the backend using full project approach
+   */
+  async init() {
+    if (this.initialized) {
+      logger9.info({ projectId: this.projectId }, "Project already initialized");
+      return;
+    }
+    logger9.info(
+      {
+        projectId: this.projectId,
+        tenantId: this.tenantId,
+        graphCount: this.graphs.length
+      },
+      "Initializing project using full project endpoint"
+    );
+    try {
+      const initPromises = this.graphs.map(async (graph) => {
+        try {
+          await graph.init();
+          logger9.debug(
+            {
+              projectId: this.projectId,
+              graphId: graph.getId()
+            },
+            "Graph initialized in project"
+          );
+        } catch (error) {
+          logger9.error(
+            {
+              projectId: this.projectId,
+              graphId: graph.getId(),
+              error: error instanceof Error ? error.message : "Unknown error"
+            },
+            "Failed to initialize graph in project"
+          );
+          throw error;
+        }
+      });
+      await Promise.all(initPromises);
+      const projectDefinition = await this.toFullProjectDefinition();
+      logger9.info(
+        {
+          projectId: this.projectId,
+          mode: "api-client",
+          apiUrl: this.baseURL
+        },
+        "Using API client to create/update full project"
+      );
+      const createdProject = await updateFullProjectViaAPI(
+        this.tenantId,
+        this.baseURL,
+        this.projectId,
+        projectDefinition
+      );
+      this.initialized = true;
+      logger9.info(
+        {
+          projectId: this.projectId,
+          tenantId: this.tenantId,
+          graphCount: Object.keys(createdProject.graphs || {}).length
+        },
+        "Project initialized successfully using full project endpoint"
+      );
+    } catch (error) {
+      logger9.error(
+        {
+          projectId: this.projectId,
+          error: error instanceof Error ? error.message : "Unknown error"
+        },
+        "Failed to initialize project using full project endpoint"
+      );
+      throw error;
+    }
+  }
+  /**
+   * Get the project ID
+   */
+  getId() {
+    return this.projectId;
+  }
+  /**
+   * Get the project name
+   */
+  getName() {
+    return this.projectName;
+  }
+  /**
+   * Get the project description
+   */
+  getDescription() {
+    return this.projectDescription;
+  }
+  /**
+   * Get the tenant ID
+   */
+  getTenantId() {
+    return this.tenantId;
+  }
+  /**
+   * Get the project's model configuration
+   */
+  getModels() {
+    return this.models;
+  }
+  /**
+   * Set the project's model configuration
+   */
+  setModels(models) {
+    this.models = models;
+  }
+  /**
+   * Get the project's stopWhen configuration
+   */
+  getStopWhen() {
+    return this.stopWhen;
+  }
+  /**
+   * Set the project's stopWhen configuration
+   */
+  setStopWhen(stopWhen) {
+    this.stopWhen = stopWhen;
+  }
+  /**
+   * Get all graphs in the project
+   */
+  getGraphs() {
+    return this.graphs;
+  }
+  /**
+   * Get a graph by ID
+   */
+  getGraph(id) {
+    return this.graphMap.get(id);
+  }
+  /**
+   * Add a graph to the project
+   */
+  addGraph(graph) {
+    this.graphs.push(graph);
+    this.graphMap.set(graph.getId(), graph);
+    graph.setConfig(this.tenantId, this.projectId, this.baseURL);
+    logger9.info(
+      {
+        projectId: this.projectId,
+        graphId: graph.getId()
+      },
+      "Graph added to project"
+    );
+  }
+  /**
+   * Remove a graph from the project
+   */
+  removeGraph(id) {
+    const graphToRemove = this.graphMap.get(id);
+    if (graphToRemove) {
+      this.graphMap.delete(id);
+      this.graphs = this.graphs.filter((graph) => graph.getId() !== id);
+      logger9.info(
+        {
+          projectId: this.projectId,
+          graphId: id
+        },
+        "Graph removed from project"
+      );
+      return true;
+    }
+    return false;
+  }
+  /**
+   * Get project statistics
+   */
+  getStats() {
+    return {
+      projectId: this.projectId,
+      tenantId: this.tenantId,
+      graphCount: this.graphs.length,
+      initialized: this.initialized
+    };
+  }
+  /**
+   * Validate the project configuration
+   */
+  validate() {
+    const errors = [];
+    if (!this.projectId) {
+      errors.push("Project must have an ID");
+    }
+    if (!this.projectName) {
+      errors.push("Project must have a name");
+    }
+    const graphIds = /* @__PURE__ */ new Set();
+    for (const graph of this.graphs) {
+      const id = graph.getId();
+      if (graphIds.has(id)) {
+        errors.push(`Duplicate graph ID: ${id}`);
+      }
+      graphIds.add(id);
+    }
+    for (const graph of this.graphs) {
+      const graphValidation = graph.validate();
+      if (!graphValidation.valid) {
+        errors.push(...graphValidation.errors.map((error) => `Graph '${graph.getId()}': ${error}`));
+      }
+    }
+    return {
+      valid: errors.length === 0,
+      errors
+    };
+  }
+  /**
+   * Convert the Project to FullProjectDefinition format
+   */
+  async toFullProjectDefinition() {
+    const graphsObject = {};
+    for (const graph of this.graphs) {
+      const graphDefinition = await graph.toFullGraphDefinition();
+      graphsObject[graph.getId()] = graphDefinition;
+    }
+    return {
+      id: this.projectId,
+      name: this.projectName,
+      description: this.projectDescription || "",
+      models: this.models,
+      stopWhen: this.stopWhen,
+      graphs: graphsObject,
+      tools: {},
+      // Empty tools object as SDK doesn't manage tools directly yet
+      credentialReferences: void 0,
+      // Projects don't directly hold credentials yet
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  /**
+   * Convert project configuration to API format
+   */
+  toApiFormat() {
+    return {
+      id: this.projectId,
+      name: this.projectName,
+      description: this.projectDescription || "",
+      models: this.models,
+      stopWhen: this.stopWhen
+    };
+  }
+};
 
 // src/utils/generateIdFromName.ts
 function generateIdFromName3(name) {
@@ -2527,6 +2994,9 @@ function generateIdFromName3(name) {
 function agentGraph(config) {
   return new AgentGraph(config);
 }
+function project(config) {
+  return new Project(config);
+}
 function agent(config) {
   if (!config.id) {
     throw new Error(
@@ -2626,9 +3096,7 @@ function createEnvironmentSettings(environments) {
       }
       const credential2 = env.credentials?.[key];
       if (!credential2) {
-        throw new Error(
-          `Credential '${String(key)}' not found in environment '${currentEnv}'`
-        );
+        throw new Error(`Credential '${String(key)}' not found in environment '${currentEnv}'`);
       }
       return credential2;
     }
@@ -2657,7 +3125,7 @@ var MaxTurnsExceededError = class extends AgentError {
 };
 
 // src/runner.ts
-var logger8 = agentsCore.getLogger("runner");
+var logger10 = agentsCore.getLogger("runner");
 var Runner = class _Runner {
   /**
    * Run a graph until completion, handling transfers and tool calls
@@ -2669,7 +3137,7 @@ var Runner = class _Runner {
     let turnCount = 0;
     const messageHistory = _Runner.normalizeToMessageHistory(messages);
     const allToolCalls = [];
-    logger8.info(
+    logger10.info(
       {
         graphId: graph.getId(),
         defaultAgent: graph.getDefaultAgent()?.getName(),
@@ -2679,7 +3147,7 @@ var Runner = class _Runner {
       "Starting graph run"
     );
     while (turnCount < maxTurns) {
-      logger8.debug(
+      logger10.debug(
         {
           graphId: graph.getId(),
           turnCount,
@@ -2689,7 +3157,7 @@ var Runner = class _Runner {
       );
       const response = await graph.generate(messageHistory, options);
       turnCount++;
-      logger8.info(
+      logger10.info(
         {
           graphId: graph.getId(),
           turnCount,
@@ -2709,7 +3177,7 @@ var Runner = class _Runner {
         }
       };
     }
-    logger8.error(
+    logger10.error(
       {
         graphId: graph.getId(),
         maxTurns,
@@ -2723,7 +3191,7 @@ var Runner = class _Runner {
    * Stream a graph's response
    */
   static async stream(graph, messages, options) {
-    logger8.info(
+    logger10.info(
       {
         graphId: graph.getId(),
         defaultAgent: graph.getDefaultAgent()?.getName()
@@ -2739,7 +3207,7 @@ var Runner = class _Runner {
     if (graphs.length === 0) {
       throw new Error("No graphs provided for race");
     }
-    logger8.info(
+    logger10.info(
       {
         graphCount: graphs.length,
         graphIds: graphs.map((g) => g.getId())
@@ -2751,7 +3219,7 @@ var Runner = class _Runner {
         const result2 = await _Runner.run(graph, messages, options);
         return { ...result2, raceIndex: index };
       } catch (error) {
-        logger8.error(
+        logger10.error(
           {
             graphId: graph.getId(),
             error: error instanceof Error ? error.message : "Unknown error"
@@ -2762,7 +3230,7 @@ var Runner = class _Runner {
       }
     });
     const result = await Promise.race(promises);
-    logger8.info(
+    logger10.info(
       {
         winningGraphId: result.graphId || "unknown",
         raceIndex: result.raceIndex
@@ -2824,10 +3292,7 @@ var Runner = class _Runner {
     const defaultAgent = graph.getDefaultAgent();
     const messageCount = Array.isArray(messages) ? messages.length : 1;
     return {
-      estimatedTurns: Math.min(
-        Math.max(messageCount, 1),
-        options?.maxTurns || 10
-      ),
+      estimatedTurns: Math.min(Math.max(messageCount, 1), options?.maxTurns || 10),
       estimatedTokens: messageCount * 100,
       // Rough estimate
       agentCount: agents.length,
@@ -2843,6 +3308,7 @@ exports.Agent = Agent;
 exports.ArtifactComponent = ArtifactComponent;
 exports.DataComponent = DataComponent;
 exports.ExternalAgent = ExternalAgent;
+exports.Project = Project;
 exports.Runner = Runner;
 exports.Tool = Tool;
 exports.agent = agent;
@@ -2850,14 +3316,19 @@ exports.agentGraph = agentGraph;
 exports.agentMcp = agentMcp;
 exports.artifactComponent = artifactComponent;
 exports.createEnvironmentSettings = createEnvironmentSettings;
+exports.createFullProjectViaAPI = createFullProjectViaAPI;
 exports.credential = credential;
 exports.dataComponent = dataComponent;
+exports.deleteFullProjectViaAPI = deleteFullProjectViaAPI;
 exports.externalAgent = externalAgent;
 exports.externalAgents = externalAgents;
+exports.getFullProjectViaAPI = getFullProjectViaAPI;
 exports.mcpServer = mcpServer;
 exports.mcpTool = mcpTool;
+exports.project = project;
 exports.raceGraphs = raceGraphs;
 exports.registerEnvironmentSettings = registerEnvironmentSettings;
 exports.run = run;
 exports.stream = stream;
 exports.transfer = transfer;
+exports.updateFullProjectViaAPI = updateFullProjectViaAPI;