@botpress/adk 1.17.0 → 1.18.0-beta.2

package/dist/index.js

@@ -22,12 +22,15 @@ var init_types = __esm(() => {
     integrationInterfaceAlias: z.string().optional()
   });
   dependenciesSchema = z.object({
-    integrations: z.record(z.object({
-      version: z.string(),
-      enabled: z.boolean(),
-      configurationType: z.string().optional(),
-      config: z.record(z.any()).optional()
-    })).optional(),
+    integrations: z.record(z.union([
+      z.string(),
+      z.object({
+        version: z.string(),
+        enabled: z.boolean(),
+        configurationType: z.string().optional(),
+        config: z.record(z.any()).optional()
+      })
+    ])).optional(),
     plugins: z.record(z.object({
       version: z.string(),
       config: z.record(z.any()).optional(),
@@ -41,6 +44,9 @@ var init_types = __esm(() => {
     devId: z.string().optional().describe("The development ID used during local development")
   });
   agentLocalInfoSchema = z.object({
+    botId: z.string().optional().describe("The bot ID (overrides agent.json for local development)"),
+    workspaceId: z.string().optional().describe("The workspace ID (overrides agent.json for local development)"),
+    apiUrl: z.string().optional().describe("The Botpress API URL (overrides agent.json for local development)"),
     devId: z.string().optional().describe("The development bot ID used during local development")
   });
   ((ValidationErrorCode2) => {
@@ -470,9 +476,46 @@ var init_constants = __esm(() => {
 // src/agent-project/agent-resolver.ts
 import fs from "fs/promises";
 import path from "path";
+async function readLocalInfo(agentPath) {
+  const localPath = path.join(agentPath, "agent.local.json");
+  try {
+    const localContent = await fs.readFile(localPath, "utf-8");
+    const localData = JSON.parse(localContent);
+    const localResult = agentLocalInfoSchema.safeParse(localData);
+    if (!localResult.success) {
+      const issue = localResult.error.errors[0];
+      throw ValidationErrors.warning(`agent.local.json has an invalid field: ${issue?.path.join(".")} — ${issue?.message}`, "agent.local.json");
+    }
+    return localResult.data;
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return null;
+    }
+    if (ValidationErrors.isValidationError(error)) {
+      throw error;
+    }
+    throw ValidationErrors.warning(`Failed to read agent.local.json: ${error.message}`, "agent.local.json");
+  }
+}
+function applyLocalOverrides(agentInfo, localInfo) {
+  if (localInfo.botId) {
+    agentInfo.botId = localInfo.botId;
+  }
+  if (localInfo.workspaceId) {
+    agentInfo.workspaceId = localInfo.workspaceId;
+  }
+  if (localInfo.apiUrl) {
+    agentInfo.apiUrl = localInfo.apiUrl;
+  }
+  if (localInfo.devId) {
+    agentInfo.devId = localInfo.devId;
+  }
+}
 async function resolveAgent(agentPath, options = {}) {
   const { required = false, requireWorkspace = false, requireBot = false } = options;
   const agentJsonPath = path.join(agentPath, "agent.json");
+  const localInfo = await readLocalInfo(agentPath);
+  let agentInfo = null;
   try {
     const agentJsonContent = await fs.readFile(agentJsonPath, "utf-8");
     let agentData;
@@ -486,38 +529,42 @@ async function resolveAgent(agentPath, options = {}) {
       const zodError = validationResult.error.errors[0];
       throw ValidationErrors.invalidConfigSchema("agent.json", zodError?.path.join(".") || "unknown", zodError?.message || "Invalid schema");
     }
-    const agentInfo = validationResult.data;
-    if (!agentInfo.apiUrl) {
-      agentInfo.apiUrl = DEFAULT_API_URL;
-    }
-    const localPath = path.join(agentPath, "agent.local.json");
-    try {
-      const localContent = await fs.readFile(localPath, "utf-8");
-      const localData = JSON.parse(localContent);
-      const localResult = agentLocalInfoSchema.safeParse(localData);
-      if (localResult.success && localResult.data.devId) {
-        agentInfo.devId = localResult.data.devId;
-      }
-    } catch {}
-    if (requireWorkspace && !agentInfo.workspaceId) {
-      throw ValidationErrors.workspaceIdMissing();
-    }
-    if (requireBot && !agentInfo.botId) {
-      throw ValidationErrors.botIdMissing();
-    }
-    return agentInfo;
+    agentInfo = validationResult.data;
   } catch (error) {
-    if (error.code === "ENOENT") {
-      if (required || requireWorkspace || requireBot) {
-        throw ValidationErrors.requiredFileMissing("agent.json");
-      }
+    if (error.code === "ENOENT") {} else if (ValidationErrors.isValidationError(error)) {
+      throw error;
+    } else {
+      throw ValidationErrors.warning(`Failed to read agent.json: ${error.message}`, "agent.json");
+    }
+  }
+  if (!agentInfo) {
+    if (localInfo?.botId && localInfo?.workspaceId) {
+      agentInfo = {
+        botId: localInfo.botId,
+        workspaceId: localInfo.workspaceId,
+        apiUrl: localInfo.apiUrl,
+        devId: localInfo.devId
+      };
+    } else if (required || requireWorkspace || requireBot) {
+      throw ValidationErrors.requiredFileMissing("agent.json or agent.local.json");
+    } else {
       return null;
     }
-    if (ValidationErrors.isValidationError(error)) {
-      throw error;
+  } else {
+    if (localInfo) {
+      applyLocalOverrides(agentInfo, localInfo);
     }
-    throw ValidationErrors.warning(`Failed to read agent.json: ${error.message}`, "agent.json");
   }
+  if (!agentInfo.apiUrl) {
+    agentInfo.apiUrl = DEFAULT_API_URL;
+  }
+  if (requireWorkspace && !agentInfo.workspaceId) {
+    throw ValidationErrors.workspaceIdMissing();
+  }
+  if (requireBot && !agentInfo.botId) {
+    throw ValidationErrors.botIdMissing();
+  }
+  return agentInfo;
 }
 var init_agent_resolver = __esm(() => {
   init_types();
@@ -694,7 +741,6 @@ class CredentialsManager {
       const store = await this.readCredentials();
       const matchingCredentials = this.findProfileByApiUrl(store, agentApiUrl);
       if (matchingCredentials) {
-        console.info(`Using profile matching agent.json API URL (${agentApiUrl})`);
         baseCredentials = matchingCredentials;
       } else {
         const profileName = store.currentProfile || "default";
@@ -776,7 +822,7 @@ var _format = null, _formatLoaded = false, formatCode = async (code, filepath) =
 `));
     return code;
   }
-}, ADK_VERSION = "1.17.0", relative2 = (from, to) => {
+}, ADK_VERSION = "1.18.0-beta.2", relative2 = (from, to) => {
   const fromDir = path10.dirname(from);
   const relative3 = path10.relative(fromDir, to);
   return relative3.startsWith(".") ? relative3 : `./${relative3}`;
@@ -907,7 +953,7 @@ var init_integration_action_types = __esm(() => {
 var require_package = __commonJS((exports, module) => {
   module.exports = {
     name: "@botpress/adk",
-    version: "1.17.0",
+    version: "1.18.0-beta.2",
     description: "Core ADK library for building AI agents on Botpress",
     keywords: [
       "adk",
@@ -952,12 +998,12 @@ var require_package = __commonJS((exports, module) => {
       "check:type": "tsc --noEmit"
     },
     dependencies: {
-      "@botpress/chat": "0.5.5",
-      "@botpress/cli": "6.2.2",
-      "@botpress/client": "1.38.1",
-      "@botpress/cognitive": "0.4.2",
-      "@botpress/runtime": "^1.17.0",
-      "@botpress/sdk": "6.3.1",
+      "@botpress/chat": "~0.5.5",
+      "@botpress/cli": "~6.3.2",
+      "@botpress/client": "~1.39.0",
+      "@botpress/cognitive": "~0.5.2",
+      "@botpress/runtime": "^1.18.0-beta.2",
+      "@botpress/sdk": "~6.4.4",
       "@bpinternal/jex": "^1.2.4",
       "@bpinternal/yargs-extra": "^0.0.21",
       "@parcel/watcher": "^2.5.1",
@@ -970,14 +1016,6 @@ var require_package = __commonJS((exports, module) => {
       semver: "^7.7.2",
       "ts-morph": "^27.0.2"
     },
-    devDependencies: {
-      "@bpinternal/zui": "2.1.0",
-      "@types/debug": "^4.1.12",
-      "@types/glob": "^9.0.0",
-      "@types/luxon": "^3.7.1",
-      "@types/semver": "^7.7.1",
-      dotenv: "^17.2.3"
-    },
     peerDependencies: {
       typescript: ">=4.5.0"
     },
@@ -1204,7 +1242,7 @@ import os3 from "os";
 import path4 from "path";
 import createDebug from "debug";
 var debug = createDebug("adk:bp-cli");
-var BP_CLI_VERSION = "6.2.2";
+var BP_CLI_VERSION = "6.3.2";
 var BP_CLI_INSTALL_ALL = path4.join(os3.homedir(), ".adk", `bp-cli`);
 var BP_CLI_INSTALL_DIR = path4.join(BP_CLI_INSTALL_ALL, BP_CLI_VERSION);
 var BP_CLI_BIN_PATH = path4.join(BP_CLI_INSTALL_DIR, "node_modules", "@botpress", "cli", "bin.js");
@@ -2266,7 +2304,7 @@ function getChatClient(cwd = process.cwd()) {
 }
 // src/utils/json-ordering.ts
 var agentInfoKeyOrder = ["botId", "workspaceId", "apiUrl"];
-var agentLocalInfoKeyOrder = ["devId"];
+var agentLocalInfoKeyOrder = ["botId", "workspaceId", "apiUrl", "devId"];
 var dependenciesKeyOrder = ["integrations"];
 var integrationKeyOrder = ["version", "enabled", "configurationType", "config"];
 function orderKeys(obj, keyOrder) {
@@ -2317,6 +2355,7 @@ function stringifyWithOrder(obj, keyOrder, space = 2) {
 }
 // src/agent-project/agent-project.ts
 import { BuiltInActions, BuiltInWorkflows, Errors as Errors2, Primitives as Primitives2, setAdkCommand } from "@botpress/runtime/internal";
+import { Autonomous } from "@botpress/runtime";
 import createDebug2 from "debug";
 import { createRequire as createRequire3 } from "module";
 import fs10 from "fs/promises";
@@ -2935,7 +2974,8 @@ class IntegrationParser {
           errors.push(ValidationErrors.invalidIntegrationAlias(alias));
           continue;
         }
-        const ref = this.parseIntegrationRef(value.version);
+        const normalized = typeof value === "string" ? { version: value } : value;
+        const ref = this.parseIntegrationRef(normalized.version);
         const versionResult = versionSchema.safeParse(ref.version);
         if (!versionResult.success) {
           errors.push(ValidationErrors.invalidVersionFormat(alias, ref.version));
@@ -2943,9 +2983,9 @@ class IntegrationParser {
         integrations.push({
           alias,
           ref,
-          enabled: value.enabled,
-          configurationType: value.configurationType,
-          config: value.config
+          enabled: "enabled" in normalized ? normalized.enabled : undefined,
+          configurationType: "configurationType" in normalized ? normalized.configurationType : undefined,
+          config: "config" in normalized ? normalized.config : undefined
         });
       } catch (error) {
         errors.push(ValidationErrors.invalidDependenciesSyntax(`Invalid integration '${alias}': ${error instanceof Error ? error.message : String(error)}`));
@@ -3262,7 +3302,7 @@ class IntegrationManager {
       return { valid: false, errors, warnings };
     }
     const hasChannels = integration.definition.channels && Object.keys(integration.definition.channels).length > 0;
-    if (!integration.config) {
+    if (!integration.config && integration.enabled !== undefined) {
       let requiresConfig = false;
       if (integration.definition.configurations) {
         requiresConfig = Object.values(integration.definition.configurations).some((config) => config.identifier?.required === true);
@@ -3532,6 +3572,7 @@ class HubCache {
 // src/agent-project/config-writer.ts
 init_utils();
 import { Project, SyntaxKind } from "ts-morph";
+import { readFileSync } from "fs";
 import * as path11 from "path";
 
 class ConfigWriter {
@@ -3541,7 +3582,9 @@ class ConfigWriter {
   }
   loadConfig() {
     const project = new Project;
-    const sourceFile = project.addSourceFileAtPath(this.configPath);
+    const sourceFile = project.createSourceFile(this.configPath, readFileSync(this.configPath, "utf-8"), {
+      overwrite: true
+    });
     const defineConfigCall = sourceFile.getDescendantsOfKind(SyntaxKind.CallExpression).find((call) => {
       return call.getExpression().getText() === "defineConfig";
     });
@@ -3561,6 +3604,47 @@ class ConfigWriter {
     sourceFile.replaceWithText(formatted);
     await sourceFile.save();
   }
+  serializeDefaultModelSelection(value) {
+    if (Array.isArray(value)) {
+      return `[${value.map((entry) => `'${entry.replace(/'/g, "\\'")}'`).join(", ")}]`;
+    }
+    return `'${value.replace(/'/g, "\\'")}'`;
+  }
+  getIntegrationConfigMigrationCandidates() {
+    const { sourceFile, configObject } = this.loadConfig();
+    const dependenciesProp = configObject.getProperty("dependencies");
+    if (!dependenciesProp) {
+      return { sourceFile, candidates: [] };
+    }
+    const depsInit = dependenciesProp.getInitializerIfKind(SyntaxKind.ObjectLiteralExpression);
+    if (!depsInit) {
+      return { sourceFile, candidates: [] };
+    }
+    const integrationsProp = depsInit.getProperty("integrations");
+    if (!integrationsProp) {
+      return { sourceFile, candidates: [] };
+    }
+    const integrationsInit = integrationsProp.getInitializerIfKind(SyntaxKind.ObjectLiteralExpression);
+    if (!integrationsInit) {
+      return { sourceFile, candidates: [] };
+    }
+    const candidates = integrationsInit.getProperties().flatMap((prop) => {
+      if (!prop.isKind(SyntaxKind.PropertyAssignment)) {
+        return [];
+      }
+      const assignment = prop;
+      const initializer = assignment.getInitializerIfKind(SyntaxKind.ObjectLiteralExpression);
+      if (!initializer) {
+        return [];
+      }
+      const hasConfigProperty = initializer.getProperty("config") !== undefined;
+      const versionProp = initializer.getProperty("version");
+      const versionInitializer = versionProp?.getInitializer();
+      const versionInitializerText = versionInitializer && (versionInitializer.isKind(SyntaxKind.StringLiteral) || versionInitializer.isKind(SyntaxKind.NoSubstitutionTemplateLiteral)) ? versionInitializer.getText() : undefined;
+      return [{ alias: assignment.getName(), assignment, hasConfigProperty, versionInitializerText }];
+    });
+    return { sourceFile, candidates };
+  }
   async updateDependencies(dependencies) {
     const { sourceFile, configObject } = this.loadConfig();
     let dependenciesProperty = configObject.getProperty("dependencies");
@@ -3582,6 +3666,67 @@ class ConfigWriter {
     }
     await this.saveConfig(sourceFile);
   }
+  async updateDefaultModels(updates) {
+    const requestedEntries = Object.entries(updates).filter(([, value]) => value !== undefined);
+    if (requestedEntries.length === 0) {
+      return;
+    }
+    const { sourceFile, configObject } = this.loadConfig();
+    let defaultModelsProperty = configObject.getProperty("defaultModels");
+    if (!defaultModelsProperty) {
+      defaultModelsProperty = configObject.addPropertyAssignment({
+        name: "defaultModels",
+        initializer: "{}"
+      });
+    }
+    const defaultModelsObject = defaultModelsProperty.getInitializerIfKind(SyntaxKind.ObjectLiteralExpression);
+    if (!defaultModelsObject) {
+      throw new Error("defaultModels must be an object literal in agent.config.ts");
+    }
+    for (const [key, value] of requestedEntries) {
+      const existingProperty = defaultModelsObject.getProperty(key);
+      const initializer = this.serializeDefaultModelSelection(value);
+      if (existingProperty) {
+        existingProperty.setInitializer(initializer);
+      } else {
+        defaultModelsObject.addPropertyAssignment({
+          name: key,
+          initializer
+        });
+      }
+    }
+    await this.saveConfig(sourceFile);
+  }
+  async migrateIntegrationsToStringFormat() {
+    const { sourceFile, candidates } = this.getIntegrationConfigMigrationCandidates();
+    const migrated = [];
+    for (const candidate of candidates) {
+      if (!candidate.versionInitializerText || candidate.hasConfigProperty) {
+        continue;
+      }
+      candidate.assignment.setInitializer(candidate.versionInitializerText);
+      migrated.push(candidate.alias);
+    }
+    if (migrated.length > 0) {
+      await this.saveConfig(sourceFile);
+    }
+    return migrated;
+  }
+  getIntegrationConfigMigrationState() {
+    try {
+      const { candidates } = this.getIntegrationConfigMigrationCandidates();
+      const deprecatedAliases = candidates.map((candidate) => candidate.alias);
+      const migratableAliases = candidates.filter((candidate) => candidate.versionInitializerText && !candidate.hasConfigProperty).map((candidate) => candidate.alias);
+      return { deprecatedAliases, migratableAliases };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      console.error(`Configuration update failed with error: ${message} — please verify that there are no syntax errors in your agent.config.ts`);
+      return { deprecatedAliases: [], migratableAliases: [] };
+    }
+  }
+  getObjectFormatIntegrations() {
+    return this.getIntegrationConfigMigrationState().deprecatedAliases;
+  }
   async updateConfiguration(updates) {
     const { sourceFile, configObject } = this.loadConfig();
     const hasAdds = updates.some((u) => u.action === "add");
@@ -3693,6 +3838,66 @@ class IntegrationOperations {
     }
     return { name, version, fullName: name };
   }
+  isIntegrationVersionId(input) {
+    return input.startsWith("intver_");
+  }
+  isResourceNotFoundError(error) {
+    return Boolean(error && typeof error === "object" && "type" in error && error.type === "ResourceNotFound");
+  }
+  getCanonicalIntegrationFullName(integration) {
+    if (integration.public) {
+      return integration.name;
+    }
+    const workspaceHandle = integration.ownerWorkspace?.handle;
+    return workspaceHandle ? `${workspaceHandle}/${integration.name}` : integration.name;
+  }
+  async resolveIntegrationVersionId(id) {
+    const client = await this.getClient();
+    try {
+      const response = await client.getIntegration({ id });
+      return response.integration;
+    } catch (error) {
+      if (!this.isResourceNotFoundError(error)) {
+        throw error;
+      }
+    }
+    try {
+      const response = await client.getPublicIntegrationById({ id });
+      return response.integration;
+    } catch (error) {
+      if (this.isResourceNotFoundError(error)) {
+        throw new Error(`Integration "${id}" not found`);
+      }
+      throw error;
+    }
+  }
+  async resolveAddIntegrationInput(options) {
+    const requestedVersion = options.version || "latest";
+    if (!this.isIntegrationVersionId(options.name)) {
+      const ref = this.parseIntegrationRef(`${options.name}@${requestedVersion}`);
+      return {
+        name: ref.name,
+        fullName: ref.fullName,
+        version: ref.version,
+        alias: options.alias || ref.name,
+        ref: `${ref.fullName}@${ref.version}`,
+        isIntegrationId: false
+      };
+    }
+    if (options.version && options.version !== "latest") {
+      throw new Error("Integration version IDs are already version-pinned and do not accept an additional @version override");
+    }
+    const integration = await this.resolveIntegrationVersionId(options.name);
+    const fullName = this.getCanonicalIntegrationFullName(integration);
+    return {
+      name: integration.name,
+      fullName,
+      version: integration.version,
+      alias: options.alias || integration.name,
+      ref: `${fullName}@${integration.version}`,
+      isIntegrationId: true
+    };
+  }
   async getIntegrationVersions(name) {
     const client = await this.getClient();
     const ref = this.parseIntegrationRef(name);
@@ -3726,9 +3931,8 @@ class IntegrationOperations {
   }
   async addIntegration(options) {
     const project = await AgentProject.load(this.projectPath || process2.cwd());
-    const { name, version = "latest" } = options;
-    const ref = this.parseIntegrationRef(`${name}@${version}`);
-    const alias = options.alias || ref.name;
+    const resolvedInput = await this.resolveAddIntegrationInput(options);
+    const { alias } = resolvedInput;
     const dependencies = project.dependencies || { integrations: {} };
     if (!dependencies.integrations) {
       dependencies.integrations = {};
@@ -3745,11 +3949,17 @@ class IntegrationOperations {
       } else {
         existingVersion = "unknown";
       }
-      if (!version || version === "latest" || version === existingVersion) {
+      const effectiveVersionSpecified = Boolean(options.version) || resolvedInput.isIntegrationId;
+      if (!effectiveVersionSpecified || resolvedInput.version === "latest" || resolvedInput.version === existingVersion) {
         return {
           success: false,
           message: `Integration '${alias}' already exists with version ${existingVersion}. Use 'adk upgrade ${alias}' to upgrade to the latest version.`,
-          existingVersion
+          existingVersion,
+          name: resolvedInput.name,
+          fullName: resolvedInput.fullName,
+          alias: resolvedInput.alias,
+          version: existingVersion,
+          ref: `${resolvedInput.fullName}@${existingVersion}`
         };
       }
     }
@@ -3761,7 +3971,7 @@ class IntegrationOperations {
       const loadResult = await tempManager.loadIntegrations({
         integrations: {
           [alias]: {
-            version: `${ref.fullName}@${ref.version}`,
+            version: resolvedInput.ref,
             enabled: true
           }
         }
@@ -3779,88 +3989,28 @@ class IntegrationOperations {
       throw new Error(`Failed to add integration: ${error instanceof Error ? error.message : String(error)}`);
     }
     const actualVersion = integrationDefinition.version;
-    const integrationVersion = `${ref.fullName}@${actualVersion}`;
+    const integrationVersion = `${resolvedInput.fullName}@${actualVersion}`;
     const existingEntry = dependencies.integrations[alias];
-    const existingConfig = existingEntry && typeof existingEntry === "object" ? existingEntry.config : undefined;
-    const existingConfigurationType = existingEntry && typeof existingEntry === "object" ? existingEntry.configurationType : undefined;
-    const configurationType = existingConfigurationType || this.selectBestConfigurationType(integrationDefinition.configurations);
-    let requiresConfiguration = false;
-    const selectedConfigDef = configurationType && integrationDefinition.configurations?.[configurationType] || integrationDefinition.configurations?.["default"] || integrationDefinition.configuration;
-    if (selectedConfigDef) {
-      if (selectedConfigDef.identifier?.required === true) {
-        requiresConfiguration = true;
-      }
-      if (selectedConfigDef.schema?.required && selectedConfigDef.schema.required.length > 0) {
-        requiresConfiguration = true;
-      }
-    }
-    const config = requiresConfiguration && !existingConfig ? this.getPlaceholderConfig(integrationDefinition, configurationType) : existingConfig;
     if (existingEntry && typeof existingEntry === "object" && "version" in existingEntry) {
-      const resolvedConfigType = existingEntry.configurationType || configurationType;
       dependencies.integrations[alias] = {
-        version: integrationVersion,
-        enabled: existingEntry.enabled,
-        ...resolvedConfigType ? { configurationType: resolvedConfigType } : {},
-        config: existingEntry.config
+        ...existingEntry,
+        version: integrationVersion
       };
     } else {
-      dependencies.integrations[alias] = {
-        version: integrationVersion,
-        enabled: !requiresConfiguration,
-        ...configurationType ? { configurationType } : {},
-        config
-      };
+      dependencies.integrations[alias] = integrationVersion;
     }
     const configWriter = new ConfigWriter(project.path);
     await configWriter.updateDependencies(dependencies);
     return {
       success: true,
-      requiresConfiguration,
-      newVersion: actualVersion
+      newVersion: actualVersion,
+      name: resolvedInput.name,
+      fullName: resolvedInput.fullName,
+      alias: resolvedInput.alias,
+      version: actualVersion,
+      ref: integrationVersion
     };
   }
-  selectBestConfigurationType(configurations) {
-    if (!configurations || Object.keys(configurations).length === 0) {
-      return;
-    }
-    const keys = Object.keys(configurations);
-    if (keys.length === 1) {
-      return keys[0];
-    }
-    const priority = ["apiKey", "api", "api_key", "token", "default", "refreshToken", "oauth", "oauth2"];
-    for (const preferred of priority) {
-      const match = keys.find((k) => k.toLowerCase() === preferred.toLowerCase());
-      if (match)
-        return match;
-    }
-    return keys[0];
-  }
-  getPlaceholderConfig(integrationDefinition, configurationType) {
-    const configPlaceholder = {};
-    const configDef = configurationType && integrationDefinition.configurations?.[configurationType] || integrationDefinition.configurations?.["default"] || integrationDefinition.configuration;
-    if (configDef) {
-      const schema = configDef.schema;
-      if (schema?.required && schema.required.length > 0) {
-        const properties = schema.properties || {};
-        for (const fieldName of schema.required) {
-          const fieldDef = properties[fieldName];
-          if (fieldDef?.type === "string") {
-            configPlaceholder[fieldName] = `YOUR_${fieldName.toUpperCase()}_HERE`;
-          } else if (fieldDef?.type === "number" || fieldDef?.type === "integer") {
-            configPlaceholder[fieldName] = 0;
-          } else if (fieldDef?.type === "boolean") {
-            configPlaceholder[fieldName] = false;
-          } else {
-            configPlaceholder[fieldName] = null;
-          }
-        }
-        if (Object.keys(configPlaceholder).length > 0) {
-          return configPlaceholder;
-        }
-      }
-    }
-    return;
-  }
   async removeIntegration(name) {
     const project = await AgentProject.load(this.projectPath || process2.cwd());
     const dependencies = project.dependencies;
@@ -3899,10 +4049,8 @@ class IntegrationOperations {
         }
         const versionInfo = await this.getIntegrationVersions(ref.fullName);
         if (versionInfo.latestVersion && versionInfo.latestVersion !== currentVersion) {
-          dependencies.integrations[alias] = {
-            ...value,
-            version: `${ref.fullName}@${versionInfo.latestVersion}`
-          };
+          const newVersion = `${ref.fullName}@${versionInfo.latestVersion}`;
+          dependencies.integrations[alias] = typeof value === "string" ? newVersion : { ...value, version: newVersion };
           upgraded.push(`${alias} (${currentVersion} → ${versionInfo.latestVersion})`);
         }
       } catch {
@@ -3991,7 +4139,7 @@ async function fetchServerIntegrationConfigs(project, targetBotId) {
   const { devId, botId } = project.agentInfo ?? {};
   const targetId = targetBotId || devId || botId;
   if (!targetId) {
-    return { configs: {}, fetched: false, skipped: true };
+    return { configs: {}, enabledStates: {}, fetched: false, skipped: true };
   }
   try {
     const credentials = await auth.getActiveCredentials();
@@ -4014,18 +4162,26 @@ async function fetchServerIntegrationConfigs(project, targetBotId) {
     }
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
-    return { configs: {}, fetched: false, skipped: false, error: message };
+    return {
+      configs: {},
+      enabledStates: {},
+      fetched: false,
+      skipped: false,
+      error: message
+    };
   }
 }
 async function fetchBotConfigs(client, botId) {
   const { bot } = await client.getBot({ id: botId });
   const configs = {};
+  const enabledStates = {};
   for (const [alias, integration] of Object.entries(bot.integrations || {})) {
     if (integration.configuration && Object.keys(integration.configuration).length > 0) {
       configs[alias] = integration.configuration;
     }
+    enabledStates[alias] = integration.enabled;
   }
-  return { configs, fetched: true, skipped: false };
+  return { configs, enabledStates, fetched: true, skipped: false };
 }
 
 // src/integrations/checker.ts
@@ -4139,7 +4295,7 @@ class IntegrationChecker {
         }
       }
     }
-    const desiredInstallStatus = enabled === false ? "disabled" : "enabled";
+    const desiredInstallStatus = enabled === true ? "enabled" : enabled === false ? "disabled" : installedIntegration ? installedIntegration.enabled ? "enabled" : "disabled" : "disabled";
     const result = {
       alias,
       name: ref.fullName,
@@ -4167,7 +4323,7 @@ class IntegrationChecker {
       }
     }
     if (!installedIntegration) {
-      result.needsInstall = enabled !== false;
+      result.needsInstall = true;
       if (result.needsInstall && config) {
         result.needsConfiguration = true;
       }
@@ -4187,11 +4343,7 @@ class IntegrationChecker {
         }
       }
       if (enabled !== undefined && enabled !== installedIntegration.enabled) {
-        if (enabled === false) {
-          result.needsRemoval = true;
-        } else if (enabled === true && result.installStatus === "disabled") {
-          result.needsConfiguration = true;
-        }
+        result.needsUpdate = true;
       }
     }
     return result;
@@ -4728,6 +4880,21 @@ init_agent_resolver();
 init_types();
 init_validation_errors();
 var debug2 = createDebug2("adk:agent-project");
+function getToolDefinition(value) {
+  if (typeof value !== "object" || value === null) {
+    return;
+  }
+  const maybeTool = value;
+  const isAutonomousToolInstance = value instanceof Autonomous.Tool;
+  const looksLikeAutonomousTool = maybeTool.constructor?.name === Autonomous.Tool.name && typeof maybeTool.name === "string" && typeof maybeTool.execute === "function" && typeof maybeTool.toJSON === "function";
+  if (!isAutonomousToolInstance && !looksLikeAutonomousTool) {
+    return;
+  }
+  return {
+    name: maybeTool.name,
+    description: maybeTool.description
+  };
+}
 
 class AgentProject {
   static _projectCache = new Map;
@@ -4751,6 +4918,7 @@ class AgentProject {
   _workflows = [];
   _actions = [];
   _tables = [];
+  _tools = [];
   constructor(projectPath, options = {}) {
     this._options = options;
     this._path = path13.resolve(projectPath);
@@ -4807,6 +4975,9 @@ class AgentProject {
   get tables() {
     return this._tables;
   }
+  get tools() {
+    return this._tools;
+  }
   get config() {
     return this._config;
   }
@@ -4845,6 +5016,7 @@ class AgentProject {
       this._workflows = [];
       this._actions = [];
       this._tables = [];
+      this._tools = [];
       this._errors = [];
       this._warnings = [];
       const validation = await this.validate();
@@ -5018,7 +5190,21 @@ class AgentProject {
     const content = stringifyWithOrder(merged, agentLocalInfoKeyOrder);
     await fs10.writeFile(localPath, content);
     if (this._agentInfo) {
-      this._agentInfo.devId = merged.devId;
+      if (merged.botId)
+        this._agentInfo.botId = merged.botId;
+      if (merged.workspaceId)
+        this._agentInfo.workspaceId = merged.workspaceId;
+      if (merged.apiUrl)
+        this._agentInfo.apiUrl = merged.apiUrl;
+      if (merged.devId)
+        this._agentInfo.devId = merged.devId;
+    } else if (merged.botId && merged.workspaceId) {
+      this._agentInfo = {
+        botId: merged.botId,
+        workspaceId: merged.workspaceId,
+        apiUrl: merged.apiUrl,
+        devId: merged.devId
+      };
     }
   }
   async updateAgentLocalInfo(updates) {
@@ -5037,7 +5223,15 @@ class AgentProject {
     const content = stringifyWithOrder(updated, agentLocalInfoKeyOrder);
     await fs10.writeFile(localPath, content);
     if (this._agentInfo) {
-      this._agentInfo.devId = updated.devId;
+      const local = updated;
+      if (local.botId)
+        this._agentInfo.botId = local.botId;
+      if (local.workspaceId)
+        this._agentInfo.workspaceId = local.workspaceId;
+      if (local.apiUrl)
+        this._agentInfo.apiUrl = local.apiUrl;
+      if (local.devId)
+        this._agentInfo.devId = local.devId;
     }
   }
   requiresAgentInfo(operation) {
@@ -5242,6 +5436,19 @@ ${err.stack?.split(`
     }
     return true;
   }
+  isToolBarrelReexport(existingPath, newPath) {
+    const isNewBarrel = /^index\.[tj]s$/i.test(path13.basename(newPath));
+    const isExistingBarrel = /^index\.[tj]s$/i.test(path13.basename(existingPath));
+    if (!isNewBarrel && !isExistingBarrel) {
+      return false;
+    }
+    return true;
+  }
+  shouldPreferToolDefinition(existingPath, newPath) {
+    const isNewBarrel = /^index\.[tj]s$/i.test(path13.basename(newPath));
+    const isExistingBarrel = /^index\.[tj]s$/i.test(path13.basename(existingPath));
+    return isExistingBarrel && !isNewBarrel;
+  }
   getChannelsList(channelSpec) {
     if (channelSpec === "*") {
       return ["*"];
@@ -5442,6 +5649,35 @@ ${err.stack?.split(`
               export: key,
               path: relPath
             });
+          } else {
+            const toolDefinition = getToolDefinition(expandedExports[key]);
+            if (!toolDefinition) {
+              continue;
+            }
+            const existing = this._tools.find((tool) => tool.definition.name === toolDefinition.name);
+            if (existing) {
+              if (this.isToolBarrelReexport(existing.path, relPath)) {
+                if (this.shouldPreferToolDefinition(existing.path, relPath)) {
+                  existing.path = relPath;
+                  existing.export = key;
+                  existing.definition = toolDefinition;
+                }
+                continue;
+              }
+              this._warnings.push({
+                $type: "ValidationError",
+                code: "DUPLICATE_PRIMITIVE" /* DUPLICATE_PRIMITIVE */,
+                severity: "warning" /* WARNING */,
+                message: `Duplicate tool definition found: ${filename} -> ${key} (already defined in ${existing.path} -> ${existing.export})`,
+                file: relPath
+              });
+              continue;
+            }
+            this._tools.push({
+              definition: toolDefinition,
+              export: key,
+              path: relPath
+            });
           }
         }
       } catch (error) {
@@ -5725,6 +5961,8 @@ class ConfigManager {
 init_utils();
 import * as fs11 from "fs";
 import * as path15 from "path";
+import { fileURLToPath } from "url";
+import { createRequire as createRequire4 } from "module";
 
 // src/agent-init/ai-assistant-instructions.template.md
 var ai_assistant_instructions_template_default = `# Botpress ADK Agent
@@ -5775,10 +6013,12 @@ Run \`adk mcp:init --all\` to generate configuration for your editor, or use the
 
 ### Workflows
 
-| Tool                 | Use for                                    |
-| -------------------- | ------------------------------------------ |
-| \`adk_list_workflows\` | List available workflows with descriptions |
-| \`adk_start_workflow\` | Start a workflow or get its input schema   |
+| Tool                 | Use for                                  |
+| -------------------- | ---------------------------------------- |
+| \`adk_list_workflows\` | Deprecated compat workflow discovery     |
+| \`adk_start_workflow\` | Start a workflow or get its input schema |
+
+> **Tip:** Prefer \`adk workflows\` in the terminal to discover workflow names and metadata. Keep \`adk_list_workflows\` for MCP compatibility only.
 
 > **Tip:** The dev server must be running (\`adk dev\`) for debugging and testing tools to work.
 
@@ -5796,6 +6036,30 @@ Run \`adk mcp:init --all\` to generate configuration for your editor, or use the
 `;
 
 // src/agent-init/agent-project-generator.ts
+var TEXT_EXTENSIONS = new Set([
+  ".ts",
+  ".tsx",
+  ".js",
+  ".jsx",
+  ".mjs",
+  ".cjs",
+  ".json",
+  ".md",
+  ".txt",
+  ".yml",
+  ".yaml",
+  ".html",
+  ".css",
+  ".svg",
+  ".gitignore"
+]);
+function isTextFile(filename) {
+  if (filename === ".gitignore")
+    return true;
+  const ext = path15.extname(filename).toLowerCase();
+  return TEXT_EXTENSIONS.has(ext);
+}
+
 class AgentProjectGenerator {
   projectPath;
   projectName;
@@ -5809,253 +6073,146 @@ class AgentProjectGenerator {
   }
   async generate() {
     this.ensureEmptyDirectory();
-    this.createPackageJson();
-    await this.createAgentConfig();
-    this.createTsConfig();
-    this.createAgentJson();
-    this.createGitIgnore();
-    await this.createReadme();
-    this.createAIAssistantInstructions();
-    await this.createSourceStructure();
-  }
-  ensureEmptyDirectory() {
-    if (!fs11.existsSync(this.projectPath)) {
-      fs11.mkdirSync(this.projectPath, { recursive: true });
+    const templateDir = this.resolveTemplateDir();
+    await this.copyTemplateFiles(templateDir);
+    if (!fs11.existsSync(path15.join(this.projectPath, "agent.json"))) {
+      this.createAgentJson();
     }
-    const files = fs11.readdirSync(this.projectPath);
-    if (files.length > 0) {
-      throw new Error(`Directory ${this.projectPath} is not empty. Please use an empty directory.`);
+    if (!fs11.existsSync(path15.join(this.projectPath, "CLAUDE.md"))) {
+      this.createAIAssistantInstructions();
     }
   }
-  createPackageJson() {
-    const packageJson = {
-      name: this.projectName,
-      version: "1.0.0",
-      description: `A Botpress Agent built with the ADK`,
-      type: "module",
-      packageManager: this.packageManager === "npm" ? undefined : `${this.packageManager}@latest`,
-      scripts: {
-        dev: "adk dev",
-        build: "adk build",
-        deploy: "adk deploy"
-      },
-      dependencies: {
-        "@botpress/runtime": `^${"1.17.0"}`
-      },
-      devDependencies: {
-        typescript: "^5.9.3"
+  static getAvailableTemplates() {
+    try {
+      const templatesRoot = AgentProjectGenerator.getTemplatesRoot();
+      const configPath = path15.join(templatesRoot, "template.config.json");
+      if (!fs11.existsSync(configPath)) {
+        return [];
       }
-    };
-    if (packageJson.packageManager === undefined) {
-      delete packageJson.packageManager;
+      const raw = fs11.readFileSync(configPath, "utf-8");
+      const registry = JSON.parse(raw);
+      return registry.templates;
+    } catch {
+      return [];
     }
-    this.writeJsonFile("package.json", packageJson);
   }
-  getDefaultDependencies() {
-    const dependencies = {
-      integrations: {}
-    };
-    if (this.template === "hello-world") {
-      dependencies.integrations = {
-        chat: {
-          version: "chat@latest",
-          enabled: true
-        },
-        webchat: {
-          version: "webchat@latest",
-          enabled: true
-        }
-      };
-    }
-    return dependencies;
+  getPostInitCommands() {
+    const templates = AgentProjectGenerator.getAvailableTemplates();
+    const config = templates.find((t) => t.name === this.template);
+    return config?.postInit ?? [];
   }
-  async createAgentConfig() {
-    const dependencies = this.getDefaultDependencies();
-    const integrationsJson = JSON.stringify(dependencies.integrations, null, 4).replace(/\n/g, `
-    `);
-    const defaultModels = this.template === "hello-world" ? `
-  defaultModels: {
-    autonomous: "cerebras:gpt-oss-120b",
-    zai: "cerebras:gpt-oss-120b",
-  },
-` : "";
-    const agentConfig = `import { z, defineConfig } from '@botpress/runtime';
-
-export default defineConfig({
-  name: '${this.projectName}',
-  description: 'An AI agent built with Botpress ADK',
-${defaultModels}
-  bot: {
-    state: z.object({}),
-  },
+  static _templatesRootOverride = null;
+  static setTemplatesRoot(dir) {
+    AgentProjectGenerator._templatesRootOverride = dir;
+  }
+  static getTemplatesRoot() {
+    if (AgentProjectGenerator._templatesRootOverride) {
+      return AgentProjectGenerator._templatesRootOverride;
+    }
+    const candidates = [];
+    try {
+      const esmRequire = createRequire4(import.meta.url);
+      const adkPkgPath = esmRequire.resolve("@botpress/adk/package.json");
+      const adkRoot = path15.dirname(adkPkgPath);
+      candidates.push(path15.join(adkRoot, "dist", "templates"));
+      candidates.push(path15.join(adkRoot, "templates"));
+    } catch {}
+    const thisDir = path15.dirname(fileURLToPath(import.meta.url));
+    candidates.push(path15.resolve(thisDir, "templates"));
+    candidates.push(path15.resolve(thisDir, "../../templates"));
+    candidates.push(path15.join(path15.dirname(process.execPath), "templates"));
+    for (const candidate of candidates) {
+      if (fs11.existsSync(candidate) && fs11.existsSync(path15.join(candidate, "template.config.json"))) {
+        return candidate;
+      }
+    }
+    const tried = candidates.map((c) => `  - ${c}`).join(`
+`);
+    throw new Error(`Could not find templates directory.
 
-  user: {
-    state: z.object({}),
-  },
+Searched:
+${tried}
 
-  dependencies: {
-    integrations: ${integrationsJson},
-  },
-});
-`;
-    await this.writeFormattedFile("agent.config.ts", agentConfig);
+Ensure the ADK package is properly installed or run the CLI build.`);
   }
-  createTsConfig() {
-    const tsConfig = {
-      compilerOptions: {
-        target: "ES2022",
-        module: "ES2022",
-        moduleResolution: "Bundler",
-        lib: ["ES2022", "DOM"],
-        outDir: "./dist",
-        rootDir: ".",
-        strict: true,
-        esModuleInterop: true,
-        allowSyntheticDefaultImports: true,
-        skipLibCheck: true,
-        forceConsistentCasingInFileNames: true,
-        moduleDetection: "force",
-        resolveJsonModule: true,
-        paths: {
-          "@botpress/runtime/_types/*": ["./.adk/*-types"]
-        }
-      },
-      include: ["src/**/*", ".adk/**/*"],
-      exclude: ["node_modules", "dist"]
+  resolveTemplateDir() {
+    const templatesRoot = AgentProjectGenerator.getTemplatesRoot();
+    const templateDir = path15.join(templatesRoot, this.template);
+    if (!fs11.existsSync(templateDir)) {
+      const available = AgentProjectGenerator.getAvailableTemplates();
+      const names = available.map((t) => `  - ${t.name}: ${t.description}`).join(`
+`);
+      throw new Error(`Unknown template: "${this.template}"
+
+Available templates:
+${names || "  (none found)"}`);
+    }
+    const configFile = path15.join(templateDir, "agent.config.ts");
+    if (!fs11.existsSync(configFile)) {
+      throw new Error(`Template "${this.template}" is missing agent.config.ts`);
+    }
+    return templateDir;
+  }
+  async copyTemplateFiles(templateDir) {
+    const substitutions = {
+      "{{projectName}}": this.projectName,
+      "{{runtimeVersion}}": "1.18.0-beta.2",
+      "{{packageManager}}": this.packageManager
     };
-    this.writeJsonFile("tsconfig.json", tsConfig);
+    await this.copyDirRecursive(templateDir, this.projectPath, substitutions);
+  }
+  async copyDirRecursive(src, dest, substitutions) {
+    if (!fs11.existsSync(dest)) {
+      fs11.mkdirSync(dest, { recursive: true });
+    }
+    const entries = fs11.readdirSync(src, { withFileTypes: true });
+    for (const entry of entries) {
+      const srcPath = path15.join(src, entry.name);
+      const destPath = path15.join(dest, entry.name);
+      if (entry.isDirectory()) {
+        await this.copyDirRecursive(srcPath, destPath, substitutions);
+      } else if (isTextFile(entry.name)) {
+        let content = fs11.readFileSync(srcPath, "utf-8");
+        for (const [placeholder, value] of Object.entries(substitutions)) {
+          content = content.replaceAll(placeholder, value);
+        }
+        const remaining = content.match(/\{\{[a-zA-Z]+\}\}/g);
+        if (remaining) {
+          console.warn(`Warning: unresolved placeholders in ${entry.name}: ${remaining.join(", ")}`);
+        }
+        if (entry.name.endsWith(".ts") || entry.name.endsWith(".tsx")) {
+          try {
+            content = await formatCode(content, destPath);
+          } catch {}
+        }
+        fs11.writeFileSync(destPath, content);
+      } else {
+        fs11.copyFileSync(srcPath, destPath);
+      }
+    }
+  }
+  ensureEmptyDirectory() {
+    if (!fs11.existsSync(this.projectPath)) {
+      fs11.mkdirSync(this.projectPath, { recursive: true });
+    }
+    const files = fs11.readdirSync(this.projectPath);
+    if (files.length > 0) {
+      throw new Error(`Directory ${this.projectPath} is not empty. Please use an empty directory.`);
+    }
   }
   createAgentJson() {
     const agentJson = {};
     this.writeJsonFile("agent.json", agentJson);
   }
-  createGitIgnore() {
-    const gitIgnore = `# Dependencies
-node_modules/
-.pnpm-store/
-
-# Build outputs
-dist/
-.adk/
-
-# Environment files
-.env
-.env.local
-.env.production
-
-# Local development
-agent.local.json
-
-# MCP configuration (auto-generated by adk mcp:init)
-.mcp.json
-
-# IDE files
-.vscode/
-.idea/
-*.swp
-*.swo
-
-# OS files
-.DS_Store
-Thumbs.db
-
-# Logs
-*.log
-logs/
-
-# Runtime files
-*.pid
-*.seed
-*.pid.lock
-`;
-    this.writeFile(".gitignore", gitIgnore);
-  }
-  async createReadme() {
-    const installCommand = this.packageManager === "npm" ? "npm install" : this.packageManager === "yarn" ? "yarn install" : `${this.packageManager} install`;
-    const readme = `# ${this.projectName}
-
-A Botpress Agent built with the ADK.
-
-## Getting Started
-
-1. Install dependencies:
-   \`\`\`bash
-   ${installCommand}
-   \`\`\`
-
-2. Start development server:
-   \`\`\`bash
-   adk dev
-   \`\`\`
-
-3. Deploy your agent:
-   \`\`\`bash
-   adk deploy
-   \`\`\`
-
-## Project Structure
-
-- \`src/actions/\` - Define callable functions
-- \`src/workflows/\` - Define long-running processes
-- \`src/conversations/\` - Define conversation handlers
-- \`src/tables/\` - Define data storage schemas
-- \`src/triggers/\` - Define event subscriptions
-- \`src/knowledge/\` - Add knowledge base files
-
-## Learn More
-
-- [ADK Documentation](https://botpress.com/docs/adk)
-- [Botpress Platform](https://botpress.com)
-`;
-    await this.writeFormattedFile("README.md", readme);
-  }
   createAIAssistantInstructions() {
     const content = ai_assistant_instructions_template_default;
     this.writeFile("CLAUDE.md", content);
     this.writeFile("AGENTS.md", content);
   }
-  async createSourceStructure() {
-    const srcPath = path15.join(this.projectPath, "src");
-    fs11.mkdirSync(srcPath);
-    const subdirectories = ["actions", "conversations", "knowledge", "tables", "triggers", "workflows"];
-    for (const subdir of subdirectories) {
-      const subdirPath = path15.join(srcPath, subdir);
-      fs11.mkdirSync(subdirPath);
-      if (subdir === "conversations" && this.template === "hello-world") {
-        const conversationContent = `import { Conversation } from "@botpress/runtime";
-
-export default new Conversation({
-  channel: "*",
-  handler: async ({ execute }) => {
-    await execute({
-      instructions: \`You are a helpful AI assistant built with Botpress ADK. You can assist users with their questions and tasks.\`,
-    });
-  },
-});
-`;
-        await this.writeFormattedFile(path15.join("src", subdir, "index.ts"), conversationContent);
-      } else {
-        const placeholderContent = `/**
- * TODO: Add your ${subdir} here
- *
- * This is a placeholder file to initialize the ${subdir} directory.
- * You can delete this file once you add your own ${subdir}.
- */
-
-export default {};
-`;
-        await this.writeFormattedFile(path15.join("src", subdir, "index.ts"), placeholderContent);
-      }
-    }
-  }
   writeFile(relativePath, content) {
     const filePath = path15.join(this.projectPath, relativePath);
     fs11.writeFileSync(filePath, content);
   }
-  async writeFormattedFile(relativePath, content) {
-    const formatted = await formatCode(content, relativePath);
-    this.writeFile(relativePath, formatted);
-  }
   writeJsonFile(relativePath, data) {
     this.writeFile(relativePath, JSON.stringify(data, null, 2) + `
 `);
@@ -7077,7 +7234,7 @@ export function createAdkClient(client: Client): AdkClient {
 }
 // src/bot-generator/generator.ts
 import dedent from "dedent";
-import { existsSync as existsSync8 } from "fs";
+import { existsSync as existsSync7 } from "fs";
 import fs18 from "fs/promises";
 import path38 from "path";
 
@@ -7962,8 +8119,10 @@ async function linkSdk(agentDir, botDir) {
 // src/bot-generator/dev-id-manager.ts
 import path32 from "path";
 import fs14 from "fs/promises";
-import { existsSync as existsSync4 } from "fs";
+import createDebug3 from "debug";
 import { Client as Client14 } from "@botpress/client";
+var debug3 = createDebug3("adk:dev-id-manager");
+
 class DevIdManager {
   projectPath;
   botProjectPath;
@@ -7998,11 +8157,26 @@ class DevIdManager {
   }
   async readProjectCache() {
     try {
-      if (existsSync4(this.projectCachePath)) {
-        const content = await fs14.readFile(this.projectCachePath, "utf-8");
-        return JSON.parse(content);
+      const content = await fs14.readFile(this.projectCachePath, "utf-8");
+      if (content.trim().length === 0) {
+        debug3("project cache is empty, treating as bootstrap state: %s", this.projectCachePath);
+        return {};
       }
+      const parsed = JSON.parse(content);
+      if (!isProjectCache(parsed)) {
+        debug3("project cache contains unexpected JSON type, treating as bootstrap state: %s", this.projectCachePath);
+        return {};
+      }
+      return parsed;
     } catch (error) {
+      if (isMissingFileError(error)) {
+        debug3("project cache missing, treating as bootstrap state: %s", this.projectCachePath);
+        return {};
+      }
+      if (error instanceof SyntaxError) {
+        debug3("project cache contains transient invalid JSON, treating as bootstrap state: %s (%O)", this.projectCachePath, error);
+        return {};
+      }
       console.error("Error reading project.cache.json:", error);
     }
     return {};
@@ -8056,11 +8230,17 @@ class DevIdManager {
     return false;
   }
 }
+function isMissingFileError(error) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
+}
+function isProjectCache(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
 
 // src/bot-generator/integration-sync.ts
 import path33 from "path";
 import fs15 from "fs/promises";
-import { existsSync as existsSync5 } from "fs";
+import { existsSync as existsSync4 } from "fs";
 class IntegrationSync {
   projectPath;
   botProjectPath;
@@ -8100,12 +8280,12 @@ class IntegrationSync {
   }
   async isIntegrationSynced(integration) {
     const targetFolder = path33.join(this.bpModulesPath, `integration_${integration.alias}`);
-    if (!existsSync5(targetFolder)) {
+    if (!existsSync4(targetFolder)) {
       return false;
     }
     try {
       const indexPath = path33.join(targetFolder, "index.ts");
-      if (!existsSync5(indexPath)) {
+      if (!existsSync4(indexPath)) {
         return false;
       }
       const indexContent = await fs15.readFile(indexPath, "utf-8");
@@ -8138,17 +8318,17 @@ class IntegrationSync {
   async renameIntegrationFolder(integration) {
     const sourceFolder = path33.join(this.bpModulesPath, integration.name.replace("/", "-"));
     const targetFolder = path33.join(this.bpModulesPath, `integration_${integration.alias}`);
-    if (!existsSync5(sourceFolder)) {
+    if (!existsSync4(sourceFolder)) {
       throw new Error(`Integration folder not found: ${sourceFolder}`);
     }
-    if (existsSync5(targetFolder)) {
+    if (existsSync4(targetFolder)) {
       await fs15.rm(targetFolder, { recursive: true, force: true });
     }
     await fs15.rename(sourceFolder, targetFolder);
   }
   async removeIntegrationFolder(alias) {
     const targetFolder = path33.join(this.bpModulesPath, `integration_${alias}`);
-    if (existsSync5(targetFolder)) {
+    if (existsSync4(targetFolder)) {
       await fs15.rm(targetFolder, { recursive: true, force: true });
     }
   }
@@ -8183,7 +8363,7 @@ class IntegrationSync {
 // src/bot-generator/interface-sync.ts
 import path34 from "path";
 import fs16 from "fs/promises";
-import { existsSync as existsSync6 } from "fs";
+import { existsSync as existsSync5 } from "fs";
 init_constants();
 class InterfaceSync {
   projectPath;
@@ -8211,12 +8391,12 @@ class InterfaceSync {
   }
   async isInterfaceSynced(interfaceInfo) {
     const targetFolder = path34.join(this.bpModulesPath, `interface_${pascalCase(interfaceInfo.alias)}`);
-    if (!existsSync6(targetFolder)) {
+    if (!existsSync5(targetFolder)) {
       return false;
     }
     try {
       const indexPath = path34.join(targetFolder, "index.ts");
-      if (!existsSync6(indexPath)) {
+      if (!existsSync5(indexPath)) {
         return false;
       }
       const indexContent = await fs16.readFile(indexPath, "utf-8");
@@ -8263,17 +8443,17 @@ class InterfaceSync {
   async renameInterfaceFolder(interfaceInfo) {
     const sourceFolder = path34.join(this.bpModulesPath, interfaceInfo.name);
     const targetFolder = path34.join(this.bpModulesPath, `interface_${pascalCase(interfaceInfo.alias)}`);
-    if (!existsSync6(sourceFolder)) {
+    if (!existsSync5(sourceFolder)) {
       throw new Error(`Interface folder not found: ${sourceFolder}`);
     }
-    if (existsSync6(targetFolder)) {
+    if (existsSync5(targetFolder)) {
       await fs16.rm(targetFolder, { recursive: true, force: true });
     }
     await fs16.rename(sourceFolder, targetFolder);
   }
   async removeInterfaceFolder(alias) {
     const targetFolder = path34.join(this.bpModulesPath, `interface_${pascalCase(alias)}`);
-    if (existsSync6(targetFolder)) {
+    if (existsSync5(targetFolder)) {
       await fs16.rm(targetFolder, { recursive: true, force: true });
     }
   }
@@ -8308,7 +8488,7 @@ class InterfaceSync {
 // src/bot-generator/plugin-sync.ts
 import path35 from "path";
 import fs17 from "fs/promises";
-import { existsSync as existsSync7 } from "fs";
+import { existsSync as existsSync6 } from "fs";
 class PluginSync {
   projectPath;
   botProjectPath;
@@ -8340,12 +8520,12 @@ class PluginSync {
   }
   async isPluginSynced(plugin) {
     const targetFolder = path35.join(this.bpModulesPath, `plugin_${plugin.alias}`);
-    if (!existsSync7(targetFolder)) {
+    if (!existsSync6(targetFolder)) {
       return false;
     }
     try {
       const indexPath = path35.join(targetFolder, "index.ts");
-      if (!existsSync7(indexPath)) {
+      if (!existsSync6(indexPath)) {
         return false;
       }
       const indexContent = await fs17.readFile(indexPath, "utf-8");
@@ -8378,17 +8558,17 @@ class PluginSync {
   async renamePluginFolder(plugin) {
     const sourceFolder = path35.join(this.bpModulesPath, plugin.name.replace("/", "-"));
     const targetFolder = path35.join(this.bpModulesPath, `plugin_${plugin.alias}`);
-    if (!existsSync7(sourceFolder)) {
+    if (!existsSync6(sourceFolder)) {
       throw new Error(`Plugin folder not found: ${sourceFolder}`);
     }
-    if (existsSync7(targetFolder)) {
+    if (existsSync6(targetFolder)) {
       await fs17.rm(targetFolder, { recursive: true, force: true });
     }
     await fs17.rename(sourceFolder, targetFolder);
   }
   async removePluginFolder(alias) {
     const targetFolder = path35.join(this.bpModulesPath, `plugin_${alias}`);
-    if (existsSync7(targetFolder)) {
+    if (existsSync6(targetFolder)) {
       await fs17.rm(targetFolder, { recursive: true, force: true });
     }
   }
@@ -8451,7 +8631,7 @@ class BotGenerator {
   }
   async listFilesRecursive(rootDir) {
     try {
-      if (!existsSync8(rootDir))
+      if (!existsSync7(rootDir))
         return [];
       const result = [];
       const walk = async (dir, relativeBase) => {
@@ -8473,7 +8653,7 @@ class BotGenerator {
     }
   }
   async removeEmptyDirectories(rootDir) {
-    if (!existsSync8(rootDir))
+    if (!existsSync7(rootDir))
       return;
     const removeIfEmpty = async (dir) => {
       const entries = await fs18.readdir(dir, { withFileTypes: true });
@@ -8679,7 +8859,7 @@ class BotGenerator {
     const integrations = await manager3.loadIntegrations(project.dependencies || {});
     const channels = [];
     for (const integration of integrations.integrations) {
-      if (integration.enabled && integration.definition) {
+      if (integration.definition) {
         const alias = integration.alias;
         for (const channelName of Object.keys(integration.definition.channels || {})) {
           channels.push(`"${alias}.${channelName}"`);
@@ -8737,7 +8917,7 @@ declare module "@botpress/runtime/_types/state" {
     const interfacesDir = path38.join(this.projectPath, ".adk", "interfaces");
     const existingInterfaceFiles = await this.listFilesRecursive(interfacesDir);
     const interfaces = await manager3.loadInterfaces(project.dependencies || {}).then((result) => result.interfaces.filter((int) => int.definition).map((x) => x.definition));
-    const integrationsWithAlias = await integrationManager.loadIntegrations(project.dependencies || {}).then((result) => result.integrations.filter((int) => int.enabled && int.definition).map((x) => ({ alias: x.alias, definition: x.definition })));
+    const integrationsWithAlias = await integrationManager.loadIntegrations(project.dependencies || {}).then((result) => result.integrations.filter((int) => int.definition).map((x) => ({ alias: x.alias, definition: x.definition })));
     let imports = new Set;
     let aliases = new Set;
     let files = new Set;
@@ -8802,10 +8982,7 @@ declare module "@botpress/runtime/_types/state" {
     const integrations = project.dependencies?.integrations || {};
     const imports = [];
     const integrationDefs = [];
-    for (const [alias, config] of Object.entries(integrations)) {
-      if (config.enabled === false) {
-        continue;
-      }
+    for (const [alias] of Object.entries(integrations)) {
       const normalizedAlias = getIntegrationAlias(alias);
       imports.push(`import integration_${normalizedAlias} from "../bp_modules/integration_${normalizedAlias}";`);
       integrationDefs.push(`"${alias}": integration_${normalizedAlias}`);
@@ -8907,21 +9084,21 @@ declare module "@botpress/runtime/_types/state" {
   async generateBotDefinition() {
     const project = await AgentProject.load(this.projectPath);
     const integrations = project.integrations;
-    const enabledIntegrations = integrations.filter((i) => i.enabled);
     const isDeployOrBuild = this.adkCommand === "adk-deploy" || this.adkCommand === "adk-build";
     const configTargetBotId = isDeployOrBuild ? project.agentInfo?.botId : undefined;
     const serverConfigResult = await fetchServerIntegrationConfigs(project, configTargetBotId);
-    this.reportServerConfigSync(serverConfigResult, enabledIntegrations);
+    this.reportServerConfigSync(serverConfigResult, integrations);
     const imports = [];
     const addIntegrations = [];
-    for (const integration of enabledIntegrations) {
+    for (const integration of integrations) {
       const { alias, configurationType, config } = integration;
       const importName = `integration_${getIntegrationAlias(alias)}`;
       imports.push(`import ${importName} from "./bp_modules/${importName}";`);
       const configType = configurationType && configurationType !== "default" ? `, configurationType: "${configurationType}"` : "";
       const mergedConfig = mergeIntegrationConfig(serverConfigResult.configs[alias], config);
       const configData = Object.keys(mergedConfig).length > 0 ? `, configuration: ${JSON.stringify(mergedConfig)}` : "";
-      addIntegrations.push(`bot.addIntegration(${importName}, { alias: "${alias}", enabled: true${configType}${configData} });`);
+      const enabled = integration.enabled ?? serverConfigResult.enabledStates[alias] ?? false;
+      addIntegrations.push(`bot.addIntegration(${importName}, { alias: "${alias}", enabled: ${enabled}${configType}${configData} });`);
     }
     const depRefErrors = PluginParser.validateDependencyReferences(project.dependencies || {});
     if (depRefErrors.length > 0) {
@@ -9350,7 +9527,7 @@ export default bot;`;
   async copyAssets() {
     const assetsPath = path38.join(this.projectPath, "assets");
     const targetPath = path38.join(this.outputPath, "assets");
-    if (existsSync8(assetsPath)) {
+    if (existsSync7(assetsPath)) {
       await fs18.mkdir(targetPath, { recursive: true });
       await this.copyDirectory(assetsPath, targetPath);
     }
@@ -9688,7 +9865,7 @@ export default bot;`;
   }
   async copyAssetsRuntime() {
     const assetsRuntimePath = path38.join(this.projectPath, ".adk", "assets-runtime.ts");
-    if (existsSync8(assetsRuntimePath)) {
+    if (existsSync7(assetsRuntimePath)) {
       const content = await fs18.readFile(assetsRuntimePath, "utf-8");
       await createFile(path38.join(this.outputPath, "src", "assets-runtime.ts"), await formatCode(content));
     }
@@ -10752,6 +10929,7 @@ class KnowledgeManager {
         const sourcesToSync = options.force ? item.sources || [] : (item.sources || []).filter((s) => s.needsSync);
         const directorySourcesToSync = sourcesToSync.filter((s) => s.dsType === "document");
         const websiteSourcesToSync = sourcesToSync.filter((s) => s.dsType === "web-page");
+        let currentTags = { ...remoteKb.tags ?? {} };
         for (const sourceStatus of directorySourcesToSync) {
           const source = kbRef.definition.sources?.find((s) => s.id === sourceStatus.dsId);
           if (!source || !DataSource.isDirectory(source))
@@ -10764,27 +10942,52 @@ class KnowledgeManager {
           syncOutput.deleted.push(...sourceOutput.deleted);
           syncOutput.errors.push(...sourceOutput.errors);
           const sourceHash = await this.computeDirectorySourceHash(source.directoryPath, source.filterFn);
-          await this.updateSourceHash(remoteKb.id, item.kb.name, source.id, sourceHash, remoteKb.tags);
+          await this.updateSourceHash(remoteKb.id, item.kb.name, source.id, sourceHash, currentTags);
+          currentTags = {
+            ...currentTags,
+            [sourceTag(source.id, "hash")]: sourceHash,
+            [sourceTag(source.id, "lastupdatedat")]: new Date().toISOString()
+          };
         }
-        if (websiteSourcesToSync.length > 0) {
+        for (const sourceStatus of websiteSourcesToSync) {
+          const source = kbRef.definition.sources?.find((s) => s.id === sourceStatus.dsId);
+          if (!source || !DataSource.isWebsite(source))
+            continue;
+          const config = source.getConfig();
+          if (config.mode === "website") {
+            console.warn(`  ⚠️  Skipping website source "${source.id}": website mode requires browser integration for URL discovery. Use WebsiteSource.fromSitemap() instead.`);
+            continue;
+          }
+          if (config.fetchStrategy === "integration:browser") {
+            console.warn(`  ⚠️  Skipping website source "${source.id}": integration:browser fetch strategy requires browser integration. Use fetch: 'node:fetch' or a custom fetch function instead.`);
+            continue;
+          }
+          await this.deleteLegacyWebsiteFiles(item.kb.name, sourceStatus.dsId);
           try {
-            for (const sourceStatus of websiteSourcesToSync) {
-              await this.deleteLegacyWebsiteFiles(item.kb.name, sourceStatus.dsId);
-            }
-            console.log(`  Triggering website sync workflow for ${websiteSourcesToSync.length} source(s)...`);
-            const { workflowId } = await this.syncWebsiteSource(item.kb.name, remoteKb.id, options.force || false);
-            result.websiteSyncs.push({ kbName: item.kb.name, workflowId });
-            for (const sourceStatus of websiteSourcesToSync) {
-              const source = kbRef.definition.sources?.find((s) => s.id === sourceStatus.dsId);
-              if (!source || !DataSource.isWebsite(source))
-                continue;
-              const config = source.getConfig();
-              const configHash = this.computeConfigHash(config);
-              await this.updateSourceHash(remoteKb.id, item.kb.name, source.id, configHash, remoteKb.tags);
-            }
+            this.assertBotId("sync website source");
+            console.log(`  Syncing website source "${source.id}" locally...`);
+            const sourceOutput = await source.syncDirect(client, this.botId, {
+              dsId: source.id,
+              kbName: item.kb.name,
+              kbId: remoteKb.id,
+              force: options.force || false
+            });
+            syncOutput.processed += sourceOutput.processed;
+            syncOutput.added.push(...sourceOutput.added);
+            syncOutput.updated.push(...sourceOutput.updated);
+            syncOutput.deleted.push(...sourceOutput.deleted);
+            syncOutput.errors.push(...sourceOutput.errors.map((e) => typeof e === "string" ? { file: source.id, error: e } : e));
+            const configHash = this.computeConfigHash(config);
+            await this.updateSourceHash(remoteKb.id, item.kb.name, source.id, configHash, currentTags);
+            currentTags = {
+              ...currentTags,
+              [sourceTag(source.id, "hash")]: configHash,
+              [sourceTag(source.id, "lastupdatedat")]: new Date().toISOString()
+            };
           } catch (error) {
             const errorMsg = error instanceof Error ? error.message : String(error);
-            console.warn(`  Warning: Could not trigger website sync: ${errorMsg}`);
+            console.error(`  Failed to sync website source "${source.id}": ${errorMsg}`);
+            syncOutput.errors.push({ file: source.id, error: errorMsg });
           }
         }
         result.synced.push({ name: item.kb.name, result: syncOutput });
@@ -10928,7 +11131,7 @@ class KnowledgeManager {
   }
 }
 // src/knowledge/sync-formatter.ts
-import { readFileSync } from "fs";
+import { readFileSync as readFileSync3 } from "fs";
 import { join as join8 } from "path";
 var getAdkVersion = () => {
   try {
@@ -10937,7 +11140,7 @@ var getAdkVersion = () => {
   } catch {
     try {
       const adkPackagePath = join8(process.cwd(), "node_modules/@botpress/adk/package.json");
-      const pkg = JSON.parse(readFileSync(adkPackagePath, "utf-8"));
+      const pkg = JSON.parse(readFileSync3(adkPackagePath, "utf-8"));
       return pkg.version;
     } catch {
       return "unknown";
@@ -11031,7 +11234,7 @@ class KBSyncFormatter {
 import { watch as watch2, readdirSync as readdirSync2, statSync } from "fs";
 import { EventEmitter as EventEmitter3 } from "events";
 import { join as join9, relative as relative3 } from "path";
-import { existsSync as existsSync9 } from "fs";
+import { existsSync as existsSync8 } from "fs";
 
 class FileWatcher2 extends EventEmitter3 {
   projectPath;
@@ -11049,12 +11252,12 @@ class FileWatcher2 extends EventEmitter3 {
     const rootFiles = ["package.json", "agent.json", "agent.config.ts"];
     for (const file of rootFiles) {
       const filePath = join9(this.projectPath, file);
-      if (existsSync9(filePath)) {
+      if (existsSync8(filePath)) {
         this.watchFile(filePath);
       }
     }
     const srcPath = join9(this.projectPath, "src");
-    if (existsSync9(srcPath)) {
+    if (existsSync8(srcPath)) {
       this.initializeDirectoryState(srcPath);
       this.watchDirectory(srcPath);
     }
@@ -11104,12 +11307,12 @@ class FileWatcher2 extends EventEmitter3 {
   }
   handleFileChange(filePath) {
     try {
-      if (existsSync9(filePath) && statSync(filePath).isDirectory()) {
+      if (existsSync8(filePath) && statSync(filePath).isDirectory()) {
         this.scanDirectoryForChanges(filePath);
         return;
       }
     } catch {}
-    const fileExists = existsSync9(filePath);
+    const fileExists = existsSync8(filePath);
     const previousState = this.fileStates.get(filePath);
     let changeType;
     if (!fileExists && previousState !== undefined) {
@@ -11182,7 +11385,7 @@ class FileWatcher2 extends EventEmitter3 {
     }, this.debounceMs);
   }
   updateFileState(filePath) {
-    if (existsSync9(filePath)) {
+    if (existsSync8(filePath)) {
       this.fileStates.set(filePath, Date.now());
     }
   }
@@ -11264,7 +11467,7 @@ class AgentConfigSyncManager {
 }
 
 // src/preflight/formatter.ts
-import { readFileSync as readFileSync2 } from "fs";
+import { readFileSync as readFileSync4 } from "fs";
 import { join as join10 } from "path";
 var getAdkVersion2 = () => {
   try {
@@ -11273,7 +11476,7 @@ var getAdkVersion2 = () => {
   } catch {
     try {
       const adkPackagePath = join10(process.cwd(), "node_modules/@botpress/adk/package.json");
-      const pkg = JSON.parse(readFileSync2(adkPackagePath, "utf-8"));
+      const pkg = JSON.parse(readFileSync4(adkPackagePath, "utf-8"));
       return pkg.version;
     } catch {
       return "unknown";
@@ -11455,9 +11658,6 @@ class PreflightChecker {
     const toRemove = [];
     const toUpdate = [];
     for (const result of results) {
-      if (result.desiredInstallStatus === "disabled" && !result.needsRemoval && !result.needsConfiguration) {
-        continue;
-      }
       if (result.needsInstall) {
         toInstall.push({
           alias: result.alias,
@@ -11577,7 +11777,7 @@ class PreflightChecker {
 }
 // src/runner/script-runner.ts
 import dedent2 from "dedent";
-import { existsSync as existsSync10 } from "fs";
+import { existsSync as existsSync9 } from "fs";
 import fs20 from "fs/promises";
 import path41 from "path";
 import { spawn } from "child_process";
@@ -11615,7 +11815,7 @@ class ScriptRunner {
     const botPath = path41.join(this.projectPath, ".adk", "bot");
     const runnerPath = path41.join(botPath, "src", "script-runner.ts");
     const botpressTypesPath = path41.join(botPath, ".botpress", "implementation", "index.ts");
-    const needsRegenerate = this.forceRegenerate || !existsSync10(runnerPath) || !existsSync10(botpressTypesPath);
+    const needsRegenerate = this.forceRegenerate || !existsSync9(runnerPath) || !existsSync9(botpressTypesPath);
     if (needsRegenerate) {
       try {
         await generateAssetsTypes(project.path);
@@ -11773,7 +11973,7 @@ class ScriptRunner {
       initialize: async () => {
         const botModule = await import(runtimePath);
         const runtimeModule = await import("@botpress/runtime/runtime");
-        const { Autonomous } = await import("@botpress/runtime");
+        const { Autonomous: Autonomous2 } = await import("@botpress/runtime");
         const { context, agentRegistry } = runtimeModule;
         const { Client: Client18 } = await import("@botpress/client");
         const { BotSpecificClient, BotLogger } = await import("@botpress/sdk");
@@ -11795,7 +11995,7 @@ class ScriptRunner {
           botId,
           client,
           cognitive,
-          citations: new Autonomous.CitationsManager,
+          citations: new Autonomous2.CitationsManager,
           logger,
           configuration: configuration ?? {},
           integrations: agentRegistry.integrations,
@@ -11811,7 +12011,7 @@ class ScriptRunner {
   async run(scriptPath, options = {}) {
     const { botPath, runnerPath, project } = await this.prepare();
     const absoluteScriptPath = path41.isAbsolute(scriptPath) ? scriptPath : path41.resolve(this.projectPath, scriptPath);
-    if (!existsSync10(absoluteScriptPath)) {
+    if (!existsSync9(absoluteScriptPath)) {
       throw new Error(`Script not found: ${absoluteScriptPath}`);
     }
     const botId = this.prod ? project.agentInfo?.botId : project.agentInfo?.devId || project.agentInfo?.botId;
@@ -11900,42 +12100,78 @@ Either run from within an agent project directory, or provide projectPath explic
   return runner.setupTestRuntime({ env: options.env });
 }
 // src/eval/types.ts
-function defineEval(def) {
-  return def;
+class Eval {
+  name;
+  description;
+  tags;
+  type;
+  setup;
+  conversation;
+  outcome;
+  options;
+  constructor(def) {
+    this.name = def.name;
+    this.description = def.description;
+    this.tags = def.tags;
+    this.type = def.type;
+    this.setup = def.setup;
+    this.conversation = def.conversation;
+    this.outcome = def.outcome;
+    this.options = def.options;
+  }
 }
 // src/eval/loader.ts
-import { readdirSync as readdirSync3, existsSync as existsSync11 } from "fs";
+import { readdirSync as readdirSync3, existsSync as existsSync10 } from "fs";
 import { resolve as resolve3 } from "path";
+function isEvalDefinition(value) {
+  return value !== null && typeof value === "object" && typeof value.name === "string" && value.name !== "" && Array.isArray(value.conversation);
+}
 async function loadEvalFile(filePath) {
   const absPath = resolve3(filePath);
   const mod = await import(absPath);
-  const def = mod.default;
-  if (!def || typeof def !== "object" || !def.name || !Array.isArray(def.conversation)) {
-    throw new Error(`Invalid eval file ${filePath}: must export default a defineEval({...}) object with name and conversation`);
+  const results = [];
+  for (const [key, value] of Object.entries(mod)) {
+    if (key === "__esModule")
+      continue;
+    if (value instanceof Eval || isEvalDefinition(value)) {
+      results.push(value);
+    }
   }
-  return def;
+  if (results.length === 0) {
+    throw new Error(`Invalid eval file ${filePath}: no valid evals found. Export one or more \`new Eval({...})\` instances (as default or named exports).`);
+  }
+  return results;
 }
 async function loadEvalsFromDir(dirPath) {
   const absDir = resolve3(dirPath);
-  if (!existsSync11(absDir)) {
+  if (!existsSync10(absDir)) {
     return [];
   }
   const files = readdirSync3(absDir).filter((f) => f.endsWith(".eval.ts"));
   const evals = [];
   for (const f of files) {
-    evals.push(await loadEvalFile(`${absDir}/${f}`));
+    const defs = await loadEvalFile(`${absDir}/${f}`);
+    evals.push(...defs);
+  }
+  const seen = new Set;
+  for (const e of evals) {
+    if (seen.has(e.name)) {
+      throw new Error(`Duplicate eval name "${e.name}" found in ${dirPath}`);
+    }
+    seen.add(e.name);
   }
   return evals;
 }
 async function loadEvalByName(dirPath, name) {
   const absDir = resolve3(dirPath);
-  if (!existsSync11(absDir))
+  if (!existsSync10(absDir))
     return null;
   const files = readdirSync3(absDir).filter((f) => f.endsWith(".eval.ts"));
   for (const f of files) {
-    const def = await loadEvalFile(`${absDir}/${f}`);
-    if (def.name === name)
-      return def;
+    const defs = await loadEvalFile(`${absDir}/${f}`);
+    const found = defs.find((d) => d.name === name);
+    if (found)
+      return found;
   }
   return null;
 }
@@ -13089,11 +13325,11 @@ async function runEvalSuite(config, filter) {
   return runReport;
 }
 // src/eval/store.ts
-import { existsSync as existsSync12, mkdirSync as mkdirSync2, writeFileSync as writeFileSync2, readFileSync as readFileSync3, readdirSync as readdirSync4 } from "fs";
+import { existsSync as existsSync11, mkdirSync as mkdirSync2, writeFileSync as writeFileSync2, readFileSync as readFileSync5, readdirSync as readdirSync4 } from "fs";
 import { join as join11 } from "path";
 function getRunsDir(agentPath) {
   const dir = join11(agentPath, ".adk", "evals", "runs");
-  if (!existsSync12(dir)) {
+  if (!existsSync11(dir)) {
     mkdirSync2(dir, { recursive: true });
   }
   return dir;
@@ -13111,19 +13347,19 @@ function loadRunResult(agentPath, runId) {
   for (const file of files) {
     if (file.includes(runId)) {
       const filepath = join11(dir, file);
-      return JSON.parse(readFileSync3(filepath, "utf-8"));
+      return JSON.parse(readFileSync5(filepath, "utf-8"));
     }
   }
   return null;
 }
 function listRunResults(agentPath, limit = 50) {
   const dir = getRunsDir(agentPath);
-  if (!existsSync12(dir))
+  if (!existsSync11(dir))
     return [];
   const files = readdirSync4(dir).filter((f) => f.endsWith(".json")).sort().reverse().slice(0, limit);
   return files.map((file) => {
     const filepath = join11(dir, file);
-    return JSON.parse(readFileSync3(filepath, "utf-8"));
+    return JSON.parse(readFileSync5(filepath, "utf-8"));
   });
 }
 function getLatestRun(agentPath) {
@@ -13157,7 +13393,6 @@ export {
   generateAssetsRuntime,
   filterEvals,
   dependenciesKeyOrder,
-  defineEval,
   coerceConfigValue,
   buildOpenCodeConfig,
   bpCliImporter,
@@ -13189,6 +13424,7 @@ export {
   IntegrationCache,
   HubCache,
   FileWatcher2 as FileWatcher,
+  Eval,
   EnhancedInterfaceCache,
   DevIdManager,
   CredentialsManager,
@@ -13209,4 +13445,4 @@ export {
   AgentProject
 };
 
-//# debugId=984405F8F441F45F64756E2164756E21
+//# debugId=F162F419B9B9DD1664756E2164756E21