@inkeep/agents-sdk 0.0.0-chat-to-edit-20251119071712

package/dist/index.js

@@ -0,0 +1,4970 @@
+import { getLogger, normalizeToolSelections, apiFetch, CredentialReferenceApiInsertSchema, MCPToolConfigSchema } from '@inkeep/agents-core';
+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';
+import * as lockfile from '@yarnpkg/lockfile';
+import * as yaml from 'js-yaml';
+import ts from 'typescript';
+import { z } from 'zod';
+
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+// src/utils/generateIdFromName.ts
+function generateIdFromName(name) {
+  return name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+}
+
+// src/artifact-component.ts
+var logger = getLogger("artifactComponent");
+var ArtifactComponent = class {
+  constructor(config) {
+    __publicField(this, "config");
+    __publicField(this, "baseURL");
+    __publicField(this, "tenantId");
+    __publicField(this, "projectId");
+    __publicField(this, "initialized", false);
+    __publicField(this, "id");
+    this.id = 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,
+      props: processedProps
+    };
+    this.baseURL = process.env.INKEEP_API_URL || "http://localhost:3002";
+    this.tenantId = "default";
+    this.projectId = "default";
+    logger.info(
+      {
+        artifactComponentId: this.getId(),
+        artifactComponentName: config.name
+      },
+      "ArtifactComponent constructor initialized"
+    );
+  }
+  // Set context (tenantId, projectId, and baseURL) from external source (agent, agent, CLI, etc)
+  setContext(tenantId, projectId, baseURL) {
+    this.tenantId = tenantId;
+    this.projectId = projectId;
+    if (baseURL) {
+      this.baseURL = baseURL;
+    }
+  }
+  // Compute ID from name using same slug transformation as agents
+  getId() {
+    return this.id;
+  }
+  getName() {
+    return this.config.name;
+  }
+  getDescription() {
+    return this.config.description;
+  }
+  getProps() {
+    return this.config.props;
+  }
+  // Public method to ensure artifact component exists in backend (with upsert behavior)
+  async init() {
+    if (this.initialized) return;
+    try {
+      await this.upsertArtifactComponent();
+      logger.info(
+        {
+          artifactComponentId: this.getId()
+        },
+        "ArtifactComponent initialized successfully"
+      );
+      this.initialized = true;
+    } catch (error) {
+      logger.error(
+        {
+          artifactComponentId: this.getId(),
+          error: error instanceof Error ? error.message : "Unknown error"
+        },
+        "Failed to initialize artifact component"
+      );
+      throw error;
+    }
+  }
+  // Private method to upsert artifact component (create or update)
+  async upsertArtifactComponent() {
+    const artifactComponentData = {
+      id: this.getId(),
+      name: this.config.name,
+      description: this.config.description,
+      props: this.config.props
+    };
+    logger.info({ artifactComponentData }, "artifactComponentData for create/update");
+    const updateResponse = await fetch(
+      `${this.baseURL}/tenants/${this.tenantId}/projects/${this.projectId}/artifact-components/${this.getId()}`,
+      {
+        method: "PUT",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify(artifactComponentData)
+      }
+    );
+    logger.info(
+      {
+        status: updateResponse.status,
+        artifactComponentId: this.getId()
+      },
+      "artifact component updateResponse"
+    );
+    if (updateResponse.ok) {
+      logger.info(
+        {
+          artifactComponentId: this.getId()
+        },
+        "ArtifactComponent updated successfully"
+      );
+      return;
+    }
+    if (updateResponse.status === 404) {
+      logger.info(
+        {
+          artifactComponentId: this.getId()
+        },
+        "ArtifactComponent not found, creating new artifact component"
+      );
+      const createResponse = await fetch(
+        `${this.baseURL}/tenants/${this.tenantId}/projects/${this.projectId}/artifact-components`,
+        {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json"
+          },
+          body: JSON.stringify(artifactComponentData)
+        }
+      );
+      if (!createResponse.ok) {
+        const errorText2 = await createResponse.text().catch(() => "Unknown error");
+        throw new Error(
+          `Failed to create artifact component: ${createResponse.status} ${createResponse.statusText} - ${errorText2}`
+        );
+      }
+      logger.info(
+        {
+          artifactComponentId: this.getId()
+        },
+        "ArtifactComponent created successfully"
+      );
+      return;
+    }
+    const errorText = await updateResponse.text().catch(() => "Unknown error");
+    throw new Error(
+      `Failed to update artifact component: ${updateResponse.status} ${updateResponse.statusText} - ${errorText}`
+    );
+  }
+};
+var logger2 = getLogger("projectFullClient");
+async function createFullProjectViaAPI(tenantId, apiUrl, projectData, apiKey) {
+  logger2.info(
+    {
+      tenantId,
+      projectId: projectData.id,
+      apiUrl
+    },
+    "Creating full project via API"
+  );
+  const url = `${apiUrl}/tenants/${tenantId}/project-full`;
+  const headers = {};
+  if (apiKey) {
+    headers.Authorization = `Bearer ${apiKey}`;
+  }
+  let response;
+  try {
+    response = await apiFetch(url, {
+      method: "POST",
+      headers,
+      body: JSON.stringify(projectData)
+    });
+  } catch (fetchError) {
+    logger2.error(
+      {
+        error: fetchError instanceof Error ? fetchError.message : "Unknown fetch error",
+        url,
+        tenantId,
+        projectId: projectData.id
+      },
+      "Fetch request failed"
+    );
+    throw fetchError;
+  }
+  if (!response.ok) {
+    const errorText = await response.text();
+    const errorMessage = parseError(errorText) ?? `Failed to create project: ${response.status} ${response.statusText}`;
+    logger2.error(
+      {
+        status: response.status,
+        error: errorMessage
+      },
+      "Failed to create project via API"
+    );
+    throw new Error(errorMessage);
+  }
+  const result = await response.json();
+  logger2.info(
+    {
+      projectId: projectData.id
+    },
+    "Successfully created project via API"
+  );
+  return result.data;
+}
+async function updateFullProjectViaAPI(tenantId, apiUrl, projectId, projectData, apiKey) {
+  logger2.info(
+    {
+      tenantId,
+      projectId,
+      apiUrl
+    },
+    "Updating full project via API"
+  );
+  const url = `${apiUrl}/tenants/${tenantId}/project-full/${projectId}`;
+  const headers = {};
+  if (apiKey) {
+    headers.Authorization = `Bearer ${apiKey}`;
+  }
+  let response;
+  try {
+    response = await apiFetch(url, {
+      method: "PUT",
+      headers,
+      body: JSON.stringify(projectData)
+    });
+  } catch (fetchError) {
+    logger2.error(
+      {
+        error: fetchError instanceof Error ? fetchError.message : "Unknown fetch error",
+        url,
+        tenantId,
+        projectId
+      },
+      "Fetch request failed"
+    );
+    throw fetchError;
+  }
+  if (!response.ok) {
+    const errorText = await response.text();
+    const errorMessage = parseError(errorText) ?? `Failed to update project: ${response.status} ${response.statusText}`;
+    logger2.error(
+      {
+        status: response.status,
+        error: errorMessage
+      },
+      "Failed to update project via API"
+    );
+    throw new Error(errorMessage);
+  }
+  const result = await response.json();
+  logger2.info(
+    {
+      projectId
+    },
+    "Successfully updated project via API"
+  );
+  return result.data;
+}
+async function getFullProjectViaAPI(tenantId, apiUrl, projectId, apiKey) {
+  logger2.info(
+    {
+      tenantId,
+      projectId,
+      apiUrl
+    },
+    "Getting full project via API"
+  );
+  const url = `${apiUrl}/tenants/${tenantId}/project-full/${projectId}`;
+  const headers = {};
+  if (apiKey) {
+    headers.Authorization = `Bearer ${apiKey}`;
+  }
+  const response = await apiFetch(url, {
+    method: "GET",
+    headers
+  });
+  if (!response.ok) {
+    if (response.status === 404) {
+      logger2.info(
+        {
+          projectId
+        },
+        "Project not found"
+      );
+      return null;
+    }
+    const errorText = await response.text();
+    const errorMessage = parseError(errorText) ?? `Failed to get project: ${response.status} ${response.statusText}`;
+    logger2.error(
+      {
+        status: response.status,
+        error: errorMessage
+      },
+      "Failed to get project via API"
+    );
+    throw new Error(errorMessage);
+  }
+  const result = await response.json();
+  logger2.info(
+    {
+      projectId
+    },
+    "Successfully retrieved project via API"
+  );
+  return result.data;
+}
+async function deleteFullProjectViaAPI(tenantId, apiUrl, projectId, apiKey) {
+  logger2.info(
+    {
+      tenantId,
+      projectId,
+      apiUrl
+    },
+    "Deleting full project via API"
+  );
+  const url = `${apiUrl}/tenants/${tenantId}/project-full/${projectId}`;
+  const headers = {};
+  if (apiKey) {
+    headers.Authorization = `Bearer ${apiKey}`;
+  }
+  const response = await apiFetch(url, {
+    method: "DELETE",
+    headers
+  });
+  if (!response.ok) {
+    const errorText = await response.text();
+    const errorMessage = parseError(errorText) ?? `Failed to delete project: ${response.status} ${response.statusText}`;
+    logger2.error(
+      {
+        status: response.status,
+        error: errorMessage
+      },
+      "Failed to delete project via API"
+    );
+    throw new Error(errorMessage);
+  }
+  logger2.info(
+    {
+      projectId
+    },
+    "Successfully deleted project via API"
+  );
+}
+function parseError(errorText) {
+  try {
+    const errorJson = JSON.parse(errorText);
+    if (errorJson.error) {
+      const { error } = errorJson;
+      return error?.message ?? error;
+    }
+  } catch {
+    if (errorText) {
+      return errorText;
+    }
+  }
+}
+
+// src/agentFullClient.ts
+var logger3 = getLogger("agentFullClient");
+async function updateFullAgentViaAPI(tenantId, projectId, apiUrl, agentId, agentData) {
+  logger3.info(
+    {
+      tenantId,
+      projectId,
+      agentId,
+      apiUrl
+    },
+    "Updating full agent via API"
+  );
+  const url = `${apiUrl}/tenants/${tenantId}/projects/${projectId}/agent/${agentId}`;
+  const response = await fetch(url, {
+    method: "PUT",
+    headers: {
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify(agentData)
+  });
+  if (!response.ok) {
+    const errorText = await response.text();
+    const errorMessage = parseError(errorText) ?? `Failed to update agent: ${response.status} ${response.statusText}`;
+    logger3.error(
+      {
+        status: response.status,
+        error: errorMessage
+      },
+      "Failed to update agent via API"
+    );
+    throw new Error(errorMessage);
+  }
+  const result = await response.json();
+  logger3.info(
+    {
+      agentId
+    },
+    "Successfully updated agent via API"
+  );
+  return result.data;
+}
+var logger4 = getLogger("function-tool");
+var getFunctionToolDeps = (name, code) => {
+  const { dependencies, warnings } = buildToolManifestFromCodeTS(code);
+  if (warnings.length > 0) {
+    logger4.warn({ warnings }, `FunctionTool dependencies warnings for ${name}`);
+  }
+  return dependencies;
+};
+var NODE_BUILTINS = new Set(builtinModules.concat(builtinModules.map((m) => `node:${m}`)));
+var isExternal = (spec) => !spec.startsWith(".") && !spec.startsWith("/") && !NODE_BUILTINS.has(spec);
+var collapseSubpath = (spec) => {
+  if (spec.startsWith("@")) {
+    const [scope, name] = spec.split("/");
+    return `${scope}/${name ?? ""}`;
+  }
+  return spec.split("/")[0];
+};
+var readJSON = (p) => JSON.parse(fs.readFileSync(p, "utf8"));
+var findUp = (start, file) => {
+  let dir = path.resolve(start);
+  if (fs.existsSync(dir) && fs.statSync(dir).isFile()) dir = path.dirname(dir);
+  for (; ; ) {
+    const candidate = path.join(dir, file);
+    if (fs.existsSync(candidate)) return candidate;
+    const parent = path.dirname(dir);
+    if (parent === dir) return null;
+    dir = parent;
+  }
+};
+function collectDepsFromCodeTS(code) {
+  const info = ts.preProcessFile(
+    code,
+    /*readImportFiles*/
+    true,
+    /*detectJavaScriptImports*/
+    true
+  );
+  const add = /* @__PURE__ */ new Set();
+  const push = (spec) => {
+    if (isExternal(spec)) add.add(collapseSubpath(spec));
+  };
+  for (const f of info.importedFiles) {
+    const spec = f.fileName;
+    if (spec) push(spec);
+  }
+  const requireLike = /(?:require|import)\s*\(\s*(['"])([^'"]+)\1\s*\)/g;
+  let m;
+  while (m = requireLike.exec(code)) push(m[2]);
+  return add;
+}
+function resolveInstalledVersion(pkg, projectRoot) {
+  const pnpmLock = findUp(projectRoot, "pnpm-lock.yaml");
+  if (pnpmLock) {
+    const doc = yaml.load(fs.readFileSync(pnpmLock, "utf8"));
+    const pkgs = doc?.packages ?? {};
+    for (const key of Object.keys(pkgs)) {
+      if (key.startsWith(`${pkg}@`)) {
+        const ver = key.slice(key.indexOf("@") + 1);
+        if (ver) return { exact: String(ver) };
+      }
+    }
+  }
+  const npmLock = findUp(projectRoot, "package-lock.json");
+  if (npmLock) {
+    const lock = readJSON(npmLock);
+    if (lock.packages?.[`node_modules/${pkg}`]?.version) {
+      return { exact: String(lock.packages[`node_modules/${pkg}`].version) };
+    }
+    if (lock.dependencies?.[pkg]?.version) {
+      return { exact: String(lock.dependencies[pkg].version) };
+    }
+  }
+  const yarnLock = findUp(projectRoot, "yarn.lock");
+  if (yarnLock) {
+    const parsed = lockfile.parse(fs.readFileSync(yarnLock, "utf8"));
+    if (parsed.type === "success") {
+      for (const [key, val] of Object.entries(parsed.object)) {
+        if (key === pkg || key.startsWith(`${pkg}@`)) {
+          const ver = val.version;
+          if (ver) return { exact: String(ver) };
+        }
+      }
+    }
+  }
+  const host = {
+    fileExists: fs.existsSync,
+    readFile: (p) => fs.readFileSync(p, "utf8"),
+    realpath: (p) => fs.realpathSync.native?.(p) ?? fs.realpathSync(p),
+    directoryExists: (d) => {
+      try {
+        return fs.statSync(d).isDirectory();
+      } catch {
+        return false;
+      }
+    },
+    getCurrentDirectory: () => projectRoot,
+    getDirectories: (d) => fs.readdirSync(d, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name)
+  };
+  const res = ts.resolveModuleName(
+    `${pkg}/package.json`,
+    path.join(projectRoot, "__fake.ts"),
+    {},
+    host,
+    ts.ModuleKind.NodeNext
+  );
+  const pkgJsonPath = res?.resolvedModule?.resolvedFileName ?? // Try typical path as fallback
+  findUp(path.join(projectRoot, "node_modules", pkg), "package.json");
+  if (pkgJsonPath && fs.existsSync(pkgJsonPath)) {
+    try {
+      const version = readJSON(pkgJsonPath).version;
+      if (version) return { exact: String(version) };
+    } catch {
+    }
+  }
+  const hostPkg = findUp(projectRoot, "package.json");
+  if (hostPkg) {
+    const hostJson = readJSON(hostPkg);
+    const range = hostJson.dependencies?.[pkg] ?? hostJson.devDependencies?.[pkg] ?? hostJson.optionalDependencies?.[pkg];
+    if (range) return { range: String(range), unresolved: true };
+  }
+  return null;
+}
+function buildToolManifestFromCodeTS(code, projectRoot = process.cwd()) {
+  const deps = collectDepsFromCodeTS(code);
+  const warnings = [];
+  const dependencies = {};
+  for (const pkg of deps) {
+    try {
+      const v = resolveInstalledVersion(pkg, projectRoot);
+      if (!v) {
+        warnings.push(`Could not resolve version for "${pkg}"`);
+        continue;
+      }
+      if ("unresolved" in v) {
+        warnings.push(`Using range for "${pkg}" -> ${v.range} (no lockfile / not installed)`);
+        dependencies[pkg] = v.range;
+      } else {
+        dependencies[pkg] = v.exact;
+      }
+    } catch {
+      dependencies[pkg] = false;
+    }
+  }
+  return { dependencies, warnings };
+}
+
+// src/function-tool.ts
+var logger5 = getLogger("function-tool");
+var FunctionTool = class {
+  constructor(config) {
+    __publicField(this, "config");
+    __publicField(this, "id");
+    this.config = config;
+    this.id = generateIdFromName(config.name);
+    if (!config.dependencies) {
+      const executeCode = typeof config.execute === "string" ? config.execute : config.execute.toString();
+      const deps = getFunctionToolDeps(config.name, executeCode);
+      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.`
+          );
+        }
+      }
+      this.config.dependencies = deps;
+    }
+    logger5.info(
+      {
+        id: this.id,
+        name: config.name
+      },
+      "FunctionTool constructor initialized"
+    );
+  }
+  getId() {
+    return this.id;
+  }
+  getName() {
+    return this.config.name;
+  }
+  getDescription() {
+    return this.config.description;
+  }
+  getInputSchema() {
+    return this.config.inputSchema;
+  }
+  getDependencies() {
+    return this.config.dependencies || {};
+  }
+  getExecuteFunction() {
+    if (typeof this.config.execute === "string") {
+      throw new Error(
+        "Cannot get execute function from string-based function tool. Use serializeFunction() instead."
+      );
+    }
+    return this.config.execute;
+  }
+  // Serialize the function (global entity) for storage
+  serializeFunction() {
+    const executeCode = typeof this.config.execute === "string" ? this.config.execute : this.config.execute.toString();
+    return {
+      id: this.id,
+      inputSchema: this.config.inputSchema,
+      executeCode,
+      dependencies: this.config.dependencies || {}
+    };
+  }
+  // Serialize the tool (project-scoped) for storage
+  serializeTool() {
+    return {
+      id: this.id,
+      name: this.config.name,
+      description: this.config.description,
+      functionId: this.id
+      // The function ID is the same as the tool ID in this context
+    };
+  }
+};
+
+// src/agent.ts
+var logger6 = getLogger("agent");
+function resolveGetter(value) {
+  if (typeof value === "function") {
+    return value();
+  }
+  return value;
+}
+var Agent = class {
+  constructor(config) {
+    __publicField(this, "subAgents", []);
+    __publicField(this, "agentMap", /* @__PURE__ */ new Map());
+    __publicField(this, "defaultSubAgent");
+    __publicField(this, "baseURL");
+    __publicField(this, "tenantId");
+    __publicField(this, "projectId");
+    __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, "prompt");
+    __publicField(this, "stopWhen");
+    this.defaultSubAgent = config.defaultSubAgent;
+    this.tenantId = "default";
+    this.projectId = "default";
+    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 = resolveGetter(config.credentials);
+    this.models = config.models;
+    this.statusUpdateSettings = config.statusUpdates;
+    this.prompt = config.prompt;
+    this.stopWhen = config.stopWhen ? {
+      transferCountIs: config.stopWhen.transferCountIs
+    } : void 0;
+    this.subAgents = resolveGetter(config.subAgents) || [];
+    this.agentMap = new Map(this.subAgents.map((agent2) => [agent2.getId(), agent2]));
+    if (this.defaultSubAgent) {
+      const isAlreadyPresent = this.subAgents.some(
+        (agent2) => agent2.getId() === this.defaultSubAgent?.getId()
+      );
+      if (!isAlreadyPresent) {
+        this.subAgents.push(this.defaultSubAgent);
+      }
+      this.agentMap.set(this.defaultSubAgent.getId(), this.defaultSubAgent);
+    }
+    if (this.models) {
+      this.propagateImmediateModelSettings();
+    }
+    logger6.info(
+      {
+        agentId: this.agentId,
+        tenantId: this.tenantId,
+        agentCount: this.subAgents.length,
+        defaultSubAgent: this.defaultSubAgent?.getName()
+      },
+      "Agent created"
+    );
+  }
+  /**
+   * Set or update the configuration (tenantId, projectId and apiUrl)
+   * This is used by the CLI to inject configuration from inkeep.config.ts
+   */
+  setConfig(tenantId, projectId, apiUrl) {
+    if (this.initialized) {
+      throw new Error("Cannot set config after agent has been initialized");
+    }
+    this.tenantId = tenantId;
+    this.projectId = projectId;
+    this.baseURL = apiUrl;
+    for (const subAgent2 of this.subAgents) {
+      if (subAgent2.setContext) {
+        subAgent2.setContext(tenantId, projectId, apiUrl);
+      }
+      const tools = subAgent2.getTools();
+      for (const [_, toolInstance] of Object.entries(tools)) {
+        if (toolInstance && typeof toolInstance === "object") {
+          if ("setContext" in toolInstance && typeof toolInstance.setContext === "function") {
+            toolInstance.setContext(tenantId, projectId, apiUrl);
+          }
+        }
+      }
+    }
+    if (this.contextConfig?.setContext) {
+      this.contextConfig.setContext(tenantId, projectId, this.agentId, this.baseURL);
+    }
+    logger6.info(
+      {
+        agentId: this.agentId,
+        tenantId: this.tenantId,
+        projectId: this.projectId,
+        apiUrl: this.baseURL
+      },
+      "Agent configuration updated"
+    );
+  }
+  /**
+   * Convert the Agent to FullAgentDefinition format for the new agent endpoint
+   */
+  async toFullAgentDefinition() {
+    const subAgentsObject = {};
+    const externalAgentsObject = {};
+    const functionToolsObject = {};
+    const functionsObject = {};
+    for (const subAgent2 of this.subAgents) {
+      const transfers = subAgent2.getTransfers();
+      const delegates = subAgent2.getDelegates();
+      const tools = [];
+      const selectedToolsMapping = {};
+      const headersMapping = {};
+      const toolPoliciesMapping = {};
+      const subAgentTools = subAgent2.getTools();
+      for (const [_toolName, toolInstance] of Object.entries(subAgentTools)) {
+        const toolId = toolInstance.getId();
+        if (toolInstance.selectedTools) {
+          selectedToolsMapping[toolId] = toolInstance.selectedTools;
+        }
+        if (toolInstance.headers) {
+          headersMapping[toolId] = toolInstance.headers;
+        }
+        if (toolInstance.toolPolicies) {
+          toolPoliciesMapping[toolId] = toolInstance.toolPolicies;
+        }
+        tools.push(toolId);
+        if (toolInstance.constructor.name === "FunctionTool" && toolInstance instanceof FunctionTool) {
+          if (!functionsObject[toolId]) {
+            const functionData = toolInstance.serializeFunction();
+            functionsObject[toolId] = functionData;
+          }
+          if (!functionToolsObject[toolId]) {
+            const toolData = toolInstance.serializeTool();
+            functionToolsObject[toolId] = {
+              id: toolData.id,
+              name: toolData.name,
+              description: toolData.description,
+              functionId: toolData.functionId,
+              agentId: this.agentId
+              // Include agentId for agent-scoped function tools
+            };
+          }
+        }
+      }
+      const subAgentExternalAgents = subAgent2.getExternalAgentDelegates();
+      for (const externalAgentDelegate of subAgentExternalAgents) {
+        const externalAgent2 = externalAgentDelegate.externalAgent;
+        externalAgentsObject[externalAgent2.getId()] = {
+          id: externalAgent2.getId(),
+          name: externalAgent2.getName(),
+          description: externalAgent2.getDescription(),
+          baseUrl: externalAgent2.getBaseUrl(),
+          credentialReferenceId: externalAgent2.getCredentialReferenceId(),
+          type: "external"
+        };
+      }
+      const dataComponents = [];
+      const subAgentDataComponents = subAgent2.getDataComponents();
+      if (subAgentDataComponents) {
+        for (const dataComponent2 of subAgentDataComponents) {
+          const dataComponentId = dataComponent2.id || dataComponent2.name.toLowerCase().replace(/\s+/g, "-");
+          dataComponents.push(dataComponentId);
+        }
+      }
+      const artifactComponents = [];
+      const subAgentArtifactComponents = subAgent2.getArtifactComponents();
+      if (subAgentArtifactComponents) {
+        for (const artifactComponent2 of subAgentArtifactComponents) {
+          const artifactComponentId = artifactComponent2.id || artifactComponent2.name.toLowerCase().replace(/\s+/g, "-");
+          artifactComponents.push(artifactComponentId);
+        }
+      }
+      const canUse = tools.map((toolId) => ({
+        toolId,
+        toolSelection: selectedToolsMapping[toolId] || null,
+        headers: headersMapping[toolId] || null,
+        toolPolicies: toolPoliciesMapping[toolId] || null
+      }));
+      subAgentsObject[subAgent2.getId()] = {
+        id: subAgent2.getId(),
+        name: subAgent2.getName(),
+        description: subAgent2.config.description || `Agent ${subAgent2.getName()}`,
+        prompt: subAgent2.getInstructions(),
+        models: subAgent2.config.models,
+        stopWhen: subAgent2.config.stopWhen,
+        canTransferTo: transfers.map((h) => h.getId()),
+        canDelegateTo: delegates.map((d) => {
+          if (typeof d === "object" && "externalAgent" in d) {
+            return {
+              externalAgentId: d.externalAgent.getId(),
+              ...d.headers && { headers: d.headers }
+            };
+          }
+          if (typeof d === "object" && "agent" in d) {
+            return {
+              agentId: d.agent.getId(),
+              ...d.headers && { headers: d.headers }
+            };
+          }
+          return d.getId();
+        }),
+        canUse,
+        dataComponents: dataComponents.length > 0 ? dataComponents : void 0,
+        artifactComponents: artifactComponents.length > 0 ? artifactComponents : void 0,
+        type: "internal"
+      };
+    }
+    const processedStatusUpdates = this.statusUpdateSettings ? {
+      ...this.statusUpdateSettings,
+      statusComponents: this.statusUpdateSettings.statusComponents?.map((comp) => {
+        if (comp && typeof comp.getType === "function") {
+          return {
+            type: comp.getType(),
+            description: comp.getDescription(),
+            detailsSchema: comp.getDetailsSchema()
+          };
+        }
+        if (comp && typeof comp === "object" && comp.detailsSchema && isZodSchema(comp.detailsSchema)) {
+          const jsonSchema = convertZodToJsonSchema(comp.detailsSchema);
+          return {
+            type: comp.type,
+            description: comp.description,
+            detailsSchema: {
+              type: "object",
+              properties: jsonSchema.properties || {},
+              required: jsonSchema.required || void 0
+            }
+          };
+        }
+        return comp;
+      })
+    } : void 0;
+    const agentToolsObject = {};
+    for (const subAgent2 of this.subAgents) {
+      const subAgentTools = subAgent2.getTools();
+      for (const [_toolName, toolInstance] of Object.entries(subAgentTools)) {
+        const toolId = toolInstance.getId();
+        if (toolInstance.constructor.name !== "FunctionTool") {
+          if (!agentToolsObject[toolId]) {
+            if ("config" in toolInstance && "serverUrl" in toolInstance.config) {
+              const mcpTool2 = toolInstance;
+              agentToolsObject[toolId] = {
+                id: toolId,
+                name: toolInstance.getName(),
+                description: null,
+                config: {
+                  type: "mcp",
+                  mcp: {
+                    server: {
+                      url: mcpTool2.config.serverUrl
+                    },
+                    transport: mcpTool2.config.transport,
+                    activeTools: mcpTool2.config.activeTools
+                  }
+                },
+                credentialReferenceId: null
+              };
+            }
+          }
+        }
+      }
+    }
+    return {
+      id: this.agentId,
+      name: this.agentName,
+      description: this.agentDescription,
+      defaultSubAgentId: this.defaultSubAgent?.getId() || "",
+      subAgents: subAgentsObject,
+      externalAgents: externalAgentsObject,
+      contextConfig: this.contextConfig?.toObject(),
+      // Include function tools at agent level
+      ...Object.keys(functionToolsObject).length > 0 && { functionTools: functionToolsObject },
+      ...Object.keys(functionsObject).length > 0 && { functions: functionsObject },
+      models: this.models,
+      stopWhen: this.stopWhen,
+      statusUpdates: processedStatusUpdates,
+      prompt: this.prompt,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  /**
+   * Initialize all tools in all agents (especially IPCTools that need MCP server URLs)
+   */
+  async initializeAllTools() {
+    logger6.info({ agentId: this.agentId }, "Initializing all tools in agent");
+    const toolInitPromises = [];
+    for (const subAgent2 of this.subAgents) {
+      const agentTools = subAgent2.getTools();
+      for (const [toolName, toolInstance] of Object.entries(agentTools)) {
+        if (toolInstance && typeof toolInstance === "object") {
+          if (typeof toolInstance.init === "function") {
+            toolInitPromises.push(
+              (async () => {
+                try {
+                  const skipDbRegistration = toolInstance.constructor.name === "IPCTool" || toolInstance.constructor.name === "HostedTool" || toolInstance.constructor.name === "Tool";
+                  if (typeof toolInstance.init === "function") {
+                    if (skipDbRegistration) {
+                      await toolInstance.init({
+                        skipDatabaseRegistration: true
+                      });
+                    } else {
+                      await toolInstance.init();
+                    }
+                  }
+                  logger6.debug(
+                    {
+                      subAgentId: subAgent2.getId(),
+                      toolName,
+                      toolType: toolInstance.constructor.name,
+                      skipDbRegistration
+                    },
+                    "Tool initialized successfully"
+                  );
+                } catch (error) {
+                  logger6.error(
+                    {
+                      subAgentId: subAgent2.getId(),
+                      toolName,
+                      error: error instanceof Error ? error.message : "Unknown error"
+                    },
+                    "Failed to initialize tool"
+                  );
+                  throw error;
+                }
+              })()
+            );
+          }
+        }
+      }
+    }
+    await Promise.all(toolInitPromises);
+    logger6.info(
+      { agentId: this.agentId, toolCount: toolInitPromises.length },
+      "All tools initialized successfully"
+    );
+  }
+  /**
+   * Initialize the agent and all agents in the backend using the new agent endpoint
+   */
+  async init() {
+    if (this.initialized) {
+      logger6.info({ agentId: this.agentId }, "Agent already initialized");
+      return;
+    }
+    logger6.info(
+      {
+        agentId: this.agentId,
+        agentCount: this.subAgents.length
+      },
+      "Initializing agent using new agent endpoint"
+    );
+    try {
+      await this.initializeAllTools();
+      await this.applyModelInheritance();
+      const agentDefinition = await this.toFullAgentDefinition();
+      logger6.info(
+        {
+          agentId: this.agentId,
+          mode: "api-client",
+          apiUrl: this.baseURL
+        },
+        "Using API client to create/update agent"
+      );
+      const createdAgent = await updateFullAgentViaAPI(
+        this.tenantId,
+        this.projectId,
+        this.baseURL,
+        this.agentId,
+        agentDefinition
+      );
+      logger6.info(
+        {
+          agentId: this.agentId,
+          agentCount: Object.keys(createdAgent.subAgents || {}).length
+        },
+        "Agent initialized successfully using agent endpoint"
+      );
+      this.initialized = true;
+    } catch (error) {
+      logger6.error(
+        {
+          agentId: this.agentId,
+          error: error instanceof Error ? error.message : "Unknown error"
+        },
+        "Failed to initialize agent using agent endpoint"
+      );
+      throw error;
+    }
+  }
+  /**
+   * Generate a response using the default agent
+   */
+  async generate(input, options) {
+    await this._init();
+    if (!this.defaultSubAgent) {
+      throw new Error("No default agent configured for this agent");
+    }
+    logger6.info(
+      {
+        agentId: this.agentId,
+        defaultSubAgent: this.defaultSubAgent.getName(),
+        conversationId: options?.conversationId
+      },
+      "Generating response with default agent"
+    );
+    const response = await this.executeWithBackend(input, options);
+    return response;
+  }
+  /**
+   * Stream a response using the default agent
+   */
+  async stream(input, options) {
+    await this._init();
+    if (!this.defaultSubAgent) {
+      throw new Error("No default agent configured for this agent");
+    }
+    logger6.info(
+      {
+        agentId: this.agentId,
+        defaultSubAgent: this.defaultSubAgent.getName(),
+        conversationId: options?.conversationId
+      },
+      "Streaming response with default agent"
+    );
+    const textStream = async function* (agent2) {
+      const response = await agent2.executeWithBackend(input, options);
+      const words = response.split(" ");
+      for (const word of words) {
+        yield `${word} `;
+      }
+    };
+    return {
+      textStream: textStream(this)
+    };
+  }
+  /**
+   * Alias for stream() method for consistency with naming patterns
+   */
+  async generateStream(input, options) {
+    return await this.stream(input, options);
+  }
+  /**
+   * Run with a specific agent from the agent
+   */
+  async runWith(subAgentId, input, options) {
+    await this._init();
+    const agent2 = this.getSubAgent(subAgentId);
+    if (!agent2) {
+      throw new Error(`Agent '${subAgentId}' not found in agent`);
+    }
+    logger6.info(
+      {
+        agentId: this.agentId,
+        subAgentId,
+        conversationId: options?.conversationId
+      },
+      "Running with specific agent"
+    );
+    const response = await this.executeWithBackend(input, options);
+    return {
+      finalOutput: response,
+      agent: agent2,
+      turnCount: 1,
+      usage: { inputTokens: 0, outputTokens: 0 },
+      metadata: {
+        toolCalls: [],
+        transfers: []
+      }
+    };
+  }
+  /**
+   * Get an agent by name (unified method for all agent types)
+   */
+  getSubAgent(name) {
+    return this.agentMap.get(name);
+  }
+  /**
+   * Add an agent to the agent
+   */
+  addSubAgent(agent2) {
+    this.subAgents.push(agent2);
+    this.agentMap.set(agent2.getId(), agent2);
+    if (this.models) {
+      this.propagateModelSettingsToAgent(agent2);
+    }
+    logger6.info(
+      {
+        agentId: this.agentId,
+        subAgentId: agent2.getId()
+      },
+      "SubAgent added to agent"
+    );
+  }
+  /**
+   * 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((agent2) => agent2.getId() !== agentToRemove.getId());
+      logger6.info(
+        {
+          agentId: this.agentId,
+          subAgentId: agentToRemove.getId()
+        },
+        "Agent removed from agent"
+      );
+      return true;
+    }
+    return false;
+  }
+  /**
+   * Get all agents in the agent
+   */
+  getSubAgents() {
+    return this.subAgents;
+  }
+  /**
+   * Get all agent ids (unified method for all agent types)
+   */
+  getSubAgentIds() {
+    return Array.from(this.agentMap.keys());
+  }
+  /**
+   * Set the default agent
+   */
+  setDefaultSubAgent(agent2) {
+    this.defaultSubAgent = agent2;
+    this.addSubAgent(agent2);
+    logger6.info(
+      {
+        agentId: this.agentId,
+        defaultSubAgent: agent2.getId()
+      },
+      "Default agent updated"
+    );
+  }
+  /**
+   * Get the default agent
+   */
+  getDefaultSubAgent() {
+    return this.defaultSubAgent;
+  }
+  /**
+   * Get the agent ID
+   */
+  getId() {
+    return this.agentId;
+  }
+  getName() {
+    return this.agentName;
+  }
+  getDescription() {
+    return this.agentDescription;
+  }
+  getTenantId() {
+    return this.tenantId;
+  }
+  /**
+   * Get the agent's model settingsuration
+   */
+  getModels() {
+    return this.models;
+  }
+  /**
+   * Set the agent's model settingsuration
+   */
+  setModels(models) {
+    this.models = models;
+  }
+  /**
+   * Get the agent's prompt configuration
+   */
+  getPrompt() {
+    return this.prompt;
+  }
+  /**
+   * Get the agent's stopWhen configuration
+   */
+  getStopWhen() {
+    return this.stopWhen || { transferCountIs: 10 };
+  }
+  /**
+   * Get the agent's status updates configuration
+   */
+  getStatusUpdateSettings() {
+    return this.statusUpdateSettings;
+  }
+  /**
+   * Get the summarizer model from the agent's model settings
+   */
+  getSummarizerModel() {
+    return this.models?.summarizer;
+  }
+  /**
+   * Get agent statistics
+   */
+  getStats() {
+    return {
+      agentCount: this.subAgents.length,
+      defaultSubAgent: this.defaultSubAgent?.getName() || null,
+      initialized: this.initialized,
+      agentId: this.agentId,
+      tenantId: this.tenantId
+    };
+  }
+  with(options) {
+    return {
+      agent: this,
+      headers: options.headers
+    };
+  }
+  /**
+   * Validate the agent configuration
+   */
+  validate() {
+    const errors = [];
+    if (this.subAgents.length === 0) {
+      errors.push("Agent must contain at least one agent");
+    }
+    if (!this.defaultSubAgent) {
+      errors.push("Agent must have a default agent");
+    }
+    const names = /* @__PURE__ */ new Set();
+    for (const subAgent2 of this.subAgents) {
+      const name = subAgent2.getName();
+      if (names.has(name)) {
+        errors.push(`Duplicate agent name: ${name}`);
+      }
+      names.add(name);
+    }
+    for (const subAgent2 of this.subAgents) {
+      const transfers = subAgent2.getTransfers();
+      for (const transferAgent of transfers) {
+        if (!this.agentMap.has(transferAgent.getName())) {
+          errors.push(
+            `Agent '${subAgent2.getName()}' has transfer to '${transferAgent.getName()}' which is not in the agent`
+          );
+        }
+      }
+      const delegates = subAgent2.getDelegates();
+      for (const delegateAgent of delegates) {
+        if (this.isInternalAgent(delegateAgent)) {
+          if (!this.agentMap.has(delegateAgent.getName())) {
+            errors.push(
+              `Agent '${subAgent2.getName()}' has delegation to '${delegateAgent.getName()}' which is not in the agent`
+            );
+          }
+        }
+      }
+    }
+    return {
+      valid: errors.length === 0,
+      errors
+    };
+  }
+  // Private helper methods
+  async _init() {
+    if (!this.initialized) {
+      await this.init();
+    }
+  }
+  /**
+   * Type guard to check if an agent is an internal AgentInterface
+   */
+  isInternalAgent(agent2) {
+    return "getTransfers" in agent2 && typeof agent2.getTransfers === "function";
+  }
+  /**
+   * Get project-level model settingsuration defaults
+   */
+  async getProjectModelDefaults() {
+    try {
+      const project2 = await getFullProjectViaAPI(this.tenantId, this.projectId, this.baseURL);
+      return project2?.models;
+    } catch (error) {
+      logger6.warn(
+        {
+          tenantId: this.tenantId,
+          projectId: this.projectId,
+          error: error instanceof Error ? error.message : "Unknown error"
+        },
+        "Failed to get project model defaults"
+      );
+      return void 0;
+    }
+  }
+  /**
+   * Get project-level stopWhen configuration defaults
+   */
+  async getProjectStopWhenDefaults() {
+    try {
+      const project2 = await getFullProjectViaAPI(this.tenantId, this.projectId, this.baseURL);
+      return project2?.stopWhen;
+    } catch (error) {
+      logger6.warn(
+        {
+          tenantId: this.tenantId,
+          projectId: this.projectId,
+          error: error instanceof Error ? error.message : "Unknown error"
+        },
+        "Failed to get project stopWhen defaults"
+      );
+      return void 0;
+    }
+  }
+  /**
+   * Apply model inheritance hierarchy: Project -> Agent -> Agent
+   */
+  async applyModelInheritance() {
+    const projectModels = await this.getProjectModelDefaults();
+    if (projectModels) {
+      if (!this.models) {
+        this.models = {};
+      }
+      if (!this.models.base && projectModels.base) {
+        this.models.base = projectModels.base;
+      }
+      if (!this.models.structuredOutput && projectModels.structuredOutput) {
+        this.models.structuredOutput = projectModels.structuredOutput;
+      }
+      if (!this.models.summarizer && projectModels.summarizer) {
+        this.models.summarizer = projectModels.summarizer;
+      }
+    }
+    await this.applyStopWhenInheritance();
+    for (const subAgent2 of this.subAgents) {
+      this.propagateModelSettingsToAgent(subAgent2);
+    }
+  }
+  /**
+   * Apply stopWhen inheritance hierarchy: Project -> Agent -> Agent
+   */
+  async applyStopWhenInheritance() {
+    const projectStopWhen = await this.getProjectStopWhenDefaults();
+    if (!this.stopWhen) {
+      this.stopWhen = {};
+    }
+    if (this.stopWhen.transferCountIs === void 0 && projectStopWhen?.transferCountIs !== void 0) {
+      this.stopWhen.transferCountIs = projectStopWhen.transferCountIs;
+    }
+    if (this.stopWhen.transferCountIs === void 0) {
+      this.stopWhen.transferCountIs = 10;
+    }
+    if (projectStopWhen?.stepCountIs !== void 0) {
+      for (const subAgent2 of this.subAgents) {
+        if (!subAgent2.config.stopWhen) {
+          subAgent2.config.stopWhen = {};
+        }
+        if (subAgent2.config.stopWhen.stepCountIs === void 0) {
+          subAgent2.config.stopWhen.stepCountIs = projectStopWhen.stepCountIs;
+        }
+      }
+    }
+    logger6.debug(
+      {
+        agentId: this.agentId,
+        agentStopWhen: this.stopWhen,
+        projectStopWhen
+      },
+      "Applied stopWhen inheritance from project to agent"
+    );
+  }
+  /**
+   * Propagate agent-level model settings to agents (supporting partial inheritance)
+   */
+  propagateModelSettingsToAgent(agent2) {
+    if (this.models) {
+      if (!agent2.config.models) {
+        agent2.config.models = {};
+      }
+      if (!agent2.config.models.base && this.models.base) {
+        agent2.config.models.base = this.models.base;
+      }
+      if (!agent2.config.models.structuredOutput && this.models.structuredOutput) {
+        agent2.config.models.structuredOutput = this.models.structuredOutput;
+      }
+      if (!agent2.config.models.summarizer && this.models.summarizer) {
+        agent2.config.models.summarizer = this.models.summarizer;
+      }
+    }
+  }
+  /**
+   * Immediately propagate agent-level models to all agents during construction
+   */
+  propagateImmediateModelSettings() {
+    for (const subAgent2 of this.subAgents) {
+      this.propagateModelSettingsToAgent(subAgent2);
+    }
+  }
+  /**
+   * 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}/agent/${this.agentId}/v1/chat/completions`;
+    logger6.info({ url }, "Executing with backend");
+    const requestBody = {
+      model: "gpt-4o-mini",
+      messages: normalizedMessages.map((msg) => ({
+        role: msg.role,
+        content: msg.content
+      })),
+      ...options,
+      // Include conversationId for multi-turn support
+      ...options?.conversationId && {
+        conversationId: options.conversationId
+      },
+      // Include context data if available
+      ...options?.customBodyParams && { ...options.customBodyParams },
+      stream: false
+      // Explicitly disable streaming - must come after options to override
+    };
+    try {
+      const response = await fetch(url, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Accept: "application/json"
+        },
+        body: JSON.stringify(requestBody)
+      });
+      if (!response.ok) {
+        throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+      }
+      const responseText = await response.text();
+      if (responseText.startsWith("data:")) {
+        return this.parseStreamingResponse(responseText);
+      }
+      const data = JSON.parse(responseText);
+      return data.result || data.choices?.[0]?.message?.content || "";
+    } catch (error) {
+      throw new Error(`Agent execution failed: ${error.message || "Unknown error"}`);
+    }
+  }
+  /**
+   * Parse streaming response in SSE format
+   */
+  parseStreamingResponse(text) {
+    const lines = text.split("\n");
+    let content = "";
+    for (const line of lines) {
+      if (line.startsWith("data: ")) {
+        const dataStr = line.slice(6);
+        if (dataStr === "[DONE]") break;
+        try {
+          const data = JSON.parse(dataStr);
+          const delta = data.choices?.[0]?.delta?.content;
+          if (delta) {
+            content += delta;
+          }
+        } catch (_e) {
+        }
+      }
+    }
+    return content;
+  }
+  /**
+   * Normalize input messages to the expected format
+   */
+  normalizeMessages(input) {
+    if (typeof input === "string") {
+      return [{ role: "user", content: input }];
+    }
+    if (Array.isArray(input)) {
+      return input.map((msg) => typeof msg === "string" ? { role: "user", content: msg } : msg);
+    }
+    return [input];
+  }
+  async saveToDatabase() {
+    try {
+      const getUrl = `${this.baseURL}/tenants/${this.tenantId}/agents/${this.agentId}`;
+      try {
+        const getResponse = await fetch(getUrl, {
+          method: "GET",
+          headers: {
+            "Content-Type": "application/json"
+          }
+        });
+        if (getResponse.ok) {
+          logger6.info({ agentId: this.agentId }, "Agent already exists in backend");
+          return;
+        }
+        if (getResponse.status !== 404) {
+          throw new Error(`HTTP ${getResponse.status}: ${getResponse.statusText}`);
+        }
+      } catch (error) {
+        if (!error.message.includes("404")) {
+          throw error;
+        }
+      }
+      logger6.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.agentId,
+          name: this.agentName,
+          defaultSubAgentId: this.defaultSubAgent?.getId() || "",
+          contextConfigId: this.contextConfig?.getId(),
+          models: this.models
+        })
+      });
+      if (!createResponse.ok) {
+        throw new Error(`HTTP ${createResponse.status}: ${createResponse.statusText}`);
+      }
+      const createData = await createResponse.json();
+      this.agentId = createData.data.id;
+      logger6.info({ agent: createData.data }, "Agent created in backend");
+    } catch (error) {
+      throw new 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}/agents/${this.agentId}`;
+        const updateResponse = await fetch(updateUrl, {
+          method: "PUT",
+          headers: {
+            "Content-Type": "application/json"
+          },
+          body: JSON.stringify({
+            id: this.agentId,
+            defaultSubAgentId: this.defaultSubAgent.getId(),
+            contextConfigId: this.contextConfig?.getId()
+          })
+        });
+        if (!updateResponse.ok) {
+          throw new Error(`HTTP ${updateResponse.status}: ${updateResponse.statusText}`);
+        }
+        logger6.debug(
+          {
+            agentId: this.agentId,
+            defaultSubAgent: this.defaultSubAgent.getName()
+          },
+          "Agent relationships configured"
+        );
+      } catch (error) {
+        logger6.error(
+          {
+            agentId: this.agentId,
+            error: error instanceof Error ? error.message : "Unknown error"
+          },
+          "Failed to update agent relationships"
+        );
+        throw error;
+      }
+    }
+  }
+  async createSubAgentRelations() {
+    const allSubAgentRelationPromises = [];
+    for (const subAgent2 of this.subAgents) {
+      const transfers = subAgent2.getTransfers();
+      for (const transferAgent of transfers) {
+        allSubAgentRelationPromises.push(
+          this.createSubAgentRelation(subAgent2, transferAgent, "transfer")
+        );
+      }
+      const delegates = subAgent2.getSubAgentDelegates();
+      for (const delegate of delegates) {
+        if (this.isInternalAgent(delegate)) {
+          allSubAgentRelationPromises.push(
+            this.createSubAgentRelation(subAgent2, delegate, "delegate")
+          );
+        }
+      }
+    }
+    const results = await Promise.allSettled(allSubAgentRelationPromises);
+    const errors = [];
+    let successCount = 0;
+    for (const result of results) {
+      if (result.status === "fulfilled") {
+        successCount++;
+      } else {
+        errors.push(result.reason);
+        logger6.error(
+          {
+            error: result.reason instanceof Error ? result.reason.message : "Unknown error",
+            agentId: this.agentId
+          },
+          "Failed to create agent relation"
+        );
+      }
+    }
+    logger6.info(
+      {
+        agentId: this.agentId,
+        totalRelations: allSubAgentRelationPromises.length,
+        successCount,
+        errorCount: errors.length
+      },
+      "Completed agent relation creation batch"
+    );
+    if (errors.length > 0 && successCount === 0) {
+      throw new Error(`All ${errors.length} agent relation creations failed`);
+    }
+  }
+  async createSubAgentRelation(sourceAgent, targetAgent, relationType) {
+    try {
+      const response = await fetch(`${this.baseURL}/tenants/${this.tenantId}/agent-relations`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({
+          agentId: this.agentId,
+          sourceSubAgentId: sourceAgent.getId(),
+          targetSubAgentId: targetAgent.getId(),
+          relationType
+        })
+      });
+      if (!response.ok) {
+        const errorText = await response.text().catch(() => "Unknown error");
+        if (response.status === 422 && errorText.includes("already exists")) {
+          logger6.info(
+            {
+              sourceSubAgentId: sourceAgent.getId(),
+              targetSubAgentId: targetAgent.getId(),
+              agentId: this.agentId,
+              relationType
+            },
+            `${relationType} relation already exists, skipping creation`
+          );
+          return;
+        }
+        throw new Error(`Failed to create subAgent relation: ${response.status} - ${errorText}`);
+      }
+      logger6.info(
+        {
+          sourceSubAgentId: sourceAgent.getId(),
+          targetSubAgentId: targetAgent.getId(),
+          agentId: this.agentId,
+          relationType
+        },
+        `${relationType} subAgent relation created successfully`
+      );
+    } catch (error) {
+      logger6.error(
+        {
+          sourceSubAgentId: sourceAgent.getId(),
+          targetSubAgentId: targetAgent.getId(),
+          agentId: this.agentId,
+          relationType,
+          error: error instanceof Error ? error.message : "Unknown error"
+        },
+        `Failed to create ${relationType} subAgent relation`
+      );
+      throw error;
+    }
+  }
+};
+var logger7 = getLogger("dataComponent");
+var DataComponent = class {
+  constructor(config) {
+    __publicField(this, "config");
+    __publicField(this, "baseURL");
+    __publicField(this, "tenantId");
+    __publicField(this, "projectId");
+    __publicField(this, "initialized", false);
+    __publicField(this, "id");
+    this.id = 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,
+      props: processedProps,
+      render: config.render || null
+    };
+    this.baseURL = process.env.INKEEP_API_URL || "http://localhost:3002";
+    this.tenantId = "default";
+    this.projectId = "default";
+    logger7.info(
+      {
+        dataComponentId: this.getId(),
+        dataComponentName: config.name
+      },
+      "DataComponent constructor initialized"
+    );
+  }
+  // Set context (tenantId, projectId, and baseURL) from external source (sub-agent, agent, CLI, etc)
+  setContext(tenantId, projectId, baseURL) {
+    this.tenantId = tenantId;
+    this.projectId = projectId;
+    if (baseURL) {
+      this.baseURL = baseURL;
+    }
+  }
+  // Compute ID from name using same slug transformation as agents
+  getId() {
+    return this.id;
+  }
+  getName() {
+    return this.config.name;
+  }
+  getDescription() {
+    return this.config.description;
+  }
+  getProps() {
+    return this.config.props;
+  }
+  getRender() {
+    return this.config.render;
+  }
+  // Public method to ensure data component exists in backend (with upsert behavior)
+  async init() {
+    if (this.initialized) return;
+    try {
+      await this.upsertDataComponent();
+      logger7.info(
+        {
+          dataComponentId: this.getId()
+        },
+        "DataComponent initialized successfully"
+      );
+      this.initialized = true;
+    } catch (error) {
+      logger7.error(
+        {
+          dataComponentId: this.getId(),
+          error: error instanceof Error ? error.message : "Unknown error"
+        },
+        "Failed to initialize data component"
+      );
+      throw error;
+    }
+  }
+  // Private method to upsert data component (create or update)
+  async upsertDataComponent() {
+    const dataComponentData = {
+      id: this.getId(),
+      name: this.config.name,
+      description: this.config.description,
+      props: this.config.props,
+      render: this.config.render
+    };
+    logger7.info({ dataComponentData }, "dataComponentData for create/update");
+    const updateResponse = await fetch(
+      `${this.baseURL}/tenants/${this.tenantId}/projects/${this.projectId}/data-components/${this.getId()}`,
+      {
+        method: "PUT",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify(dataComponentData)
+      }
+    );
+    logger7.info(
+      {
+        status: updateResponse.status,
+        dataComponentId: this.getId()
+      },
+      "data component updateResponse"
+    );
+    if (updateResponse.ok) {
+      logger7.info(
+        {
+          dataComponentId: this.getId()
+        },
+        "DataComponent updated successfully"
+      );
+      return;
+    }
+    if (updateResponse.status === 404) {
+      logger7.info(
+        {
+          dataComponentId: this.getId()
+        },
+        "DataComponent not found, creating new data component"
+      );
+      const createResponse = await fetch(
+        `${this.baseURL}/tenants/${this.tenantId}/projects/${this.projectId}/data-components`,
+        {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json"
+          },
+          body: JSON.stringify(dataComponentData)
+        }
+      );
+      if (!createResponse.ok) {
+        const errorText2 = await createResponse.text().catch(() => "Unknown error");
+        throw new Error(
+          `Failed to create data component: ${createResponse.status} ${createResponse.statusText} - ${errorText2}`
+        );
+      }
+      logger7.info(
+        {
+          dataComponentId: this.getId()
+        },
+        "DataComponent created successfully"
+      );
+      return;
+    }
+    const errorText = await updateResponse.text().catch(() => "Unknown error");
+    throw new Error(
+      `Failed to update data component: ${updateResponse.status} ${updateResponse.statusText} - ${errorText}`
+    );
+  }
+};
+var logger8 = getLogger("project");
+var Project = class {
+  constructor(config) {
+    __publicField(this, "__type", "project");
+    __publicField(this, "projectId");
+    __publicField(this, "projectName");
+    __publicField(this, "projectDescription");
+    __publicField(this, "tenantId");
+    __publicField(this, "baseURL");
+    __publicField(this, "apiKey");
+    __publicField(this, "initialized", false);
+    __publicField(this, "models");
+    __publicField(this, "stopWhen");
+    __publicField(this, "agents", []);
+    __publicField(this, "agentMap", /* @__PURE__ */ new Map());
+    __publicField(this, "credentialReferences", []);
+    __publicField(this, "projectTools", []);
+    __publicField(this, "projectDataComponents", []);
+    __publicField(this, "projectArtifactComponents", []);
+    __publicField(this, "projectExternalAgents", []);
+    __publicField(this, "externalAgentMap", /* @__PURE__ */ new Map());
+    this.projectId = config.id;
+    this.projectName = config.name;
+    this.projectDescription = config.description;
+    this.tenantId = process.env.INKEEP_TENANT_ID || "default";
+    this.baseURL = process.env.INKEEP_API_URL || "http://localhost:3002";
+    this.models = config.models;
+    this.stopWhen = config.stopWhen;
+    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) {
+      this.projectTools = config.tools();
+    }
+    if (config.dataComponents) {
+      this.projectDataComponents = config.dataComponents();
+    }
+    if (config.artifactComponents) {
+      this.projectArtifactComponents = config.artifactComponents();
+    }
+    if (config.credentialReferences) {
+      this.credentialReferences = config.credentialReferences();
+    }
+    if (config.externalAgents) {
+      this.projectExternalAgents = config.externalAgents();
+      this.externalAgentMap = new Map(
+        this.projectExternalAgents.map((externalAgent2) => [externalAgent2.getId(), externalAgent2])
+      );
+    }
+    logger8.info(
+      {
+        projectId: this.projectId,
+        tenantId: this.tenantId,
+        agentCount: this.agents.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, models, apiKey) {
+    if (this.initialized) {
+      throw new Error("Cannot set config after project has been initialized");
+    }
+    this.tenantId = tenantId;
+    this.baseURL = apiUrl;
+    this.apiKey = apiKey;
+    if (models) {
+      this.models = models;
+    }
+    for (const agent2 of this.agents) {
+      agent2.setConfig(tenantId, this.projectId, apiUrl);
+    }
+    logger8.info(
+      {
+        projectId: this.projectId,
+        tenantId: this.tenantId,
+        apiUrl: this.baseURL,
+        hasModels: !!this.models,
+        hasApiKey: !!this.apiKey
+      },
+      "Project configuration updated"
+    );
+  }
+  /**
+   * Set credential references for the project
+   * This is used by the CLI to inject environment-specific credentials
+   */
+  setCredentials(credentials) {
+    this.credentialReferences = Object.values(credentials);
+    logger8.info(
+      {
+        projectId: this.projectId,
+        credentialCount: this.credentialReferences?.length || 0
+      },
+      "Project credentials updated"
+    );
+  }
+  /**
+   * Initialize the project and create/update it in the backend using full project approach
+   */
+  async init() {
+    if (this.initialized) {
+      logger8.info({ projectId: this.projectId }, "Project already initialized");
+      return;
+    }
+    logger8.info(
+      {
+        projectId: this.projectId,
+        tenantId: this.tenantId,
+        agentCount: this.agents.length
+      },
+      "Initializing project using full project endpoint"
+    );
+    try {
+      const projectDefinition = await this.toFullProjectDefinition();
+      logger8.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.apiKey
+      );
+      this.initialized = true;
+      logger8.info(
+        {
+          projectId: this.projectId,
+          tenantId: this.tenantId,
+          agentCount: Object.keys(createdProject.agent || {}).length
+        },
+        "Project initialized successfully using full project endpoint"
+      );
+    } catch (error) {
+      logger8.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 credential tracking information
+   */
+  async getCredentialTracking() {
+    const fullDef = await this.toFullProjectDefinition();
+    const credentials = fullDef.credentialReferences || {};
+    const usage = {};
+    for (const [credId, credData] of Object.entries(credentials)) {
+      if (credData.usedBy) {
+        usage[credId] = credData.usedBy;
+      }
+    }
+    return { credentials, usage };
+  }
+  async getFullDefinition() {
+    return await this.toFullProjectDefinition();
+  }
+  /**
+   * Get all agent in the project
+   */
+  getAgents() {
+    return this.agents;
+  }
+  /**
+   * Get all external agents in the project
+   */
+  getExternalAgents() {
+    return this.projectExternalAgents;
+  }
+  /**
+   * Get an external agent by ID
+   */
+  getExternalAgent(id) {
+    return this.externalAgentMap.get(id);
+  }
+  /**
+   * Add an external agent to the project
+   */
+  addExternalAgent(externalAgent2) {
+    this.projectExternalAgents.push(externalAgent2);
+    this.externalAgentMap.set(externalAgent2.getId(), externalAgent2);
+  }
+  /**
+   * Remove an external agent from the project
+   */
+  removeExternalAgent(id) {
+    const externalAgentToRemove = this.externalAgentMap.get(id);
+    if (externalAgentToRemove) {
+      this.externalAgentMap.delete(id);
+      this.projectExternalAgents = this.projectExternalAgents.filter(
+        (externalAgent2) => externalAgent2.getId() !== id
+      );
+      logger8.info(
+        {
+          projectId: this.projectId,
+          externalAgentId: id
+        },
+        "External agent removed from project"
+      );
+      return true;
+    }
+    return false;
+  }
+  /**
+   * Get an agent by ID
+   */
+  getAgent(id) {
+    return this.agentMap.get(id);
+  }
+  /**
+   * Add an agent to the project
+   */
+  addAgent(agent2) {
+    this.agents.push(agent2);
+    this.agentMap.set(agent2.getId(), agent2);
+    agent2.setConfig(this.tenantId, this.projectId, this.baseURL);
+    logger8.info(
+      {
+        projectId: this.projectId,
+        agentId: agent2.getId()
+      },
+      "Agent added to project"
+    );
+  }
+  /**
+   * Remove an agent from the project
+   */
+  removeAgent(id) {
+    const agentToRemove = this.agentMap.get(id);
+    if (agentToRemove) {
+      this.agentMap.delete(id);
+      this.agents = this.agents.filter((agent2) => agent2.getId() !== id);
+      logger8.info(
+        {
+          projectId: this.projectId,
+          agentId: id
+        },
+        "Agent removed from project"
+      );
+      return true;
+    }
+    return false;
+  }
+  /**
+   * Get project statistics
+   */
+  getStats() {
+    return {
+      projectId: this.projectId,
+      tenantId: this.tenantId,
+      agentCount: this.agents.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 agentIds = /* @__PURE__ */ new Set();
+    for (const agent2 of this.agents) {
+      const id = agent2.getId();
+      if (agentIds.has(id)) {
+        errors.push(`Duplicate agent ID: ${id}`);
+      }
+      agentIds.add(id);
+    }
+    for (const agent2 of this.agents) {
+      const agentValidation = agent2.validate();
+      if (!agentValidation.valid) {
+        errors.push(...agentValidation.errors.map((error) => `Agent '${agent2.getId()}': ${error}`));
+      }
+    }
+    return {
+      valid: errors.length === 0,
+      errors
+    };
+  }
+  /**
+   * Convert the Project to FullProjectDefinition format
+   */
+  async toFullProjectDefinition() {
+    const agentsObject = {};
+    const toolsObject = {};
+    const functionToolsObject = {};
+    const functionsObject = {};
+    const dataComponentsObject = {};
+    const artifactComponentsObject = {};
+    const credentialReferencesObject = {};
+    const externalAgentsObject = {};
+    const credentialUsageMap = {};
+    for (const agent2 of this.agents) {
+      logger8.info({ agentId: agent2.getId() }, "Agent id");
+      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;
+          }
+          if (credential2?.id) {
+            if (!credentialReferencesObject[credential2.id]) {
+              credentialReferencesObject[credential2.id] = {
+                id: credential2.id,
+                name: credential2.name,
+                type: credential2.type,
+                credentialStoreId: credential2.credentialStoreId,
+                retrievalParams: credential2.retrievalParams
+              };
+              credentialUsageMap[credential2.id] = [];
+            }
+            credentialUsageMap[credential2.id].push({
+              type: "agent",
+              id: agent2.getId()
+            });
+          }
+        }
+      }
+      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) {
+              const credential2 = variable.credential;
+              let credId;
+              if (credential2.__type === "credential-ref") {
+                credId = credential2.id;
+                if (credId && this.credentialReferences) {
+                  const resolvedCred = this.credentialReferences.find((c) => c.id === credId);
+                  if (resolvedCred && !credentialReferencesObject[credId]) {
+                    credentialReferencesObject[credId] = resolvedCred;
+                    credentialUsageMap[credId] = [];
+                  }
+                }
+              } else if (credential2.id) {
+                credId = credential2.id;
+                if (credId && !credentialReferencesObject[credId]) {
+                  credentialReferencesObject[credId] = credential2;
+                  credentialUsageMap[credId] = [];
+                }
+              }
+              if (credId) {
+                if (!credentialUsageMap[credId]) {
+                  credentialUsageMap[credId] = [];
+                }
+                credentialUsageMap[credId].push({
+                  type: "contextVariable",
+                  id: key,
+                  agentId: agent2.getId()
+                });
+              }
+            } else if (variable?.credentialReferenceId) {
+              const credId = variable.credentialReferenceId;
+              if (!credentialUsageMap[credId]) {
+                credentialUsageMap[credId] = [];
+              }
+              credentialUsageMap[credId].push({
+                type: "contextVariable",
+                id: key,
+                agentId: agent2.getId()
+              });
+            }
+          }
+        }
+      }
+      for (const subAgent2 of agent2.getSubAgents()) {
+        const agentTools = subAgent2.getTools();
+        for (const [, toolInstance] of Object.entries(agentTools)) {
+          const actualTool = toolInstance;
+          const toolId = actualTool.getId();
+          if (actualTool.constructor.name === "FunctionTool" && actualTool instanceof FunctionTool) {
+            if (!functionsObject[toolId]) {
+              const functionData = actualTool.serializeFunction();
+              functionsObject[toolId] = functionData;
+            }
+            if (!functionToolsObject[toolId]) {
+              const toolData = actualTool.serializeTool();
+              functionToolsObject[toolId] = {
+                id: toolData.id,
+                name: toolData.name,
+                description: toolData.description,
+                functionId: toolData.functionId
+              };
+            }
+          } else {
+            if (!toolsObject[toolId]) {
+              if ("config" in actualTool && "serverUrl" in actualTool.config) {
+                const mcpTool2 = actualTool;
+                const toolConfig = {
+                  type: "mcp",
+                  mcp: {
+                    server: {
+                      url: mcpTool2.config.serverUrl
+                    },
+                    transport: mcpTool2.config.transport,
+                    activeTools: mcpTool2.config.activeTools
+                  }
+                };
+                const toolData = {
+                  id: toolId,
+                  name: actualTool.getName(),
+                  config: toolConfig
+                };
+                if (mcpTool2.config?.imageUrl) {
+                  toolData.imageUrl = mcpTool2.config.imageUrl;
+                }
+                if (mcpTool2.config?.headers) {
+                  toolData.headers = mcpTool2.config.headers;
+                }
+                if ("getCredentialReferenceId" in actualTool) {
+                  const credentialId = actualTool.getCredentialReferenceId();
+                  if (credentialId) {
+                    toolData.credentialReferenceId = credentialId;
+                  }
+                }
+                if ("credential" in mcpTool2.config && mcpTool2.config.credential) {
+                  const credential2 = mcpTool2.config.credential;
+                  if (credential2?.id && credential2.__type !== "credential-ref") {
+                    if (!credentialReferencesObject[credential2.id]) {
+                      credentialReferencesObject[credential2.id] = {
+                        id: credential2.id,
+                        name: credential2.name,
+                        type: credential2.type,
+                        credentialStoreId: credential2.credentialStoreId,
+                        retrievalParams: credential2.retrievalParams
+                      };
+                      credentialUsageMap[credential2.id] = [];
+                    }
+                    credentialUsageMap[credential2.id].push({
+                      type: "tool",
+                      id: toolId
+                    });
+                  }
+                }
+                toolsObject[toolId] = toolData;
+              }
+            }
+          }
+        }
+        const subAgentDataComponents = subAgent2.getDataComponents?.();
+        if (subAgentDataComponents) {
+          for (const dataComponent2 of subAgentDataComponents) {
+            let dataComponentId;
+            let dataComponentName;
+            let dataComponentDescription;
+            let dataComponentProps;
+            let dataComponentRender;
+            if (dataComponent2.getId) {
+              dataComponentId = dataComponent2.getId();
+              dataComponentName = dataComponent2.getName();
+              dataComponentDescription = dataComponent2.getDescription() || "";
+              dataComponentProps = dataComponent2.getProps() || {};
+              dataComponentRender = dataComponent2.getRender?.() || null;
+            } else {
+              dataComponentId = dataComponent2.id || (dataComponent2.name ? dataComponent2.name.toLowerCase().replace(/\s+/g, "-") : "");
+              dataComponentName = dataComponent2.name || "";
+              dataComponentDescription = dataComponent2.description || "";
+              dataComponentProps = dataComponent2.props || {};
+              dataComponentRender = dataComponent2.render || null;
+            }
+            if (!dataComponentsObject[dataComponentId] && dataComponentName) {
+              dataComponentsObject[dataComponentId] = {
+                id: dataComponentId,
+                name: dataComponentName,
+                description: dataComponentDescription,
+                props: dataComponentProps,
+                render: dataComponentRender
+              };
+            }
+          }
+        }
+        const subAgentArtifactComponents = subAgent2.getArtifactComponents();
+        if (subAgentArtifactComponents) {
+          for (const artifactComponent2 of subAgentArtifactComponents) {
+            let artifactComponentId;
+            let artifactComponentName;
+            let artifactComponentDescription;
+            let artifactComponentProps;
+            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 || "";
+              artifactComponentDescription = artifactComponent2.description || "";
+              artifactComponentProps = artifactComponent2.props || {};
+            }
+            if (!artifactComponentsObject[artifactComponentId] && artifactComponentName) {
+              artifactComponentsObject[artifactComponentId] = {
+                id: artifactComponentId,
+                name: artifactComponentName,
+                description: artifactComponentDescription,
+                props: artifactComponentProps
+              };
+            }
+          }
+        }
+        const subAgentExternalAgents = subAgent2.getExternalAgentDelegates();
+        if (subAgentExternalAgents) {
+          for (const externalAgentDelegate of subAgentExternalAgents) {
+            const externalAgent2 = externalAgentDelegate.externalAgent;
+            const credential2 = externalAgent2.getCredentialReference();
+            if (credential2) {
+              if (!credentialReferencesObject[credential2.id]) {
+                credentialReferencesObject[credential2.id] = {
+                  id: credential2.id,
+                  name: credential2.name,
+                  type: credential2.type,
+                  credentialStoreId: credential2.credentialStoreId,
+                  retrievalParams: credential2.retrievalParams
+                };
+                credentialUsageMap[credential2.id] = [];
+              }
+              logger8.info({ credentialId: credential2.id }, "Credential id in external agent");
+              credentialUsageMap[credential2.id].push({
+                type: "externalAgent",
+                id: externalAgent2.getId()
+              });
+            }
+            logger8.info({ externalAgentId: externalAgent2.getId() }, "External agent id");
+            externalAgentsObject[externalAgent2.getId()] = {
+              id: externalAgent2.getId(),
+              name: externalAgent2.getName(),
+              description: externalAgent2.getDescription(),
+              baseUrl: externalAgent2.getBaseUrl(),
+              credentialReferenceId: externalAgent2.getCredentialReferenceId()
+            };
+          }
+        }
+      }
+    }
+    logger8.info({ externalAgentsObject }, "External agents object");
+    for (const tool of this.projectTools) {
+      const toolId = tool.getId();
+      if (!toolsObject[toolId]) {
+        const toolConfig = {
+          type: "mcp",
+          mcp: {
+            server: {
+              url: tool.config.serverUrl
+            },
+            transport: tool.config.transport,
+            activeTools: tool.config.activeTools
+          }
+        };
+        const toolData = {
+          id: toolId,
+          name: tool.getName(),
+          config: toolConfig
+        };
+        if (tool.config?.imageUrl) {
+          toolData.imageUrl = tool.config.imageUrl;
+        }
+        if (tool.config?.headers) {
+          toolData.headers = tool.config.headers;
+        }
+        const credentialId = tool.getCredentialReferenceId();
+        if (credentialId) {
+          toolData.credentialReferenceId = credentialId;
+        }
+        toolsObject[toolId] = toolData;
+      }
+    }
+    for (const dataComponent2 of this.projectDataComponents) {
+      const dataComponentId = dataComponent2.getId();
+      const dataComponentName = dataComponent2.getName();
+      const dataComponentDescription = dataComponent2.getDescription() || "";
+      const dataComponentProps = dataComponent2.getProps() || {};
+      if (!dataComponentsObject[dataComponentId] && dataComponentName) {
+        dataComponentsObject[dataComponentId] = {
+          id: dataComponentId,
+          name: dataComponentName,
+          description: dataComponentDescription,
+          props: dataComponentProps
+        };
+      }
+    }
+    for (const artifactComponent2 of this.projectArtifactComponents) {
+      const artifactComponentId = artifactComponent2.getId();
+      const artifactComponentName = artifactComponent2.getName();
+      const artifactComponentDescription = artifactComponent2.getDescription() || "";
+      const artifactComponentProps = artifactComponent2.getProps() || {};
+      if (!artifactComponentsObject[artifactComponentId] && artifactComponentName) {
+        artifactComponentsObject[artifactComponentId] = {
+          id: artifactComponentId,
+          name: artifactComponentName,
+          description: artifactComponentDescription,
+          props: artifactComponentProps
+        };
+      }
+    }
+    if (this.credentialReferences && this.credentialReferences.length > 0) {
+      for (const credential2 of this.credentialReferences) {
+        if (credential2.id) {
+          if (!credentialReferencesObject[credential2.id]) {
+            credentialReferencesObject[credential2.id] = credential2;
+            credentialUsageMap[credential2.id] = [];
+          }
+        }
+      }
+    }
+    for (const [credId, usages] of Object.entries(credentialUsageMap)) {
+      if (credentialReferencesObject[credId]) {
+        credentialReferencesObject[credId].usedBy = usages;
+      }
+    }
+    return {
+      id: this.projectId,
+      name: this.projectName,
+      description: this.projectDescription || "",
+      models: this.models,
+      stopWhen: this.stopWhen,
+      agents: agentsObject,
+      tools: toolsObject,
+      functionTools: Object.keys(functionToolsObject).length > 0 ? functionToolsObject : void 0,
+      functions: Object.keys(functionsObject).length > 0 ? functionsObject : void 0,
+      dataComponents: Object.keys(dataComponentsObject).length > 0 ? dataComponentsObject : void 0,
+      artifactComponents: Object.keys(artifactComponentsObject).length > 0 ? artifactComponentsObject : void 0,
+      externalAgents: Object.keys(externalAgentsObject).length > 0 ? externalAgentsObject : void 0,
+      credentialReferences: Object.keys(credentialReferencesObject).length > 0 ? credentialReferencesObject : void 0,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+};
+var logger9 = getLogger("statusComponent");
+var StatusComponent = class {
+  constructor(config) {
+    __publicField(this, "config");
+    let processedDetailsSchema;
+    if (config.detailsSchema && isZodSchema(config.detailsSchema)) {
+      const jsonSchema = convertZodToJsonSchema(config.detailsSchema);
+      processedDetailsSchema = {
+        type: "object",
+        properties: jsonSchema.properties || {},
+        required: jsonSchema.required || void 0
+      };
+    } else {
+      processedDetailsSchema = config.detailsSchema;
+    }
+    this.config = {
+      ...config,
+      detailsSchema: processedDetailsSchema
+    };
+    logger9.info(
+      {
+        statusComponentType: config.type
+      },
+      "StatusComponent constructor initialized"
+    );
+  }
+  getType() {
+    return this.config.type;
+  }
+  getDescription() {
+    return this.config.description;
+  }
+  getDetailsSchema() {
+    return this.config.detailsSchema;
+  }
+};
+var logger10 = getLogger("tool");
+var Tool = class {
+  constructor(config) {
+    __publicField(this, "config");
+    __publicField(this, "baseURL");
+    __publicField(this, "tenantId");
+    __publicField(this, "initialized", false);
+    __publicField(this, "projectId");
+    this.config = config;
+    this.baseURL = process.env.INKEEP_API_URL || "http://localhost:3002";
+    this.tenantId = "default";
+    this.projectId = "default";
+    logger10.info(
+      {
+        Id: this.getId(),
+        Name: config.name
+      },
+      "Tool constructor initialized"
+    );
+  }
+  // Set context (tenantId, projectId, and baseURL) from external source (agent, agent, CLI, etc)
+  setContext(tenantId, projectId, baseURL) {
+    this.tenantId = tenantId;
+    this.projectId = projectId;
+    if (baseURL) {
+      this.baseURL = baseURL;
+    }
+  }
+  // Compute ID from name using same slug transformation as agents
+  getId() {
+    return this.config.id;
+  }
+  getName() {
+    return this.config.name;
+  }
+  getDescription() {
+    return this.config.description || "";
+  }
+  getServerUrl() {
+    return this.config.serverUrl;
+  }
+  getActiveTools() {
+    return this.config.activeTools;
+  }
+  getCredentialReferenceId() {
+    return this.config.credential?.id;
+  }
+  // Public method to ensure tool exists in backend (with upsert behavior)
+  async init(options) {
+    if (this.initialized) return;
+    try {
+      if (!options?.skipDatabaseRegistration) {
+        await this.upsertTool();
+      }
+      logger10.info(
+        {
+          toolId: this.getId()
+        },
+        "Tool initialized successfully"
+      );
+      this.initialized = true;
+    } catch (error) {
+      logger10.error(
+        {
+          toolId: this.getId(),
+          error: error instanceof Error ? error.message : "Unknown error"
+        },
+        "Failed to initialize tool"
+      );
+      throw error;
+    }
+  }
+  // Private method to upsert tool (create or update)
+  async upsertTool() {
+    const toolDataForUpdate = {
+      id: this.getId(),
+      name: this.config.name,
+      credentialReferenceId: this.config.credential?.id ?? null,
+      headers: this.config.headers ?? null,
+      imageUrl: this.config.imageUrl,
+      config: {
+        type: "mcp",
+        mcp: {
+          server: {
+            url: this.config.serverUrl
+          },
+          transport: this.config.transport,
+          activeTools: this.config.activeTools
+        }
+      }
+    };
+    const toolDataForCreate = {
+      ...toolDataForUpdate
+    };
+    logger10.info({ toolDataForCreate }, "toolDataForCreate");
+    const updateResponse = await fetch(
+      `${this.baseURL}/tenants/${this.tenantId}/projects/${this.projectId}/tools/${this.getId()}`,
+      {
+        method: "PUT",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify(toolDataForUpdate)
+      }
+    );
+    logger10.info({ updateResponse }, "tool updateResponse");
+    if (updateResponse.ok) {
+      logger10.info(
+        {
+          toolId: this.getId()
+        },
+        "Tool updated successfully"
+      );
+      return;
+    }
+    if (updateResponse.status === 404) {
+      logger10.info(
+        {
+          toolId: this.getId()
+        },
+        "Tool not found, creating new tool"
+      );
+      const createResponse = await fetch(
+        `${this.baseURL}/tenants/${this.tenantId}/projects/${this.projectId}/tools`,
+        {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json"
+          },
+          body: JSON.stringify(toolDataForCreate)
+        }
+      );
+      if (!createResponse.ok) {
+        throw new Error(`Failed to create tool: ${createResponse.status}`);
+      }
+      logger10.info(
+        {
+          toolId: this.getId()
+        },
+        "Tool created successfully"
+      );
+      return;
+    }
+    throw new Error(`Failed to update tool: ${updateResponse.status}`);
+  }
+  /**
+   * Creates a new AgentMcpConfig with the given configuration.
+   *
+   * @param config - The configuration for the AgentMcpConfig
+   * @returns A new AgentMcpConfig
+   *
+   * example:
+   * ```typescript
+   * const tool = new Tool({
+   *   id: 'tool-id',
+   *   name: 'Tool Name',
+   *   serverUrl: 'https://example.com/mcp',
+   * });
+   * const agentMcpConfig = tool.with({ selectedTools: ['tool-1', 'tool-2'], headers: { 'Authorization': 'Bearer token' } });
+   * ```
+   */
+  with(config) {
+    const { selectedTools, toolPolicies } = normalizeToolSelections(config.selectedTools);
+    return {
+      server: this,
+      selectedTools,
+      headers: config.headers,
+      toolPolicies
+    };
+  }
+};
+
+// src/utils/tool-normalization.ts
+function isAgentMcpConfig(value) {
+  return value !== null && typeof value === "object" && "server" in value && value.server && typeof value.server === "object";
+}
+function isTool(value) {
+  return value !== null && typeof value === "object" && "config" in value && (typeof value.getId === "function" || "id" in value);
+}
+function normalizeAgentCanUseType(value, fallbackName) {
+  if (isAgentMcpConfig(value)) {
+    return {
+      tool: value.server,
+      toolId: value.server.getId(),
+      selectedTools: value.selectedTools,
+      headers: value.headers,
+      toolPolicies: value.toolPolicies,
+      isWrapped: true
+    };
+  }
+  if (isTool(value)) {
+    const toolId = value.getId?.() || value.id || fallbackName || "unknown";
+    return {
+      tool: value,
+      toolId,
+      isWrapped: false
+    };
+  }
+  throw new Error(`Invalid AgentCanUseType: expected Tool or AgentMcpConfig, got ${typeof value}`);
+}
+
+// src/subAgent.ts
+var logger11 = getLogger("agent");
+function resolveGetter2(value) {
+  if (typeof value === "function") {
+    return value();
+  }
+  return value;
+}
+var SubAgent = class {
+  constructor(config) {
+    __publicField(this, "config");
+    __publicField(this, "type", "internal");
+    __publicField(this, "baseURL");
+    __publicField(this, "tenantId");
+    __publicField(this, "projectId");
+    __publicField(this, "initialized", false);
+    this.config = { ...config, type: "internal" };
+    this.baseURL = process.env.INKEEP_API_URL || "http://localhost:3002";
+    this.tenantId = "default";
+    this.projectId = "default";
+    logger11.info(
+      {
+        tenantId: this.tenantId,
+        subAgentId: this.config.id,
+        agentName: config.name
+      },
+      "Agent constructor initialized"
+    );
+  }
+  // Set context (tenantId, projectId, and baseURL) from external source (agent, CLI, etc)
+  setContext(tenantId, projectId, baseURL) {
+    this.tenantId = tenantId;
+    this.projectId = projectId;
+    if (baseURL) {
+      this.baseURL = baseURL;
+    }
+  }
+  // Return the configured ID
+  getId() {
+    return this.config.id;
+  }
+  // Agent introspection methods
+  getName() {
+    return this.config.name;
+  }
+  getInstructions() {
+    return this.config.prompt;
+  }
+  /**
+   * Get the agent's description (the human-readable description field)
+   */
+  getDescription() {
+    return this.config.description || "";
+  }
+  getTools() {
+    const tools = resolveGetter2(this.config.canUse);
+    if (!tools) {
+      return {};
+    }
+    if (!Array.isArray(tools)) {
+      throw new Error("tools getter must return an array");
+    }
+    const toolRecord = {};
+    for (const tool of tools) {
+      if (tool && typeof tool === "object") {
+        let id;
+        let toolInstance;
+        if (isAgentMcpConfig(tool)) {
+          id = tool.server.getId();
+          toolInstance = tool.server;
+          toolInstance.selectedTools = tool.selectedTools;
+          toolInstance.headers = tool.headers;
+          toolInstance.toolPolicies = tool.toolPolicies;
+        } else {
+          toolInstance = tool;
+          id = toolInstance.getId();
+        }
+        if (id) {
+          toolRecord[id] = toolInstance;
+        }
+      }
+    }
+    return toolRecord;
+  }
+  getModels() {
+    return this.config.models;
+  }
+  setModels(models) {
+    this.config.models = models;
+  }
+  getTransfers() {
+    return typeof this.config.canTransferTo === "function" ? this.config.canTransferTo() : [];
+  }
+  getSubAgentDelegates() {
+    return typeof this.config.canDelegateTo === "function" ? this.config.canDelegateTo().filter((delegate) => {
+      if (typeof delegate === "object" && "externalAgent" in delegate) {
+        return false;
+      }
+      if (typeof delegate === "object" && "agent" in delegate) {
+        return false;
+      }
+      if (typeof delegate === "object" && "toFullAgentDefinition" in delegate) {
+        return false;
+      }
+      if (typeof delegate === "object" && "type" in delegate && delegate.type === "external") {
+        return false;
+      }
+      return true;
+    }) : [];
+  }
+  getExternalAgentDelegates() {
+    if (typeof this.config.canDelegateTo !== "function") {
+      return [];
+    }
+    return this.config.canDelegateTo().filter((delegate) => {
+      if (typeof delegate === "object" && "externalAgent" in delegate) {
+        return true;
+      }
+      if (typeof delegate === "object" && "type" in delegate && delegate.type === "external") {
+        return true;
+      }
+      return false;
+    }).map((delegate) => {
+      if ("externalAgent" in delegate) {
+        return delegate;
+      }
+      return {
+        externalAgent: delegate,
+        headers: void 0
+      };
+    });
+  }
+  getTeamAgentDelegates() {
+    if (typeof this.config.canDelegateTo !== "function") {
+      return [];
+    }
+    return this.config.canDelegateTo().filter((delegate) => {
+      if (typeof delegate === "object" && "agent" in delegate) {
+        return true;
+      }
+      if (typeof delegate === "object" && "toFullAgentDefinition" in delegate) {
+        return true;
+      }
+      return false;
+    }).map((delegate) => {
+      if ("agent" in delegate) {
+        return delegate;
+      }
+      return {
+        agent: delegate,
+        headers: void 0
+      };
+    });
+  }
+  getDelegates() {
+    return [
+      ...this.getSubAgentDelegates(),
+      ...this.getTeamAgentDelegates(),
+      ...this.getExternalAgentDelegates()
+    ];
+  }
+  getDataComponents() {
+    const components = resolveGetter2(this.config.dataComponents) || [];
+    return components.map((comp) => {
+      if (comp && typeof comp.getId === "function") {
+        return {
+          id: comp.getId(),
+          name: comp.getName(),
+          description: comp.getDescription(),
+          props: comp.getProps(),
+          render: comp.getRender?.() || null
+        };
+      }
+      if (comp && typeof comp === "object" && comp.props && isZodSchema(comp.props)) {
+        return {
+          id: comp.id,
+          name: comp.name,
+          description: comp.description,
+          props: convertZodToJsonSchemaWithPreview(comp.props),
+          render: comp.render || null
+        };
+      }
+      return comp;
+    });
+  }
+  getArtifactComponents() {
+    const components = resolveGetter2(this.config.artifactComponents) || [];
+    return components.map((comp) => {
+      if (comp && typeof comp.getId === "function") {
+        return {
+          id: comp.getId(),
+          name: comp.getName(),
+          description: comp.getDescription(),
+          props: comp.getProps?.() || comp.props
+        };
+      }
+      if (comp && typeof comp === "object" && comp.props && isZodSchema(comp.props)) {
+        return {
+          id: comp.id,
+          name: comp.name,
+          description: comp.description,
+          props: convertZodToJsonSchemaWithPreview(comp.props)
+        };
+      }
+      return comp;
+    });
+  }
+  // adjust
+  addTool(_name, tool) {
+    const existingTools = this.config.canUse ? this.config.canUse() : [];
+    this.config.canUse = () => [...existingTools, tool];
+  }
+  addTransfer(...agents) {
+    if (typeof this.config.canTransferTo === "function") {
+      const existingTransfers = this.config.canTransferTo;
+      this.config.canTransferTo = () => [...existingTransfers(), ...agents];
+    } else {
+      this.config.canTransferTo = () => agents;
+    }
+  }
+  addDelegate(...agents) {
+    if (typeof this.config.canDelegateTo === "function") {
+      const existingDelegates = this.config.canDelegateTo;
+      this.config.canDelegateTo = () => [...existingDelegates(), ...agents];
+    } else {
+      this.config.canDelegateTo = () => agents;
+    }
+  }
+  // Public method to ensure agent exists in backend (with upsert behavior)
+  async init() {
+    if (this.initialized) return;
+    try {
+      await this.upsertAgent();
+      await this.loadDataComponents();
+      await this.loadArtifactComponents();
+      await this.saveToolsAndRelations();
+      await this.saveDataComponents();
+      await this.saveArtifactComponents();
+      logger11.info(
+        {
+          subAgentId: this.getId()
+        },
+        "Agent initialized successfully"
+      );
+      this.initialized = true;
+    } catch (error) {
+      logger11.error(
+        {
+          subAgentId: this.getId(),
+          error: error instanceof Error ? error.message : "Unknown error"
+        },
+        "Failed to initialize agent"
+      );
+      throw error;
+    }
+  }
+  // Private method to upsert agent (create or update)
+  async upsertAgent() {
+    const agentData = {
+      id: this.getId(),
+      name: this.config.name,
+      description: this.config.description || "",
+      prompt: this.config.prompt,
+      conversationHistoryConfig: this.config.conversationHistoryConfig,
+      models: this.config.models,
+      stopWhen: this.config.stopWhen
+    };
+    const updateResponse = await fetch(
+      `${this.baseURL}/tenants/${this.tenantId}/agents/${this.getId()}`,
+      {
+        method: "PUT",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify(agentData)
+      }
+    );
+    if (updateResponse.ok) {
+      logger11.info(
+        {
+          subAgentId: this.getId()
+        },
+        "Agent updated successfully"
+      );
+      return;
+    }
+    if (updateResponse.status === 404) {
+      logger11.info(
+        {
+          subAgentId: this.getId()
+        },
+        "Agent not found, creating new agent"
+      );
+      const createResponse = await fetch(`${this.baseURL}/tenants/${this.tenantId}/agents`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify(agentData)
+      });
+      if (!createResponse.ok) {
+        const errorText2 = await createResponse.text().catch(() => "Unknown error");
+        throw new Error(
+          `Failed to create agent: ${createResponse.status} ${createResponse.statusText} - ${errorText2}`
+        );
+      }
+      logger11.info(
+        {
+          subAgentId: this.getId()
+        },
+        "Agent created successfully"
+      );
+      return;
+    }
+    const errorText = await updateResponse.text().catch(() => "Unknown error");
+    throw new Error(
+      `Failed to update agent: ${updateResponse.status} ${updateResponse.statusText} - ${errorText}`
+    );
+  }
+  async saveToolsAndRelations() {
+    if (this.config.canUse) {
+      const tools = resolveGetter2(this.config.canUse);
+      if (tools && Array.isArray(tools)) {
+        for (let i = 0; i < tools.length; i++) {
+          const toolConfig = tools[i];
+          try {
+            const normalizedTool = normalizeAgentCanUseType(toolConfig, `tool-${i}`);
+            await this.createTool(normalizedTool.toolId, toolConfig);
+          } catch (error) {
+            logger11.error(
+              {
+                toolId: isAgentMcpConfig(toolConfig) ? toolConfig.server.getId() : toolConfig.getId?.(),
+                error: error instanceof Error ? error.message : "Unknown error"
+              },
+              "Tool creation failed"
+            );
+            throw error;
+          }
+        }
+      }
+    }
+  }
+  async saveDataComponents() {
+    logger11.info({ dataComponents: this.config.dataComponents }, "dataComponents and config");
+    const components = resolveGetter2(this.config.dataComponents);
+    if (components) {
+      for (const dataComponent2 of components) {
+        const plainComponent = dataComponent2 && typeof dataComponent2.getId === "function" ? {
+          id: dataComponent2.getId(),
+          name: dataComponent2.getName(),
+          description: dataComponent2.getDescription(),
+          props: dataComponent2.getProps()
+        } : dataComponent2;
+        await this.createDataComponent(plainComponent);
+      }
+    }
+  }
+  async saveArtifactComponents() {
+    logger11.info(
+      { artifactComponents: this.config.artifactComponents },
+      "artifactComponents and config"
+    );
+    const components = resolveGetter2(this.config.artifactComponents);
+    if (components) {
+      for (const artifactComponent2 of components) {
+        const plainComponent = artifactComponent2 && typeof artifactComponent2.getId === "function" ? {
+          id: artifactComponent2.getId(),
+          name: artifactComponent2.getName(),
+          description: artifactComponent2.getDescription(),
+          props: artifactComponent2.getProps?.() || artifactComponent2.props
+        } : artifactComponent2;
+        await this.createArtifactComponent(plainComponent);
+      }
+    }
+  }
+  async loadDataComponents() {
+    try {
+      const existingComponents = [];
+      const dbDataComponents = existingComponents.map((component) => ({
+        id: component.id,
+        name: component.name,
+        description: component.description,
+        props: component.props,
+        createdAt: component.createdAt,
+        updatedAt: component.updatedAt
+      }));
+      const configComponents = resolveGetter2(this.config.dataComponents) || [];
+      const normalizedConfigComponents = configComponents.map((comp) => {
+        if (comp && typeof comp.getId === "function") {
+          return {
+            id: comp.getId(),
+            name: comp.getName(),
+            description: comp.getDescription(),
+            props: comp.getProps()
+          };
+        }
+        return comp;
+      });
+      const allComponents = [...dbDataComponents, ...normalizedConfigComponents];
+      const uniqueComponents = allComponents.reduce((acc, component) => {
+        const componentId = typeof component.getId === "function" ? component.getId() : component.id;
+        const existingIndex = acc.findIndex((c) => {
+          const cId = typeof c.getId === "function" ? c.getId() : c.id;
+          return cId === componentId;
+        });
+        if (existingIndex >= 0) {
+          acc[existingIndex] = component;
+        } else {
+          acc.push(component);
+        }
+        return acc;
+      }, []);
+      this.config.dataComponents = () => uniqueComponents;
+      logger11.info(
+        {
+          subAgentId: this.getId(),
+          dbComponentCount: dbDataComponents.length,
+          configComponentCount: configComponents.length,
+          totalComponentCount: uniqueComponents.length
+        },
+        "Loaded and merged data components"
+      );
+    } catch (error) {
+      logger11.error(
+        {
+          subAgentId: this.getId(),
+          error: error instanceof Error ? error.message : "Unknown error"
+        },
+        "Failed to load data components from database"
+      );
+    }
+  }
+  async loadArtifactComponents() {
+    try {
+      const existingComponents = [];
+      const dbArtifactComponents = existingComponents.map((component) => ({
+        id: component.id,
+        name: component.name,
+        description: component.description,
+        props: component.props,
+        createdAt: component.createdAt,
+        updatedAt: component.updatedAt
+      }));
+      const configComponents = resolveGetter2(this.config.artifactComponents) || [];
+      const normalizedConfigComponents = configComponents.map((comp) => {
+        if (comp && typeof comp.getId === "function") {
+          return {
+            id: comp.getId(),
+            name: comp.getName(),
+            description: comp.getDescription(),
+            props: comp.getProps?.() || comp.props
+          };
+        }
+        return comp;
+      });
+      const allComponents = [...dbArtifactComponents, ...normalizedConfigComponents];
+      const uniqueComponents = allComponents.reduce((acc, component) => {
+        const componentId = typeof component.getId === "function" ? component.getId() : component.id;
+        const existingIndex = acc.findIndex((c) => {
+          const cId = typeof c.getId === "function" ? c.getId() : c.id;
+          return cId === componentId;
+        });
+        if (existingIndex >= 0) {
+          acc[existingIndex] = component;
+        } else {
+          acc.push(component);
+        }
+        return acc;
+      }, []);
+      this.config.artifactComponents = () => uniqueComponents;
+      logger11.info(
+        {
+          subAgentId: this.getId(),
+          dbComponentCount: dbArtifactComponents.length,
+          configComponentCount: configComponents.length,
+          totalComponentCount: uniqueComponents.length
+        },
+        "Loaded and merged artifact components"
+      );
+    } catch (error) {
+      logger11.error(
+        {
+          subAgentId: this.getId(),
+          error: error instanceof Error ? error.message : "Unknown error"
+        },
+        "Failed to load artifact components from database"
+      );
+    }
+  }
+  async createFunctionTool(toolId, functionTool2) {
+    try {
+      const functionData = functionTool2.serializeFunction();
+      const toolData = functionTool2.serializeTool();
+      const functionUrl = `${this.baseURL}/tenants/${this.tenantId}/crud/projects/${this.projectId}/functions`;
+      logger11.info(
+        {
+          agentId: this.getId(),
+          toolId,
+          functionUrl
+        },
+        "Attempting to create global function"
+      );
+      const functionResponse = await fetch(functionUrl, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({
+          id: functionData.id,
+          inputSchema: functionData.inputSchema,
+          executeCode: functionData.executeCode,
+          dependencies: functionData.dependencies
+        })
+      });
+      logger11.info(
+        {
+          agentId: this.getId(),
+          toolId,
+          functionStatus: functionResponse.status,
+          functionStatusText: functionResponse.statusText
+        },
+        "Function creation response received"
+      );
+      if (!functionResponse.ok) {
+        const errorText = await functionResponse.text();
+        logger11.error(
+          {
+            agentId: this.getId(),
+            toolId,
+            functionStatus: functionResponse.status,
+            functionStatusText: functionResponse.statusText,
+            errorText
+          },
+          "Function creation failed"
+        );
+        throw new Error(`Failed to create function: ${functionResponse.status} ${errorText}`);
+      }
+      const toolUrl = `${this.baseURL}/tenants/${this.tenantId}/crud/projects/${this.projectId}/tools`;
+      logger11.info(
+        {
+          agentId: this.getId(),
+          toolId,
+          toolUrl
+        },
+        "Attempting to create function tool"
+      );
+      const toolResponse = await fetch(toolUrl, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({
+          id: toolData.id,
+          name: toolData.name,
+          description: toolData.description,
+          functionId: toolData.functionId,
+          config: {
+            type: "function"
+            // No inline function details - reference via functionId only
+          }
+        })
+      });
+      logger11.info(
+        {
+          agentId: this.getId(),
+          toolId,
+          toolStatus: toolResponse.status,
+          toolStatusText: toolResponse.statusText
+        },
+        "Tool creation response received"
+      );
+      if (!toolResponse.ok) {
+        const errorText = await toolResponse.text();
+        logger11.error(
+          {
+            agentId: this.getId(),
+            toolId,
+            toolStatus: toolResponse.status,
+            toolStatusText: toolResponse.statusText,
+            errorText
+          },
+          "Tool creation failed"
+        );
+        throw new Error(`Failed to create tool: ${toolResponse.status} ${errorText}`);
+      }
+      await this.createAgentToolRelation(toolData.id);
+      logger11.info(
+        {
+          agentId: this.getId(),
+          functionId: functionData.id,
+          toolId: toolData.id
+        },
+        "Function and tool created successfully"
+      );
+    } catch (error) {
+      logger11.error(
+        {
+          agentId: this.getId(),
+          toolId,
+          error: error instanceof Error ? error.message : "Unknown error",
+          stack: error instanceof Error ? error.stack : void 0
+        },
+        "Failed to create function tool"
+      );
+      throw error;
+    }
+  }
+  async createTool(toolId, toolConfig) {
+    try {
+      if (toolConfig instanceof FunctionTool) {
+        await this.createFunctionTool(toolId, toolConfig);
+        return;
+      }
+      if (toolConfig.type === "function") {
+        logger11.info(
+          {
+            subAgentId: this.getId(),
+            toolId
+          },
+          "Skipping function tool creation - will be handled at runtime"
+        );
+        return;
+      }
+      let tool;
+      let selectedTools;
+      let headers;
+      let toolPolicies;
+      try {
+        const normalizedTool = normalizeAgentCanUseType(toolConfig, toolId);
+        tool = normalizedTool.tool;
+        selectedTools = normalizedTool.selectedTools;
+        headers = normalizedTool.headers;
+        toolPolicies = normalizedTool.toolPolicies;
+        tool.setContext(this.tenantId, this.projectId);
+        await tool.init();
+      } catch (_) {
+        tool = new Tool({
+          id: toolId,
+          name: toolConfig.name || toolId,
+          description: toolConfig.description || `MCP tool: ${toolId}`,
+          serverUrl: toolConfig.config?.serverUrl || toolConfig.serverUrl || "http://localhost:3000",
+          activeTools: toolConfig.config?.mcp?.activeTools,
+          credential: toolConfig.credential
+        });
+        tool.setContext(this.tenantId, this.projectId);
+        await tool.init();
+      }
+      await this.createAgentToolRelation(tool.getId(), selectedTools, headers, toolPolicies);
+      logger11.info(
+        {
+          subAgentId: this.getId(),
+          toolId: tool.getId()
+        },
+        "Tool created and linked to agent"
+      );
+    } catch (error) {
+      logger11.error(
+        {
+          subAgentId: this.getId(),
+          toolId,
+          error: error instanceof Error ? error.message : "Unknown error"
+        },
+        "Failed to create tool"
+      );
+      throw error;
+    }
+  }
+  async createDataComponent(dataComponent2) {
+    try {
+      const dc = new DataComponent({
+        id: dataComponent2.id,
+        name: dataComponent2.name,
+        description: dataComponent2.description,
+        props: dataComponent2.props,
+        render: dataComponent2.render
+      });
+      dc.setContext(this.tenantId, this.projectId);
+      await dc.init();
+      await this.createAgentDataComponentRelation(dc.getId());
+      logger11.info(
+        {
+          subAgentId: this.getId(),
+          dataComponentId: dc.getId()
+        },
+        "DataComponent created and linked to agent"
+      );
+    } catch (error) {
+      logger11.error(
+        {
+          subAgentId: this.getId(),
+          dataComponentName: dataComponent2.name,
+          error: error instanceof Error ? error.message : "Unknown error"
+        },
+        "Failed to create data component"
+      );
+      throw error;
+    }
+  }
+  async createArtifactComponent(artifactComponent2) {
+    try {
+      const ac = new ArtifactComponent({
+        id: artifactComponent2.id,
+        name: artifactComponent2.name,
+        description: artifactComponent2.description,
+        props: artifactComponent2.props
+      });
+      ac.setContext(this.tenantId, this.projectId);
+      await ac.init();
+      await this.createAgentArtifactComponentRelation(ac.getId());
+      logger11.info(
+        {
+          subAgentId: this.getId(),
+          artifactComponentId: ac.getId()
+        },
+        "ArtifactComponent created and linked to agent"
+      );
+    } catch (error) {
+      logger11.error(
+        {
+          subAgentId: this.getId(),
+          artifactComponentName: artifactComponent2.name,
+          error: error instanceof Error ? error.message : "Unknown error"
+        },
+        "Failed to create artifact component"
+      );
+      throw error;
+    }
+  }
+  async createAgentDataComponentRelation(dataComponentId) {
+    const relationResponse = await fetch(
+      `${this.baseURL}/tenants/${this.tenantId}/agent-data-components`,
+      {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({
+          id: `${this.getId()}-dc-${dataComponentId}`,
+          tenantId: this.tenantId,
+          subAgentId: this.getId(),
+          dataComponentId
+        })
+      }
+    );
+    if (!relationResponse.ok) {
+      throw new Error(
+        `Failed to create agent-dataComponent relation: ${relationResponse.status} ${relationResponse.statusText}`
+      );
+    }
+    logger11.info(
+      {
+        subAgentId: this.getId(),
+        dataComponentId
+      },
+      "Created agent-dataComponent relation"
+    );
+  }
+  async createAgentArtifactComponentRelation(artifactComponentId) {
+    const relationResponse = await fetch(
+      `${this.baseURL}/tenants/${this.tenantId}/agent-artifact-components`,
+      {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({
+          id: crypto.randomUUID(),
+          tenantId: this.tenantId,
+          subAgentId: this.getId(),
+          artifactComponentId
+        })
+      }
+    );
+    if (!relationResponse.ok) {
+      throw new Error(
+        `Failed to create agent-artifactComponent relation: ${relationResponse.status} ${relationResponse.statusText}`
+      );
+    }
+    logger11.info(
+      {
+        subAgentId: this.getId(),
+        artifactComponentId
+      },
+      "Created agent-artifactComponent relation"
+    );
+  }
+  async createAgentToolRelation(toolId, selectedTools, headers, toolPolicies) {
+    const relationData = {
+      id: `${this.getId()}-tool-${toolId}`,
+      tenantId: this.tenantId,
+      projectId: this.projectId,
+      subAgentId: this.getId(),
+      toolId
+    };
+    if (selectedTools !== void 0) {
+      relationData.selectedTools = selectedTools;
+    }
+    if (headers !== void 0) {
+      relationData.headers = headers;
+    }
+    if (toolPolicies !== void 0 && Object.keys(toolPolicies).length > 0) {
+      relationData.toolPolicies = toolPolicies;
+    }
+    const relationResponse = await fetch(
+      `${this.baseURL}/tenants/${this.tenantId}/projects/${this.projectId}/agent-tool-relations`,
+      {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify(relationData)
+      }
+    );
+    if (!relationResponse.ok) {
+      const errorBody = await relationResponse.text().catch(() => "Unknown error");
+      throw new Error(
+        `Failed to create agent-tool relation: ${relationResponse.status} - ${errorBody}`
+      );
+    }
+  }
+};
+
+// src/builderFunctions.ts
+function agent(config) {
+  return new Agent(config);
+}
+function project(config) {
+  return new Project(config);
+}
+function subAgent(config) {
+  if (!config.id) {
+    throw new Error(
+      "Sub-Agent ID is required. Sub-Agents must have stable IDs for consistency across deployments."
+    );
+  }
+  return new SubAgent(config);
+}
+function credential(config) {
+  try {
+    return CredentialReferenceApiInsertSchema.parse(config);
+  } catch (error) {
+    if (error instanceof Error) {
+      const credId = config.id || "unknown";
+      throw new Error(`Invalid credential '${credId}': ${error.message}`);
+    }
+    throw error;
+  }
+}
+function mcpServer(config) {
+  if (!config.serverUrl) {
+    throw new Error("MCP server requires a serverUrl");
+  }
+  const id = config.id || generateIdFromName(config.name);
+  return new Tool({
+    id,
+    name: config.name,
+    description: config.description,
+    serverUrl: config.serverUrl,
+    credential: config.credential,
+    activeTools: config.activeTools,
+    headers: config.headers,
+    imageUrl: config.imageUrl,
+    transport: config.transport ? { type: config.transport } : void 0
+  });
+}
+function mcpTool(config) {
+  const configWithId = {
+    ...config,
+    id: config.id || generateIdFromName(config.name)
+  };
+  const validatedConfig = MCPToolConfigSchema.parse(configWithId);
+  return new Tool(validatedConfig);
+}
+function artifactComponent(config) {
+  const configWithId = {
+    ...config,
+    id: config.id || generateIdFromName(config.name)
+  };
+  return new ArtifactComponent(configWithId);
+}
+function dataComponent(config) {
+  const configWithId = {
+    ...config,
+    id: config.id || generateIdFromName(config.name)
+  };
+  return new DataComponent(configWithId);
+}
+function statusComponent(config) {
+  return new StatusComponent(config);
+}
+function agentMcp(config) {
+  return {
+    server: config.server,
+    selectedTools: config.selectedTools,
+    headers: config.headers
+  };
+}
+function functionTool(config) {
+  return new FunctionTool(config);
+}
+
+// src/utils/validateFunction.ts
+function validateFunction(value, name) {
+  if (typeof value !== "function") {
+    throw new Error(`${name} must be a function`);
+  }
+}
+
+// src/builders.ts
+var TransferConfigSchema = z.object({
+  agent: z.instanceof(SubAgent),
+  description: z.string().optional()
+});
+function transfer(targetAgent, description, condition) {
+  if (condition !== void 0) {
+    validateFunction(condition, "condition");
+  }
+  const config = {
+    agent: targetAgent,
+    description: description || `Hand off to ${targetAgent.getName()}`,
+    condition
+  };
+  TransferConfigSchema.parse({
+    agent: config.agent,
+    description: config.description
+  });
+  return config;
+}
+
+// src/credential-ref.ts
+function credentialRef(id) {
+  return {
+    __type: "credential-ref",
+    id
+  };
+}
+function isCredentialReference(value) {
+  return value && typeof value === "object" && value.__type === "credential-ref";
+}
+
+// src/environment-settings.ts
+function createEnvironmentSettings(environments) {
+  return {
+    getEnvironmentCredential: (key) => {
+      const currentEnv = process.env.INKEEP_ENV || "development";
+      const env = environments[currentEnv];
+      if (!env) {
+        throw new Error(
+          `Environment '${currentEnv}' not found. Available: ${Object.keys(environments).join(", ")}`
+        );
+      }
+      const credential2 = env.credentials?.[key];
+      if (!credential2) {
+        throw new Error(`Credential '${String(key)}' not found in environment '${currentEnv}'`);
+      }
+      return credential2;
+    },
+    getEnvironmentMcp: (key) => {
+      const currentEnv = process.env.INKEEP_ENV || "development";
+      const env = environments[currentEnv];
+      if (!env) {
+        throw new Error(
+          `Environment '${currentEnv}' not found. Available: ${Object.keys(environments).join(", ")}`
+        );
+      }
+      const mcpServer2 = env.mcpServers?.[key];
+      if (!mcpServer2) {
+        throw new Error(`MCP Server '${String(key)}' not found in environment '${currentEnv}'`);
+      }
+      return mcpServer2;
+    },
+    //Deprecated: Use getEnvironmentCredential instead
+    getEnvironmentSetting: (key) => {
+      const currentEnv = process.env.INKEEP_ENV || "development";
+      const env = environments[currentEnv];
+      if (!env) {
+        throw new Error(
+          `Environment '${currentEnv}' not found. Available: ${Object.keys(environments).join(", ")}`
+        );
+      }
+      const credential2 = env.credentials?.[key];
+      if (!credential2) {
+        throw new Error(`Credential '${String(key)}' not found in environment '${currentEnv}'`);
+      }
+      return credential2;
+    }
+  };
+}
+function registerEnvironmentSettings(config) {
+  return config;
+}
+var logger12 = getLogger("evaluationClient");
+function parseError2(errorText) {
+  try {
+    const errorJson = JSON.parse(errorText);
+    if (errorJson.error) {
+      const { error } = errorJson;
+      return error?.message ?? error;
+    }
+  } catch {
+    if (errorText) {
+      return errorText;
+    }
+  }
+}
+function buildUrl(apiUrl, tenantId, projectId, ...pathSegments) {
+  return `${apiUrl}/tenants/${tenantId}/projects/${projectId}/evaluations/${pathSegments.join("/")}`;
+}
+function buildHeaders(apiKey) {
+  const headers = {
+    "Content-Type": "application/json"
+  };
+  if (apiKey) {
+    headers.Authorization = `Bearer ${apiKey}`;
+  }
+  return headers;
+}
+async function listDatasets(tenantId, projectId, apiUrl, apiKey) {
+  logger12.info({ tenantId, projectId }, "Listing datasets via API");
+  const url = buildUrl(apiUrl, tenantId, projectId, "datasets");
+  try {
+    const response = await apiFetch(url, {
+      method: "GET",
+      headers: buildHeaders(apiKey)
+    });
+    if (!response.ok) {
+      const errorText = await response.text();
+      const errorMessage = parseError2(errorText) ?? `Failed to list datasets: ${response.status} ${response.statusText}`;
+      logger12.error(
+        { status: response.status, error: errorMessage },
+        "Failed to list datasets via API"
+      );
+      throw new Error(errorMessage);
+    }
+    const result = await response.json();
+    return result.data;
+  } catch (error) {
+    logger12.error({ error, tenantId, projectId }, "Failed to list datasets");
+    throw error;
+  }
+}
+async function getDataset(tenantId, projectId, datasetId, apiUrl, apiKey) {
+  logger12.info({ tenantId, projectId, datasetId }, "Getting dataset via API");
+  const url = buildUrl(apiUrl, tenantId, projectId, "datasets", datasetId);
+  try {
+    const response = await apiFetch(url, {
+      method: "GET",
+      headers: buildHeaders(apiKey)
+    });
+    if (!response.ok) {
+      if (response.status === 404) {
+        logger12.info({ datasetId }, "Dataset not found");
+        return null;
+      }
+      const errorText = await response.text();
+      const errorMessage = parseError2(errorText) ?? `Failed to get dataset: ${response.status} ${response.statusText}`;
+      logger12.error(
+        { status: response.status, error: errorMessage },
+        "Failed to get dataset via API"
+      );
+      throw new Error(errorMessage);
+    }
+    const result = await response.json();
+    return result.data;
+  } catch (error) {
+    logger12.error({ error, tenantId, projectId, datasetId }, "Failed to get dataset");
+    throw error;
+  }
+}
+async function createDataset(tenantId, projectId, apiUrl, datasetData, apiKey) {
+  logger12.info({ tenantId, projectId }, "Creating dataset via API");
+  const url = buildUrl(apiUrl, tenantId, projectId, "datasets");
+  try {
+    const response = await apiFetch(url, {
+      method: "POST",
+      headers: buildHeaders(apiKey),
+      body: JSON.stringify(datasetData)
+    });
+    if (!response.ok) {
+      const errorText = await response.text();
+      const errorMessage = parseError2(errorText) ?? `Failed to create dataset: ${response.status} ${response.statusText}`;
+      logger12.error(
+        { status: response.status, error: errorMessage },
+        "Failed to create dataset via API"
+      );
+      throw new Error(errorMessage);
+    }
+    const result = await response.json();
+    logger12.info({ tenantId, projectId }, "Successfully created dataset via API");
+    return result.data;
+  } catch (error) {
+    logger12.error({ error, tenantId, projectId }, "Failed to create dataset");
+    throw error;
+  }
+}
+async function updateDataset(tenantId, projectId, datasetId, apiUrl, updateData, apiKey) {
+  logger12.info({ tenantId, projectId, datasetId }, "Updating dataset via API");
+  const url = buildUrl(apiUrl, tenantId, projectId, "datasets", datasetId);
+  try {
+    const response = await apiFetch(url, {
+      method: "PATCH",
+      headers: buildHeaders(apiKey),
+      body: JSON.stringify(updateData)
+    });
+    if (!response.ok) {
+      const errorText = await response.text();
+      const errorMessage = parseError2(errorText) ?? `Failed to update dataset: ${response.status} ${response.statusText}`;
+      logger12.error(
+        { status: response.status, error: errorMessage },
+        "Failed to update dataset via API"
+      );
+      throw new Error(errorMessage);
+    }
+    const result = await response.json();
+    logger12.info({ tenantId, projectId, datasetId }, "Successfully updated dataset via API");
+    return result.data;
+  } catch (error) {
+    logger12.error({ error, tenantId, projectId, datasetId }, "Failed to update dataset");
+    throw error;
+  }
+}
+async function deleteDataset(tenantId, projectId, datasetId, apiUrl, apiKey) {
+  logger12.info({ tenantId, projectId, datasetId }, "Deleting dataset via API");
+  const url = buildUrl(apiUrl, tenantId, projectId, "datasets", datasetId);
+  try {
+    const response = await apiFetch(url, {
+      method: "DELETE",
+      headers: buildHeaders(apiKey)
+    });
+    if (!response.ok) {
+      const errorText = await response.text();
+      const errorMessage = parseError2(errorText) ?? `Failed to delete dataset: ${response.status} ${response.statusText}`;
+      logger12.error(
+        { status: response.status, error: errorMessage },
+        "Failed to delete dataset via API"
+      );
+      throw new Error(errorMessage);
+    }
+    logger12.info({ tenantId, projectId, datasetId }, "Successfully deleted dataset via API");
+  } catch (error) {
+    logger12.error({ error, tenantId, projectId, datasetId }, "Failed to delete dataset");
+    throw error;
+  }
+}
+async function listDatasetItems(tenantId, projectId, datasetId, apiUrl, apiKey) {
+  logger12.info({ tenantId, projectId, datasetId }, "Listing dataset items via API");
+  const url = buildUrl(apiUrl, tenantId, projectId, "datasets", datasetId, "items");
+  try {
+    const response = await apiFetch(url, {
+      method: "GET",
+      headers: buildHeaders(apiKey)
+    });
+    if (!response.ok) {
+      const errorText = await response.text();
+      const errorMessage = parseError2(errorText) ?? `Failed to list dataset items: ${response.status} ${response.statusText}`;
+      logger12.error(
+        { status: response.status, error: errorMessage },
+        "Failed to list dataset items via API"
+      );
+      throw new Error(errorMessage);
+    }
+    const result = await response.json();
+    return result.data;
+  } catch (error) {
+    logger12.error({ error, tenantId, projectId, datasetId }, "Failed to list dataset items");
+    throw error;
+  }
+}
+async function getDatasetItem(tenantId, projectId, datasetId, itemId, apiUrl, apiKey) {
+  logger12.info({ tenantId, projectId, datasetId, itemId }, "Getting dataset item via API");
+  const url = buildUrl(apiUrl, tenantId, projectId, "datasets", datasetId, "items", itemId);
+  try {
+    const response = await apiFetch(url, {
+      method: "GET",
+      headers: buildHeaders(apiKey)
+    });
+    if (!response.ok) {
+      if (response.status === 404) {
+        logger12.info({ itemId }, "Dataset item not found");
+        return null;
+      }
+      const errorText = await response.text();
+      const errorMessage = parseError2(errorText) ?? `Failed to get dataset item: ${response.status} ${response.statusText}`;
+      logger12.error(
+        { status: response.status, error: errorMessage },
+        "Failed to get dataset item via API"
+      );
+      throw new Error(errorMessage);
+    }
+    const result = await response.json();
+    return result.data;
+  } catch (error) {
+    logger12.error({ error, tenantId, projectId, datasetId, itemId }, "Failed to get dataset item");
+    throw error;
+  }
+}
+async function createDatasetItem(tenantId, projectId, datasetId, apiUrl, itemData, apiKey) {
+  logger12.info({ tenantId, projectId, datasetId }, "Creating dataset item via API");
+  const url = buildUrl(apiUrl, tenantId, projectId, "datasets", datasetId, "items");
+  try {
+    const response = await apiFetch(url, {
+      method: "POST",
+      headers: buildHeaders(apiKey),
+      body: JSON.stringify(itemData)
+    });
+    if (!response.ok) {
+      const errorText = await response.text();
+      const errorMessage = parseError2(errorText) ?? `Failed to create dataset item: ${response.status} ${response.statusText}`;
+      logger12.error(
+        { status: response.status, error: errorMessage },
+        "Failed to create dataset item via API"
+      );
+      throw new Error(errorMessage);
+    }
+    const result = await response.json();
+    logger12.info({ tenantId, projectId, datasetId }, "Successfully created dataset item via API");
+    return result.data;
+  } catch (error) {
+    logger12.error({ error, tenantId, projectId, datasetId }, "Failed to create dataset item");
+    throw error;
+  }
+}
+async function createDatasetItems(tenantId, projectId, datasetId, apiUrl, itemsData, apiKey) {
+  logger12.info(
+    { tenantId, projectId, datasetId, count: itemsData.length },
+    "Creating dataset items via API"
+  );
+  const url = buildUrl(apiUrl, tenantId, projectId, "datasets", datasetId, "items", "bulk");
+  try {
+    const response = await apiFetch(url, {
+      method: "POST",
+      headers: buildHeaders(apiKey),
+      body: JSON.stringify({ items: itemsData })
+    });
+    if (!response.ok) {
+      const errorText = await response.text();
+      const errorMessage = parseError2(errorText) ?? `Failed to create dataset items: ${response.status} ${response.statusText}`;
+      logger12.error(
+        { status: response.status, error: errorMessage },
+        "Failed to create dataset items via API"
+      );
+      throw new Error(errorMessage);
+    }
+    const result = await response.json();
+    logger12.info(
+      { tenantId, projectId, datasetId, count: result.data.length },
+      "Successfully created dataset items via API"
+    );
+    return result.data;
+  } catch (error) {
+    logger12.error({ error, tenantId, projectId, datasetId }, "Failed to create dataset items");
+    throw error;
+  }
+}
+async function updateDatasetItem(tenantId, projectId, datasetId, itemId, apiUrl, updateData, apiKey) {
+  logger12.info({ tenantId, projectId, datasetId, itemId }, "Updating dataset item via API");
+  const url = buildUrl(apiUrl, tenantId, projectId, "datasets", datasetId, "items", itemId);
+  try {
+    const response = await apiFetch(url, {
+      method: "PATCH",
+      headers: buildHeaders(apiKey),
+      body: JSON.stringify(updateData)
+    });
+    if (!response.ok) {
+      const errorText = await response.text();
+      const errorMessage = parseError2(errorText) ?? `Failed to update dataset item: ${response.status} ${response.statusText}`;
+      logger12.error(
+        { status: response.status, error: errorMessage },
+        "Failed to update dataset item via API"
+      );
+      throw new Error(errorMessage);
+    }
+    const result = await response.json();
+    logger12.info(
+      { tenantId, projectId, datasetId, itemId },
+      "Successfully updated dataset item via API"
+    );
+    return result.data;
+  } catch (error) {
+    logger12.error(
+      { error, tenantId, projectId, datasetId, itemId },
+      "Failed to update dataset item"
+    );
+    throw error;
+  }
+}
+async function deleteDatasetItem(tenantId, projectId, datasetId, itemId, apiUrl, apiKey) {
+  logger12.info({ tenantId, projectId, datasetId, itemId }, "Deleting dataset item via API");
+  const url = buildUrl(apiUrl, tenantId, projectId, "datasets", datasetId, "items", itemId);
+  try {
+    const response = await apiFetch(url, {
+      method: "DELETE",
+      headers: buildHeaders(apiKey)
+    });
+    if (!response.ok) {
+      const errorText = await response.text();
+      const errorMessage = parseError2(errorText) ?? `Failed to delete dataset item: ${response.status} ${response.statusText}`;
+      logger12.error(
+        { status: response.status, error: errorMessage },
+        "Failed to delete dataset item via API"
+      );
+      throw new Error(errorMessage);
+    }
+    logger12.info(
+      { tenantId, projectId, datasetId, itemId },
+      "Successfully deleted dataset item via API"
+    );
+  } catch (error) {
+    logger12.error(
+      { error, tenantId, projectId, datasetId, itemId },
+      "Failed to delete dataset item"
+    );
+    throw error;
+  }
+}
+async function listEvaluators(tenantId, projectId, apiUrl, apiKey) {
+  logger12.info({ tenantId, projectId }, "Listing evaluators via API");
+  const url = buildUrl(apiUrl, tenantId, projectId, "evaluators");
+  try {
+    const response = await apiFetch(url, {
+      method: "GET",
+      headers: buildHeaders(apiKey)
+    });
+    if (!response.ok) {
+      const errorText = await response.text();
+      const errorMessage = parseError2(errorText) ?? `Failed to list evaluators: ${response.status} ${response.statusText}`;
+      logger12.error(
+        { status: response.status, error: errorMessage },
+        "Failed to list evaluators via API"
+      );
+      throw new Error(errorMessage);
+    }
+    const result = await response.json();
+    return result.data;
+  } catch (error) {
+    logger12.error({ error, tenantId, projectId }, "Failed to list evaluators");
+    throw error;
+  }
+}
+async function getEvaluator(tenantId, projectId, evaluatorId, apiUrl, apiKey) {
+  logger12.info({ tenantId, projectId, evaluatorId }, "Getting evaluator via API");
+  const url = buildUrl(apiUrl, tenantId, projectId, "evaluators", evaluatorId);
+  try {
+    const response = await apiFetch(url, {
+      method: "GET",
+      headers: buildHeaders(apiKey)
+    });
+    if (!response.ok) {
+      if (response.status === 404) {
+        logger12.info({ evaluatorId }, "Evaluator not found");
+        return null;
+      }
+      const errorText = await response.text();
+      const errorMessage = parseError2(errorText) ?? `Failed to get evaluator: ${response.status} ${response.statusText}`;
+      logger12.error(
+        { status: response.status, error: errorMessage },
+        "Failed to get evaluator via API"
+      );
+      throw new Error(errorMessage);
+    }
+    const result = await response.json();
+    return result.data;
+  } catch (error) {
+    logger12.error({ error, tenantId, projectId, evaluatorId }, "Failed to get evaluator");
+    throw error;
+  }
+}
+async function createEvaluator(tenantId, projectId, apiUrl, evaluatorData, apiKey) {
+  logger12.info({ tenantId, projectId }, "Creating evaluator via API");
+  const url = buildUrl(apiUrl, tenantId, projectId, "evaluators");
+  try {
+    const response = await apiFetch(url, {
+      method: "POST",
+      headers: buildHeaders(apiKey),
+      body: JSON.stringify(evaluatorData)
+    });
+    if (!response.ok) {
+      const errorText = await response.text();
+      const errorMessage = parseError2(errorText) ?? `Failed to create evaluator: ${response.status} ${response.statusText}`;
+      logger12.error(
+        { status: response.status, error: errorMessage },
+        "Failed to create evaluator via API"
+      );
+      throw new Error(errorMessage);
+    }
+    const result = await response.json();
+    logger12.info({ tenantId, projectId }, "Successfully created evaluator via API");
+    return result.data;
+  } catch (error) {
+    logger12.error({ error, tenantId, projectId }, "Failed to create evaluator");
+    throw error;
+  }
+}
+async function updateEvaluator(tenantId, projectId, evaluatorId, apiUrl, updateData, apiKey) {
+  logger12.info({ tenantId, projectId, evaluatorId }, "Updating evaluator via API");
+  const url = buildUrl(apiUrl, tenantId, projectId, "evaluators", evaluatorId);
+  try {
+    const response = await apiFetch(url, {
+      method: "PATCH",
+      headers: buildHeaders(apiKey),
+      body: JSON.stringify(updateData)
+    });
+    if (!response.ok) {
+      const errorText = await response.text();
+      const errorMessage = parseError2(errorText) ?? `Failed to update evaluator: ${response.status} ${response.statusText}`;
+      logger12.error(
+        { status: response.status, error: errorMessage },
+        "Failed to update evaluator via API"
+      );
+      throw new Error(errorMessage);
+    }
+    const result = await response.json();
+    logger12.info({ tenantId, projectId, evaluatorId }, "Successfully updated evaluator via API");
+    return result.data;
+  } catch (error) {
+    logger12.error({ error, tenantId, projectId, evaluatorId }, "Failed to update evaluator");
+    throw error;
+  }
+}
+async function deleteEvaluator(tenantId, projectId, evaluatorId, apiUrl, apiKey) {
+  logger12.info({ tenantId, projectId, evaluatorId }, "Deleting evaluator via API");
+  const url = buildUrl(apiUrl, tenantId, projectId, "evaluators", evaluatorId);
+  try {
+    const response = await apiFetch(url, {
+      method: "DELETE",
+      headers: buildHeaders(apiKey)
+    });
+    if (!response.ok) {
+      const errorText = await response.text();
+      const errorMessage = parseError2(errorText) ?? `Failed to delete evaluator: ${response.status} ${response.statusText}`;
+      logger12.error(
+        { status: response.status, error: errorMessage },
+        "Failed to delete evaluator via API"
+      );
+      throw new Error(errorMessage);
+    }
+    logger12.info({ tenantId, projectId, evaluatorId }, "Successfully deleted evaluator via API");
+  } catch (error) {
+    logger12.error({ error, tenantId, projectId, evaluatorId }, "Failed to delete evaluator");
+    throw error;
+  }
+}
+async function listEvaluationSuiteConfigs(tenantId, projectId, apiUrl, apiKey) {
+  logger12.info({ tenantId, projectId }, "Listing evaluation suite configs via API");
+  const url = buildUrl(apiUrl, tenantId, projectId, "evaluation-suite-configs");
+  try {
+    const response = await apiFetch(url, {
+      method: "GET",
+      headers: buildHeaders(apiKey)
+    });
+    if (!response.ok) {
+      const errorText = await response.text();
+      const errorMessage = parseError2(errorText) ?? `Failed to list evaluation suite configs: ${response.status} ${response.statusText}`;
+      logger12.error(
+        { status: response.status, error: errorMessage },
+        "Failed to list evaluation suite configs via API"
+      );
+      throw new Error(errorMessage);
+    }
+    const result = await response.json();
+    return result.data;
+  } catch (error) {
+    logger12.error({ error, tenantId, projectId }, "Failed to list evaluation suite configs");
+    throw error;
+  }
+}
+async function getEvaluationSuiteConfig(tenantId, projectId, configId, apiUrl, apiKey) {
+  logger12.info({ tenantId, projectId, configId }, "Getting evaluation suite config via API");
+  const url = buildUrl(apiUrl, tenantId, projectId, "evaluation-suite-configs", configId);
+  try {
+    const response = await apiFetch(url, {
+      method: "GET",
+      headers: buildHeaders(apiKey)
+    });
+    if (!response.ok) {
+      if (response.status === 404) {
+        logger12.info({ configId }, "Evaluation suite config not found");
+        return null;
+      }
+      const errorText = await response.text();
+      const errorMessage = parseError2(errorText) ?? `Failed to get evaluation suite config: ${response.status} ${response.statusText}`;
+      logger12.error(
+        { status: response.status, error: errorMessage },
+        "Failed to get evaluation suite config via API"
+      );
+      throw new Error(errorMessage);
+    }
+    const result = await response.json();
+    return result.data;
+  } catch (error) {
+    logger12.error({ error, tenantId, projectId, configId }, "Failed to get evaluation suite config");
+    throw error;
+  }
+}
+async function createEvaluationSuiteConfig(tenantId, projectId, apiUrl, configData, apiKey) {
+  logger12.info({ tenantId, projectId }, "Creating evaluation suite config via API");
+  const url = buildUrl(apiUrl, tenantId, projectId, "evaluation-suite-configs");
+  try {
+    const response = await apiFetch(url, {
+      method: "POST",
+      headers: buildHeaders(apiKey),
+      body: JSON.stringify(configData)
+    });
+    if (!response.ok) {
+      const errorText = await response.text();
+      const errorMessage = parseError2(errorText) ?? `Failed to create evaluation suite config: ${response.status} ${response.statusText}`;
+      logger12.error(
+        { status: response.status, error: errorMessage },
+        "Failed to create evaluation suite config via API"
+      );
+      throw new Error(errorMessage);
+    }
+    const result = await response.json();
+    logger12.info({ tenantId, projectId }, "Successfully created evaluation suite config via API");
+    return result.data;
+  } catch (error) {
+    logger12.error({ error, tenantId, projectId }, "Failed to create evaluation suite config");
+    throw error;
+  }
+}
+async function updateEvaluationSuiteConfig(tenantId, projectId, configId, apiUrl, updateData, apiKey) {
+  logger12.info({ tenantId, projectId, configId }, "Updating evaluation suite config via API");
+  const url = buildUrl(apiUrl, tenantId, projectId, "evaluation-suite-configs", configId);
+  try {
+    const response = await apiFetch(url, {
+      method: "PATCH",
+      headers: buildHeaders(apiKey),
+      body: JSON.stringify(updateData)
+    });
+    if (!response.ok) {
+      const errorText = await response.text();
+      const errorMessage = parseError2(errorText) ?? `Failed to update evaluation suite config: ${response.status} ${response.statusText}`;
+      logger12.error(
+        { status: response.status, error: errorMessage },
+        "Failed to update evaluation suite config via API"
+      );
+      throw new Error(errorMessage);
+    }
+    const result = await response.json();
+    logger12.info(
+      { tenantId, projectId, configId },
+      "Successfully updated evaluation suite config via API"
+    );
+    return result.data;
+  } catch (error) {
+    logger12.error(
+      { error, tenantId, projectId, configId },
+      "Failed to update evaluation suite config"
+    );
+    throw error;
+  }
+}
+async function deleteEvaluationSuiteConfig(tenantId, projectId, configId, apiUrl, apiKey) {
+  logger12.info({ tenantId, projectId, configId }, "Deleting evaluation suite config via API");
+  const url = buildUrl(apiUrl, tenantId, projectId, "evaluation-suite-configs", configId);
+  try {
+    const response = await apiFetch(url, {
+      method: "DELETE",
+      headers: buildHeaders(apiKey)
+    });
+    if (!response.ok) {
+      const errorText = await response.text();
+      const errorMessage = parseError2(errorText) ?? `Failed to delete evaluation suite config: ${response.status} ${response.statusText}`;
+      logger12.error(
+        { status: response.status, error: errorMessage },
+        "Failed to delete evaluation suite config via API"
+      );
+      throw new Error(errorMessage);
+    }
+    logger12.info(
+      { tenantId, projectId, configId },
+      "Successfully deleted evaluation suite config via API"
+    );
+  } catch (error) {
+    logger12.error(
+      { error, tenantId, projectId, configId },
+      "Failed to delete evaluation suite config"
+    );
+    throw error;
+  }
+}
+async function listEvaluationSuiteConfigEvaluators(tenantId, projectId, configId, apiUrl, apiKey) {
+  logger12.info(
+    { tenantId, projectId, configId },
+    "Listing evaluators for evaluation suite config via API"
+  );
+  const url = buildUrl(
+    apiUrl,
+    tenantId,
+    projectId,
+    "evaluation-suite-configs",
+    configId,
+    "evaluators"
+  );
+  try {
+    const response = await apiFetch(url, {
+      method: "GET",
+      headers: buildHeaders(apiKey)
+    });
+    if (!response.ok) {
+      const errorText = await response.text();
+      const errorMessage = parseError2(errorText) ?? `Failed to list evaluators for evaluation suite config: ${response.status} ${response.statusText}`;
+      logger12.error(
+        { status: response.status, error: errorMessage },
+        "Failed to list evaluators for evaluation suite config via API"
+      );
+      throw new Error(errorMessage);
+    }
+    const result = await response.json();
+    return result.data;
+  } catch (error) {
+    logger12.error(
+      { error, tenantId, projectId, configId },
+      "Failed to list evaluators for evaluation suite config"
+    );
+    throw error;
+  }
+}
+async function addEvaluatorToSuiteConfig(tenantId, projectId, configId, evaluatorId, apiUrl, apiKey) {
+  logger12.info(
+    { tenantId, projectId, configId, evaluatorId },
+    "Adding evaluator to evaluation suite config via API"
+  );
+  const url = buildUrl(
+    apiUrl,
+    tenantId,
+    projectId,
+    "evaluation-suite-configs",
+    configId,
+    "evaluators",
+    evaluatorId
+  );
+  try {
+    const response = await apiFetch(url, {
+      method: "POST",
+      headers: buildHeaders(apiKey)
+    });
+    if (!response.ok) {
+      const errorText = await response.text();
+      const errorMessage = parseError2(errorText) ?? `Failed to add evaluator to evaluation suite config: ${response.status} ${response.statusText}`;
+      logger12.error(
+        { status: response.status, error: errorMessage },
+        "Failed to add evaluator to evaluation suite config via API"
+      );
+      throw new Error(errorMessage);
+    }
+    const result = await response.json();
+    logger12.info(
+      { tenantId, projectId, configId, evaluatorId },
+      "Successfully added evaluator to evaluation suite config via API"
+    );
+    return result.data;
+  } catch (error) {
+    logger12.error(
+      { error, tenantId, projectId, configId, evaluatorId },
+      "Failed to add evaluator to evaluation suite config"
+    );
+    throw error;
+  }
+}
+async function removeEvaluatorFromSuiteConfig(tenantId, projectId, configId, evaluatorId, apiUrl, apiKey) {
+  logger12.info(
+    { tenantId, projectId, configId, evaluatorId },
+    "Removing evaluator from evaluation suite config via API"
+  );
+  const url = buildUrl(
+    apiUrl,
+    tenantId,
+    projectId,
+    "evaluation-suite-configs",
+    configId,
+    "evaluators",
+    evaluatorId
+  );
+  try {
+    const response = await apiFetch(url, {
+      method: "DELETE",
+      headers: buildHeaders(apiKey)
+    });
+    if (!response.ok) {
+      const errorText = await response.text();
+      const errorMessage = parseError2(errorText) ?? `Failed to remove evaluator from evaluation suite config: ${response.status} ${response.statusText}`;
+      logger12.error(
+        { status: response.status, error: errorMessage },
+        "Failed to remove evaluator from evaluation suite config via API"
+      );
+      throw new Error(errorMessage);
+    }
+    logger12.info(
+      { tenantId, projectId, configId, evaluatorId },
+      "Successfully removed evaluator from evaluation suite config via API"
+    );
+  } catch (error) {
+    logger12.error(
+      { error, tenantId, projectId, configId, evaluatorId },
+      "Failed to remove evaluator from evaluation suite config"
+    );
+    throw error;
+  }
+}
+async function getEvaluationResult(tenantId, projectId, resultId, apiUrl, apiKey) {
+  logger12.info({ tenantId, projectId, resultId }, "Getting evaluation result via API");
+  const url = buildUrl(apiUrl, tenantId, projectId, "evaluation-results", resultId);
+  try {
+    const response = await apiFetch(url, {
+      method: "GET",
+      headers: buildHeaders(apiKey)
+    });
+    if (!response.ok) {
+      if (response.status === 404) {
+        logger12.info({ resultId }, "Evaluation result not found");
+        return null;
+      }
+      const errorText = await response.text();
+      const errorMessage = parseError2(errorText) ?? `Failed to get evaluation result: ${response.status} ${response.statusText}`;
+      logger12.error(
+        { status: response.status, error: errorMessage },
+        "Failed to get evaluation result via API"
+      );
+      throw new Error(errorMessage);
+    }
+    const result = await response.json();
+    return result.data;
+  } catch (error) {
+    logger12.error({ error, tenantId, projectId, resultId }, "Failed to get evaluation result");
+    throw error;
+  }
+}
+async function createEvaluationResult(tenantId, projectId, apiUrl, resultData, apiKey) {
+  logger12.info({ tenantId, projectId }, "Creating evaluation result via API");
+  const url = buildUrl(apiUrl, tenantId, projectId, "evaluation-results");
+  try {
+    const response = await apiFetch(url, {
+      method: "POST",
+      headers: buildHeaders(apiKey),
+      body: JSON.stringify(resultData)
+    });
+    if (!response.ok) {
+      const errorText = await response.text();
+      const errorMessage = parseError2(errorText) ?? `Failed to create evaluation result: ${response.status} ${response.statusText}`;
+      logger12.error(
+        { status: response.status, error: errorMessage },
+        "Failed to create evaluation result via API"
+      );
+      throw new Error(errorMessage);
+    }
+    const result = await response.json();
+    logger12.info({ tenantId, projectId }, "Successfully created evaluation result via API");
+    return result.data;
+  } catch (error) {
+    logger12.error({ error, tenantId, projectId }, "Failed to create evaluation result");
+    throw error;
+  }
+}
+async function updateEvaluationResult(tenantId, projectId, resultId, apiUrl, updateData, apiKey) {
+  logger12.info({ tenantId, projectId, resultId }, "Updating evaluation result via API");
+  const url = buildUrl(apiUrl, tenantId, projectId, "evaluation-results", resultId);
+  try {
+    const response = await apiFetch(url, {
+      method: "PATCH",
+      headers: buildHeaders(apiKey),
+      body: JSON.stringify(updateData)
+    });
+    if (!response.ok) {
+      const errorText = await response.text();
+      const errorMessage = parseError2(errorText) ?? `Failed to update evaluation result: ${response.status} ${response.statusText}`;
+      logger12.error(
+        { status: response.status, error: errorMessage },
+        "Failed to update evaluation result via API"
+      );
+      throw new Error(errorMessage);
+    }
+    const result = await response.json();
+    logger12.info(
+      { tenantId, projectId, resultId },
+      "Successfully updated evaluation result via API"
+    );
+    return result.data;
+  } catch (error) {
+    logger12.error({ error, tenantId, projectId, resultId }, "Failed to update evaluation result");
+    throw error;
+  }
+}
+async function deleteEvaluationResult(tenantId, projectId, resultId, apiUrl, apiKey) {
+  logger12.info({ tenantId, projectId, resultId }, "Deleting evaluation result via API");
+  const url = buildUrl(apiUrl, tenantId, projectId, "evaluation-results", resultId);
+  try {
+    const response = await apiFetch(url, {
+      method: "DELETE",
+      headers: buildHeaders(apiKey)
+    });
+    if (!response.ok) {
+      const errorText = await response.text();
+      const errorMessage = parseError2(errorText) ?? `Failed to delete evaluation result: ${response.status} ${response.statusText}`;
+      logger12.error(
+        { status: response.status, error: errorMessage },
+        "Failed to delete evaluation result via API"
+      );
+      throw new Error(errorMessage);
+    }
+    logger12.info(
+      { tenantId, projectId, resultId },
+      "Successfully deleted evaluation result via API"
+    );
+  } catch (error) {
+    logger12.error({ error, tenantId, projectId, resultId }, "Failed to delete evaluation result");
+    throw error;
+  }
+}
+var logger13 = getLogger("external-agent-builder");
+var ExternalAgent = class {
+  constructor(config) {
+    __publicField(this, "config");
+    __publicField(this, "type", "external");
+    __publicField(this, "initialized", false);
+    __publicField(this, "tenantId");
+    __publicField(this, "projectId");
+    __publicField(this, "baseURL");
+    this.config = { ...config, type: "external" };
+    this.tenantId = "default";
+    this.projectId = "default";
+    this.baseURL = this.config.baseUrl;
+    logger13.debug(
+      {
+        externalAgentName: this.config.name,
+        baseUrl: this.config.baseUrl,
+        tenantId: this.tenantId
+      },
+      "External Agent constructor initialized"
+    );
+  }
+  /**
+   * Initialize the external agent by upserting it in the database
+   */
+  async init() {
+    if (this.initialized) return;
+    try {
+      await this.upsertExternalAgent();
+      logger13.info(
+        {
+          externalSubAgentId: this.getId()
+        },
+        "External agent initialized successfully"
+      );
+      this.initialized = true;
+    } catch (error) {
+      logger13.error(
+        {
+          externalSubAgentId: this.getId(),
+          error: error instanceof Error ? error.message : "Unknown error"
+        },
+        "Failed to initialize external agent"
+      );
+      throw error;
+    }
+  }
+  // Set context (tenantId and baseURL) from external source (agent, CLI, etc)
+  setContext(tenantId, projectId) {
+    this.tenantId = tenantId;
+    this.projectId = projectId;
+  }
+  // Compute ID from name using a simple slug transformation
+  getId() {
+    return this.config.id;
+  }
+  with(options) {
+    return {
+      externalAgent: this,
+      headers: options.headers
+    };
+  }
+  // Private method to upsert external agent (create or update)
+  async upsertExternalAgent() {
+    const externalAgentData = {
+      id: this.getId(),
+      name: this.config.name,
+      description: this.config.description,
+      baseUrl: this.config.baseUrl,
+      credentialReferenceId: this.config.credentialReference?.id || void 0
+    };
+    const updateResponse = await fetch(
+      `${this.baseURL}/tenants/${this.tenantId}/projects/${this.projectId}/external-agents/${this.getId()}`,
+      {
+        method: "PUT",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify(externalAgentData)
+      }
+    );
+    if (updateResponse.ok) {
+      logger13.info(
+        {
+          externalSubAgentId: this.getId()
+        },
+        "External agent updated successfully"
+      );
+      return;
+    }
+    if (updateResponse.status === 404) {
+      logger13.info(
+        {
+          externalSubAgentId: this.getId()
+        },
+        "External agent not found, creating new external agent"
+      );
+      const createResponse = await fetch(
+        `${this.baseURL}/tenants/${this.tenantId}/projects/${this.projectId}/external-agents`,
+        {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json"
+          },
+          body: JSON.stringify(externalAgentData)
+        }
+      );
+      if (!createResponse.ok) {
+        const errorText2 = await createResponse.text().catch(() => "Unknown error");
+        throw new Error(
+          `Failed to create external agent: ${createResponse.status} ${createResponse.statusText} - ${errorText2}`
+        );
+      }
+      logger13.info(
+        {
+          externalSubAgentId: this.getId()
+        },
+        "External agent created successfully"
+      );
+      return;
+    }
+    const errorText = await updateResponse.text().catch(() => "Unknown error");
+    throw new Error(
+      `Failed to update external agent: ${updateResponse.status} ${updateResponse.statusText} - ${errorText}`
+    );
+  }
+  /**
+   * Get the external agent configuration
+   */
+  getConfig() {
+    return { ...this.config };
+  }
+  /**
+   * Get the external agent name
+   */
+  getName() {
+    return this.config.name;
+  }
+  /**
+   * Get the external agent base URL
+   */
+  getBaseUrl() {
+    return this.config.baseUrl;
+  }
+  /**
+   * Get the tenant ID
+   */
+  getTenantId() {
+    return this.tenantId;
+  }
+  getDescription() {
+    return this.config.description || "";
+  }
+  getCredentialReferenceId() {
+    return this.config.credentialReference?.id || void 0;
+  }
+  getCredentialReference() {
+    return this.config.credentialReference || void 0;
+  }
+};
+function externalAgent(config) {
+  return new ExternalAgent(config);
+}
+function externalAgents(configs) {
+  const builders = {};
+  for (const [name, config] of Object.entries(configs)) {
+    builders[name] = externalAgent(config);
+  }
+  return builders;
+}
+
+// src/types.ts
+var AgentError = class extends Error {
+  constructor(message, code, details) {
+    super(message);
+    this.code = code;
+    this.details = details;
+    this.name = "AgentError";
+  }
+};
+var MaxTurnsExceededError = class extends AgentError {
+  constructor(maxTurns) {
+    super(`Maximum turns (${maxTurns}) exceeded`);
+    this.code = "MAX_TURNS_EXCEEDED";
+  }
+};
+
+// src/runner.ts
+var logger14 = getLogger("runner");
+var Runner = class _Runner {
+  /**
+   * Run an agent until completion, handling transfers and tool calls
+   * Similar to OpenAI's Runner.run() pattern
+   * NOTE: This now requires an agent instead of an agent
+   */
+  static async run(agent2, messages, options) {
+    const maxTurns = options?.maxTurns || 10;
+    let turnCount = 0;
+    const messageHistory = _Runner.normalizeToMessageHistory(messages);
+    const allToolCalls = [];
+    logger14.info(
+      {
+        agentId: agent2.getId(),
+        defaultSubAgent: agent2.getDefaultSubAgent()?.getName(),
+        maxTurns,
+        initialMessageCount: messageHistory.length
+      },
+      "Starting agent run"
+    );
+    while (turnCount < maxTurns) {
+      logger14.debug(
+        {
+          agentId: agent2.getId(),
+          turnCount,
+          messageHistoryLength: messageHistory.length
+        },
+        "Starting turn"
+      );
+      const response = await agent2.generate(messageHistory, options);
+      turnCount++;
+      logger14.info(
+        {
+          agentId: agent2.getId(),
+          turnCount,
+          responseLength: response.length
+        },
+        "Agent generation completed"
+      );
+      return {
+        finalOutput: response,
+        agent: agent2.getDefaultSubAgent() || {},
+        turnCount,
+        usage: { inputTokens: 0, outputTokens: 0 },
+        metadata: {
+          toolCalls: allToolCalls,
+          transfers: []
+          // Agent handles transfers internally
+        }
+      };
+    }
+    logger14.error(
+      {
+        agentId: agent2.getId(),
+        maxTurns,
+        finalTurnCount: turnCount
+      },
+      "Maximum turns exceeded"
+    );
+    throw new MaxTurnsExceededError(maxTurns);
+  }
+  /**
+   * Stream an agent's response
+   */
+  static async stream(agent2, messages, options) {
+    logger14.info(
+      {
+        agentId: agent2.getId(),
+        defaultSubAgent: agent2.getDefaultSubAgent()?.getName()
+      },
+      "Starting agent stream"
+    );
+    return agent2.stream(messages, options);
+  }
+  /**
+   * Execute multiple agent in parallel and return the first successful result
+   */
+  static async raceAgents(agent2, messages, options) {
+    if (agent2.length === 0) {
+      throw new Error("No agent provided for race");
+    }
+    logger14.info(
+      {
+        agentCount: agent2.length,
+        agentIds: agent2.map((g) => g.getId())
+      },
+      "Starting agent race"
+    );
+    const promises = agent2.map(async (agent3, index) => {
+      try {
+        const result2 = await _Runner.run(agent3, messages, options);
+        return { ...result2, raceIndex: index };
+      } catch (error) {
+        logger14.error(
+          {
+            agentId: agent3.getId(),
+            error: error instanceof Error ? error.message : "Unknown error"
+          },
+          "Agent failed in race"
+        );
+        throw error;
+      }
+    });
+    const result = await Promise.race(promises);
+    logger14.info(
+      {
+        winningAgentId: result.agentId || "unknown",
+        raceIndex: result.raceIndex
+      },
+      "Agent race completed"
+    );
+    return result;
+  }
+  // Private helper methods
+  static normalizeToMessageHistory(messages) {
+    if (typeof messages === "string") {
+      return [{ role: "user", content: messages }];
+    }
+    if (Array.isArray(messages)) {
+      return messages.map(
+        (msg) => typeof msg === "string" ? { role: "user", content: msg } : msg
+      );
+    }
+    return [messages];
+  }
+  /**
+   * Validate agent configuration before running
+   */
+  static validateAgent(agent2) {
+    const errors = [];
+    if (!agent2.getId()) {
+      errors.push("Agent ID is required");
+    }
+    const defaultSubAgent = agent2.getDefaultSubAgent();
+    if (!defaultSubAgent) {
+      errors.push("Default agent is required");
+    } else {
+      if (!defaultSubAgent.getName()) {
+        errors.push("Default agent name is required");
+      }
+      if (!defaultSubAgent.getInstructions()) {
+        errors.push("Default agent instructions are required");
+      }
+    }
+    const subAgents = agent2.getSubAgents();
+    if (subAgents.length === 0) {
+      errors.push("Agent must contain at least one subagent");
+    }
+    for (const subAgent2 of subAgents) {
+      if (!subAgent2.getName()) {
+        errors.push(`Agent missing name`);
+      }
+    }
+    return {
+      valid: errors.length === 0,
+      errors
+    };
+  }
+  /**
+   * Get execution statistics for an agent
+   */
+  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
+      subAgentCount: subAgents.length,
+      defaultSubAgent: defaultSubAgent?.getName()
+    };
+  }
+};
+var run = Runner.run.bind(Runner);
+var stream = Runner.stream.bind(Runner);
+var raceAgents = Runner.raceAgents.bind(Runner);
+
+export { ArtifactComponent, DataComponent, ExternalAgent, FunctionTool, Project, Runner, StatusComponent, SubAgent, Tool, addEvaluatorToSuiteConfig, agent, agentMcp, artifactComponent, createDataset, createDatasetItem, createDatasetItems, createEnvironmentSettings, createEvaluationResult, createEvaluationSuiteConfig, createEvaluator, createFullProjectViaAPI, credential, credentialRef, dataComponent, deleteDataset, deleteDatasetItem, deleteEvaluationResult, deleteEvaluationSuiteConfig, deleteEvaluator, deleteFullProjectViaAPI, externalAgent, externalAgents, functionTool, getDataset, getDatasetItem, getEvaluationResult, getEvaluationSuiteConfig, getEvaluator, getFullProjectViaAPI, isCredentialReference, listDatasetItems, listDatasets, listEvaluationSuiteConfigEvaluators, listEvaluationSuiteConfigs, listEvaluators, mcpServer, mcpTool, project, raceAgents, registerEnvironmentSettings, removeEvaluatorFromSuiteConfig, run, statusComponent, stream, subAgent, transfer, updateDataset, updateDatasetItem, updateEvaluationResult, updateEvaluationSuiteConfig, updateEvaluator, updateFullProjectViaAPI };