@botpress/adk 1.16.7 → 1.18.0-beta.1

package/dist/index.js

@@ -15,19 +15,22 @@ var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
 // src/agent-project/types.ts
 import { z } from "@botpress/sdk";
-var pluginDependencyMappingSchema, dependenciesSchema, agentInfoSchema, ValidationErrorCode, ValidationSeverity, ProjectState;
+var pluginDependencyMappingSchema, dependenciesSchema, agentInfoSchema, agentLocalInfoSchema, ValidationErrorCode, ValidationSeverity, ProjectState;
 var init_types = __esm(() => {
   pluginDependencyMappingSchema = z.object({
     integrationAlias: z.string(),
     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(),
@@ -40,6 +43,12 @@ var init_types = __esm(() => {
     apiUrl: z.string().optional().describe("The Botpress API URL (e.g., https://api.botpress.cloud)"),
     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) => {
     ValidationErrorCode2["DIRECTORY_NOT_FOUND"] = "DIRECTORY_NOT_FOUND";
     ValidationErrorCode2["DIRECTORY_ACCESS_ERROR"] = "DIRECTORY_ACCESS_ERROR";
@@ -467,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;
@@ -483,29 +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;
-    }
-    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();
@@ -525,10 +584,14 @@ import os from "os";
 class CredentialsManager {
   credentialsPath;
   configDir;
+  profileOverride;
   constructor() {
     this.configDir = path2.join(os.homedir(), ".adk");
     this.credentialsPath = path2.join(this.configDir, "credentials");
   }
+  setProfileOverride(profile) {
+    this.profileOverride = profile;
+  }
   async ensureConfigDir() {
     try {
       await fs2.mkdir(this.configDir, { recursive: true });
@@ -644,23 +707,53 @@ class CredentialsManager {
     await this.writeCredentials(store);
   }
   async getActiveCredentials() {
-    const envProfile = process.env.ADK_PROFILE;
-    const credentials = await this.getCredentials(envProfile);
+    const profileName = this.profileOverride || process.env.ADK_PROFILE;
+    const credentials = await this.getCredentials(profileName);
     if (!credentials) {
-      const profileName = envProfile || "default";
-      throw new Error(`No credentials found for profile '${profileName}'. ` + `Please run 'adk login' to authenticate.`);
+      const displayName = profileName || "default";
+      throw new Error(`No credentials found for profile '${displayName}'. ` + `Please run 'adk login' to authenticate.`);
     }
     return credentials;
   }
+  findProfileByApiUrl(store, apiUrl) {
+    const normalizedUrl = apiUrl.replace(/\/+$/, "");
+    for (const [, credentials] of Object.entries(store.profiles)) {
+      if (!credentials.apiUrl)
+        continue;
+      const profileUrl = credentials.apiUrl.replace(/\/+$/, "");
+      if (profileUrl === normalizedUrl) {
+        return credentials;
+      }
+    }
+    return null;
+  }
   async getAgentCredentials(agentPath) {
-    const baseCredentials = await this.getActiveCredentials();
     const agentInfo = await resolveAgent(agentPath, {
       required: true,
       requireWorkspace: true
     });
+    const agentApiUrl = agentInfo.apiUrl;
+    let baseCredentials;
+    const hasExplicitProfile = !!(this.profileOverride || process.env.ADK_PROFILE);
+    if (hasExplicitProfile) {
+      baseCredentials = await this.getActiveCredentials();
+    } else {
+      const store = await this.readCredentials();
+      const matchingCredentials = this.findProfileByApiUrl(store, agentApiUrl);
+      if (matchingCredentials) {
+        baseCredentials = matchingCredentials;
+      } else {
+        const profileName = store.currentProfile || "default";
+        const activeCredentials = store.profiles[profileName];
+        if (!activeCredentials) {
+          throw new Error(`No credentials found for profile '${profileName}'. ` + `Please run 'adk login' to authenticate.`);
+        }
+        baseCredentials = activeCredentials;
+      }
+    }
     return {
       ...baseCredentials,
-      apiUrl: agentInfo.apiUrl || baseCredentials.apiUrl,
+      apiUrl: agentApiUrl,
       workspaceId: agentInfo.workspaceId,
       botId: agentInfo.botId
     };
@@ -729,7 +822,7 @@ var _format = null, _formatLoaded = false, formatCode = async (code, filepath) =
 `));
     return code;
   }
-}, ADK_VERSION = "1.16.7", relative2 = (from, to) => {
+}, ADK_VERSION = "1.18.0-beta.1", relative2 = (from, to) => {
   const fromDir = path10.dirname(from);
   const relative3 = path10.relative(fromDir, to);
   return relative3.startsWith(".") ? relative3 : `./${relative3}`;
@@ -860,16 +953,31 @@ var init_integration_action_types = __esm(() => {
 var require_package = __commonJS((exports, module) => {
   module.exports = {
     name: "@botpress/adk",
-    version: "1.16.7",
+    version: "1.18.0-beta.1",
     description: "Core ADK library for building AI agents on Botpress",
-    type: "module",
-    main: "dist/index.js",
-    types: "dist/index.d.ts",
+    keywords: [
+      "adk",
+      "agent",
+      "ai",
+      "botpress",
+      "chatbot",
+      "conversational-ai",
+      "development-kit"
+    ],
+    license: "MIT",
+    author: "Botpress",
+    repository: {
+      type: "git",
+      url: "https://github.com/botpress/adk"
+    },
     files: [
       "dist/**/*",
       "package.json",
       "README.md"
     ],
+    type: "module",
+    main: "dist/index.js",
+    types: "dist/index.d.ts",
     exports: {
       ".": {
         types: "./dist/index.d.ts",
@@ -884,33 +992,18 @@ var require_package = __commonJS((exports, module) => {
       watch: "bun run build:types && bun build ./src/index.ts --outdir ./dist --target node --format esm --sourcemap --watch",
       clean: "rm -rf dist",
       prepublishOnly: "bun run clean && bun run build",
-      test: "vitest run",
-      "test:watch": "vitest",
-      "test:ui": "vitest --ui",
-      "test:coverage": "vitest run --coverage"
-    },
-    keywords: [
-      "botpress",
-      "adk",
-      "agent",
-      "ai",
-      "chatbot",
-      "conversational-ai",
-      "development-kit"
-    ],
-    author: "Botpress",
-    license: "MIT",
-    repository: {
-      type: "git",
-      url: "https://github.com/botpress/adk"
+      test: "bun test",
+      "test:watch": "bun test --watch",
+      "test:coverage": "bun test",
+      "check:type": "tsc --noEmit"
     },
     dependencies: {
-      "@botpress/chat": "^0.5.5",
-      "@botpress/cli": "5.2.0",
-      "@botpress/client": "1.35.0",
-      "@botpress/cognitive": "0.3.14",
-      "@botpress/runtime": "^1.16.7",
-      "@botpress/sdk": "5.4.3",
+      "@botpress/chat": "0.5.5",
+      "@botpress/cli": "6.2.2",
+      "@botpress/client": "1.38.1",
+      "@botpress/cognitive": "0.4.2",
+      "@botpress/runtime": "^1.18.0-beta.1",
+      "@botpress/sdk": "6.3.1",
       "@bpinternal/jex": "^1.2.4",
       "@bpinternal/yargs-extra": "^0.0.21",
       "@parcel/watcher": "^2.5.1",
@@ -923,19 +1016,12 @@ var require_package = __commonJS((exports, module) => {
       semver: "^7.7.2",
       "ts-morph": "^27.0.2"
     },
-    devDependencies: {
-      "@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"
     },
     engines: {
-      node: ">=22.0.0",
-      bun: ">=1.3.9"
+      bun: ">=1.3.9",
+      node: ">=22.0.0"
     },
     packageManager: "bun@1.3.9"
   };
@@ -1104,6 +1190,9 @@ class Auth {
   async setCurrentProfile(profileName) {
     return this.credentialsManager.setCurrentProfile(profileName);
   }
+  setProfileOverride(profile) {
+    this.credentialsManager.setProfileOverride(profile);
+  }
   async getActiveCredentials() {
     return this.credentialsManager.getActiveCredentials();
   }
@@ -1153,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 = "5.2.0";
+var BP_CLI_VERSION = "6.2.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");
@@ -1648,9 +1737,9 @@ class BpDevCommand extends BaseCommand {
     if (sourceMap) {
       bpArgs.push("--sourceMap");
     }
-    const consoleUrl = `http://localhost:${this.options.internalOtlpPort}`;
+    const spanIngestUrl = `http://localhost:${this.options.spanIngestPort}`;
     const otlpEndpoint = this.options.otlpPort ? `http://localhost:${this.options.otlpPort}` : undefined;
-    const traceLines = [`[bp-dev] Trace endpoints:`, `  ADK_CONSOLE_URL=${consoleUrl}`];
+    const traceLines = [`[bp-dev] Trace endpoints:`, `  ADK_SPAN_INGEST_URL=${spanIngestUrl}`];
     if (otlpEndpoint) {
       traceLines.push(`  OTEL_EXPORTER_OTLP_ENDPOINT=${otlpEndpoint}`);
     }
@@ -1673,7 +1762,7 @@ class BpDevCommand extends BaseCommand {
         },
         WORKER_MODE: "true",
         WORKER_LIFETIME_MS: process.env.WORKER_LIFETIME_MS || "120000",
-        ADK_CONSOLE_URL: consoleUrl,
+        ADK_SPAN_INGEST_URL: spanIngestUrl,
         ...otlpEndpoint && { OTEL_EXPORTER_OTLP_ENDPOINT: otlpEndpoint },
         ...this.options.botName && { ADK_BOT_NAME: this.options.botName },
         ADK_DIRECTORY: join2(botPath, ".."),
@@ -1902,10 +1991,11 @@ class BpChatCommand extends BaseCommand {
     try {
       await this.childProcess;
     } catch (error) {
+      const errObj = error != null && typeof error === "object" ? error : {};
       this.emit("error", {
-        exitCode: error.exitCode || 1,
-        stderr: error.stderr || "",
-        message: error.message || "Chat command failed"
+        exitCode: "exitCode" in errObj ? errObj.exitCode || 1 : 1,
+        stderr: "stderr" in errObj ? errObj.stderr || "" : "",
+        message: error instanceof Error ? error.message || "Chat command failed" : "Chat command failed"
       });
       throw error;
     }
@@ -1986,8 +2076,8 @@ You also have access to Botpress documentation search for platform-level questio
 **Never read or display the contents of .env files or credentials.** If you need to verify a configuration value, ask the developer to confirm it.`;
 function buildOpenCodeConfig(options) {
   const command = [options.adkBinPath, "mcp", "--cwd", options.agentPath];
-  if (options.devServerPort)
-    command.push("--port", String(options.devServerPort));
+  if (options.uiServerPort)
+    command.push("--port", String(options.uiServerPort));
   return {
     ...options.openCodePort && {
       server: {
@@ -2060,7 +2150,7 @@ class OpenCodeCommand extends BaseCommand {
     const opencodeConfig = JSON.stringify(buildOpenCodeConfig({
       adkBinPath: adkBin,
       agentPath: cwd,
-      devServerPort: this.options.devServerPort,
+      uiServerPort: this.options.uiServerPort,
       openCodePort: port,
       corsOrigins
     }));
@@ -2122,7 +2212,13 @@ class OpenCodeCommand extends BaseCommand {
       } catch {}
       await new Promise((r) => setTimeout(r, 500));
     }
-    this.emitReady();
+    if (!this.readyEmitted && !this.killed) {
+      this.emit("progress", {
+        type: "error",
+        startTime: Date.now(),
+        data: { reason: "OpenCode server did not respond in time" }
+      });
+    }
   }
   kill(signal = "SIGTERM") {
     this.killed = true;
@@ -2207,7 +2303,8 @@ function getChatClient(cwd = process.cwd()) {
   return Client4;
 }
 // src/utils/json-ordering.ts
-var agentInfoKeyOrder = ["botId", "workspaceId", "apiUrl", "devId"];
+var agentInfoKeyOrder = ["botId", "workspaceId", "apiUrl"];
+var agentLocalInfoKeyOrder = ["botId", "workspaceId", "apiUrl", "devId"];
 var dependenciesKeyOrder = ["integrations"];
 var integrationKeyOrder = ["version", "enabled", "configurationType", "config"];
 function orderKeys(obj, keyOrder) {
@@ -2258,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";
@@ -2292,7 +2390,7 @@ class AssetsCacheManager {
       const content = await fs4.readFile(this.cachePath, "utf-8");
       this.cache = JSON.parse(content);
       return this.cache;
-    } catch (error) {
+    } catch {
       this.cache = {
         version: "1.0",
         entries: {}
@@ -2825,7 +2923,7 @@ class EnhancedIntegrationCache {
 
 // src/agent-project/dependencies-parser.ts
 init_validation_errors();
-import { z as z2, ZodIssueCode } from "@botpress/sdk";
+import { z as z2 } from "@botpress/sdk";
 var INTEGRATION_ALIAS_MIN_LENGTH = 2;
 var INTEGRATION_ALIAS_MAX_LENGTH = 100;
 var INTEGRATION_ALIAS_REGEX = /^(?:[a-z][a-z0-9_-]*\/)?[a-z][a-z0-9_-]*$/;
@@ -2836,10 +2934,10 @@ var integrationRefSchema = z2.string().transform((val, ctx) => {
   const match = val.match(/^(?:([^/]+)\/)?([^@]+)@(.+)$/);
   if (!match) {
     ctx.addIssue({
-      code: ZodIssueCode.custom,
+      code: "custom",
       message: `Invalid integration version format: ${val}. Expected format: 'name@version' or 'workspace/name@version'`
     });
-    return z2.NEVER;
+    return;
   }
   const [, workspace, name, version] = match;
   return {
@@ -2876,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));
@@ -2884,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)}`));
@@ -2938,10 +3037,10 @@ var pluginRefSchema = z2.string().transform((val, ctx) => {
   const match = val.match(/^([^/@]+)@(.+)$/);
   if (!match) {
     ctx.addIssue({
-      code: ZodIssueCode.custom,
+      code: "custom",
       message: `Invalid plugin version format: ${val}. Expected format: 'name@version' (no workspace prefix)`
     });
-    return z2.NEVER;
+    return;
   }
   const [, name, version] = match;
   return {
@@ -2998,7 +3097,7 @@ class PluginParser {
       if (!pluginConfig.dependencies) {
         continue;
       }
-      for (const [depAlias, depMapping] of Object.entries(pluginConfig.dependencies)) {
+      for (const [_depAlias, depMapping] of Object.entries(pluginConfig.dependencies)) {
         if (!integrationAliases.includes(depMapping.integrationAlias)) {
           errors.push(ValidationErrors.invalidPluginDependency(alias, depMapping.integrationAlias, integrationAliases));
         }
@@ -3203,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);
@@ -3269,7 +3368,7 @@ class IntegrationCache {
         }
       }
       return cached.definition;
-    } catch (error) {
+    } catch {
       return null;
     }
   }
@@ -3473,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 {
@@ -3482,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";
     });
@@ -3502,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");
@@ -3523,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");
@@ -3634,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);
@@ -3667,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 = {};
@@ -3686,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}`
         };
       }
     }
@@ -3702,7 +3971,7 @@ class IntegrationOperations {
       const loadResult = await tempManager.loadIntegrations({
         integrations: {
           [alias]: {
-            version: `${ref.fullName}@${ref.version}`,
+            version: resolvedInput.ref,
             enabled: true
           }
         }
@@ -3720,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;
@@ -3840,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 {
@@ -3932,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();
@@ -3955,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
@@ -4080,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,
@@ -4108,7 +4323,7 @@ class IntegrationChecker {
       }
     }
     if (!installedIntegration) {
-      result.needsInstall = enabled !== false;
+      result.needsInstall = true;
       if (result.needsInstall && config) {
         result.needsConfiguration = true;
       }
@@ -4128,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;
@@ -4658,7 +4869,7 @@ async function expandExports(options) {
         });
         return {};
       }
-      currentError = currentError.cause;
+      currentError = currentError instanceof Error ? currentError.cause : undefined;
     }
     throw importError;
   }
@@ -4669,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;
@@ -4692,6 +4918,7 @@ class AgentProject {
   _workflows = [];
   _actions = [];
   _tables = [];
+  _tools = [];
   constructor(projectPath, options = {}) {
     this._options = options;
     this._path = path13.resolve(projectPath);
@@ -4748,6 +4975,9 @@ class AgentProject {
   get tables() {
     return this._tables;
   }
+  get tools() {
+    return this._tools;
+  }
   get config() {
     return this._config;
   }
@@ -4786,6 +5016,7 @@ class AgentProject {
       this._workflows = [];
       this._actions = [];
       this._tables = [];
+      this._tools = [];
       this._errors = [];
       this._warnings = [];
       const validation = await this.validate();
@@ -4924,20 +5155,84 @@ class AgentProject {
     return this._assetsManager;
   }
   async createAgentInfo(info) {
+    const { devId, ...agentJsonInfo } = info;
     const agentPath = path13.join(this._path, "agent.json");
-    const agentContent = stringifyWithOrder(info, agentInfoKeyOrder);
+    const agentContent = stringifyWithOrder(agentJsonInfo, agentInfoKeyOrder);
     await fs10.writeFile(agentPath, agentContent);
     this._agentInfo = info;
+    if (devId) {
+      await this.createAgentLocalInfo({ devId });
+    }
   }
   async updateAgentInfo(updates) {
     if (!this._agentInfo) {
       throw new Error("No agent.json found. Use createAgentInfo() first.");
     }
-    const updatedInfo = { ...this._agentInfo, ...updates };
+    const { devId, ...agentJsonUpdates } = updates;
+    const updatedInfo = { ...this._agentInfo, ...agentJsonUpdates };
+    const { devId: _devId, ...agentJsonData } = updatedInfo;
     const agentPath = path13.join(this._path, "agent.json");
-    const agentContent = stringifyWithOrder(updatedInfo, agentInfoKeyOrder);
+    const agentContent = stringifyWithOrder(agentJsonData, agentInfoKeyOrder);
     await fs10.writeFile(agentPath, agentContent);
     this._agentInfo = updatedInfo;
+    if (devId !== undefined) {
+      await this.updateAgentLocalInfo({ devId });
+    }
+  }
+  async createAgentLocalInfo(info) {
+    const localPath = path13.join(this._path, "agent.local.json");
+    let existing = {};
+    try {
+      const content2 = await fs10.readFile(localPath, "utf-8");
+      existing = JSON.parse(content2);
+    } catch {}
+    const merged = { ...existing, ...info };
+    const content = stringifyWithOrder(merged, agentLocalInfoKeyOrder);
+    await fs10.writeFile(localPath, content);
+    if (this._agentInfo) {
+      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) {
+    const localPath = path13.join(this._path, "agent.local.json");
+    let existing = {};
+    try {
+      const content2 = await fs10.readFile(localPath, "utf-8");
+      existing = JSON.parse(content2);
+    } catch {}
+    const updated = { ...existing, ...updates };
+    for (const key of Object.keys(updated)) {
+      if (updated[key] === undefined) {
+        delete updated[key];
+      }
+    }
+    const content = stringifyWithOrder(updated, agentLocalInfoKeyOrder);
+    await fs10.writeFile(localPath, content);
+    if (this._agentInfo) {
+      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) {
     if (!this._agentInfo?.botId) {
@@ -5128,6 +5423,32 @@ ${err.stack?.split(`
       console.warn(`Failed to register data source workflows for ${kbPath}:`, error);
     }
   }
+  isBarrelReexport(existing, newPath, newExport, newDefinition) {
+    const isNewBarrel = /^index\.[tj]s$/i.test(path13.basename(newPath));
+    const isExistingBarrel = /^index\.[tj]s$/i.test(path13.basename(existing.path));
+    if (!isNewBarrel && !isExistingBarrel) {
+      return false;
+    }
+    if (isExistingBarrel && !isNewBarrel) {
+      existing.path = newPath;
+      existing.export = newExport;
+      existing.definition = newDefinition;
+    }
+    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 ["*"];
@@ -5210,6 +5531,9 @@ ${err.stack?.split(`
               return existingChannels.some((ch) => newChannels.includes(ch));
             });
             if (overlapping) {
+              if (this.isBarrelReexport(overlapping, relPath, key, definition)) {
+                continue;
+              }
               this._warnings.push({
                 $type: "ValidationError",
                 code: "DUPLICATE_PRIMITIVE" /* DUPLICATE_PRIMITIVE */,
@@ -5227,6 +5551,9 @@ ${err.stack?.split(`
           } else if (Primitives2.Definitions.isKnowledgeDefinition(definition)) {
             const existing = this._knowledge.find((p) => p.definition.name === definition.name);
             if (existing) {
+              if (this.isBarrelReexport(existing, relPath, key, definition)) {
+                continue;
+              }
               this._warnings.push({
                 $type: "ValidationError",
                 code: "DUPLICATE_PRIMITIVE" /* DUPLICATE_PRIMITIVE */,
@@ -5245,6 +5572,9 @@ ${err.stack?.split(`
           } else if (Primitives2.Definitions.isTriggerDefinition(definition)) {
             const existing = this._triggers.find((p) => p.definition.name === definition.name);
             if (existing) {
+              if (this.isBarrelReexport(existing, relPath, key, definition)) {
+                continue;
+              }
               this._warnings.push({
                 $type: "ValidationError",
                 code: "DUPLICATE_PRIMITIVE" /* DUPLICATE_PRIMITIVE */,
@@ -5262,6 +5592,9 @@ ${err.stack?.split(`
           } else if (Primitives2.Definitions.isWorkflowDefinition(definition)) {
             const existing = this._workflows.find((p) => p.definition.name === definition.name);
             if (existing) {
+              if (this.isBarrelReexport(existing, relPath, key, definition)) {
+                continue;
+              }
               this._warnings.push({
                 $type: "ValidationError",
                 code: "DUPLICATE_PRIMITIVE" /* DUPLICATE_PRIMITIVE */,
@@ -5279,6 +5612,9 @@ ${err.stack?.split(`
           } else if (Primitives2.Definitions.isActionDefinition(definition)) {
             const existing = this._actions.find((p) => p.definition.name === definition.name);
             if (existing) {
+              if (this.isBarrelReexport(existing, relPath, key, definition)) {
+                continue;
+              }
               this._warnings.push({
                 $type: "ValidationError",
                 code: "DUPLICATE_PRIMITIVE" /* DUPLICATE_PRIMITIVE */,
@@ -5296,6 +5632,9 @@ ${err.stack?.split(`
           } else if (Primitives2.Definitions.isTableDefinition(definition)) {
             const existing = this._tables.find((p) => p.definition.name === definition.name);
             if (existing) {
+              if (this.isBarrelReexport(existing, relPath, key, definition)) {
+                continue;
+              }
               this._warnings.push({
                 $type: "ValidationError",
                 code: "DUPLICATE_PRIMITIVE" /* DUPLICATE_PRIMITIVE */,
@@ -5310,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) {
@@ -5593,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
@@ -5619,22 +5989,38 @@ adk deploy   # Deploy to Botpress Cloud
 adk chat     # Chat with your agent in the terminal
 \`\`\`
 
-## AI Coding Assistant Skills
+## MCP Tools (ADK Dev Server)
 
-This project uses the Botpress ADK. Before making changes, use the relevant skill:
+This project includes an MCP server that provides AI coding assistants with deep ADK integration.
+Run \`adk mcp:init --all\` to generate configuration for your editor, or use the tools below directly.
 
-| Skill              | Use for                                          |
-| ------------------ | ------------------------------------------------ |
-| \`/adk\`             | ADK concepts, patterns, and API reference        |
-| \`/adk-integration\` | Finding and using Botpress integrations           |
-| \`/adk-debugger\`    | Debugging with traces and test conversations      |
-| \`/adk-frontend\`    | Building frontends that connect to ADK bots       |
+### Debugging & Testing
 
-If these skills are not installed, install them:
+| Tool               | Use for                                                      |
+| ------------------ | ------------------------------------------------------------ |
+| \`adk_send_message\` | Send a test message to the running bot and receive responses |
+| \`adk_query_traces\` | Query trace spans for debugging conversations and workflows  |
+| \`adk_get_dev_logs\` | Get dev server logs, build output, errors, and warnings      |
 
-\`\`\`
-npx skills add botpress/skills --skill adk
-\`\`\`
+### Project & Integration Management
+
+| Tool                      | Use for                                                     |
+| ------------------------- | ----------------------------------------------------------- |
+| \`adk_get_agent_info\`      | Get project info: name, version, and all primitives         |
+| \`adk_search_integrations\` | Search available integrations on the Botpress Hub           |
+| \`adk_get_integration\`     | Get detailed info about an integration before adding it     |
+| \`adk_add_integration\`     | Add an integration to the project (updates agent.config.ts) |
+
+### Workflows
+
+| 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.
 
 ## Project Overview
 
@@ -5650,6 +6036,30 @@ npx skills add botpress/skills --skill adk
 `;
 
 // 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;
@@ -5661,16 +6071,125 @@ class AgentProjectGenerator {
     this.packageManager = packageManager;
     this.template = template;
   }
-  async generate() {
-    this.ensureEmptyDirectory();
-    this.createPackageJson();
-    await this.createAgentConfig();
-    this.createTsConfig();
-    this.createAgentJson();
-    this.createGitIgnore();
-    await this.createReadme();
-    this.createAIAssistantInstructions();
-    await this.createSourceStructure();
+  async generate() {
+    this.ensureEmptyDirectory();
+    const templateDir = this.resolveTemplateDir();
+    await this.copyTemplateFiles(templateDir);
+    if (!fs11.existsSync(path15.join(this.projectPath, "agent.json"))) {
+      this.createAgentJson();
+    }
+    if (!fs11.existsSync(path15.join(this.projectPath, "CLAUDE.md"))) {
+      this.createAIAssistantInstructions();
+    }
+  }
+  static getAvailableTemplates() {
+    try {
+      const templatesRoot = AgentProjectGenerator.getTemplatesRoot();
+      const configPath = path15.join(templatesRoot, "template.config.json");
+      if (!fs11.existsSync(configPath)) {
+        return [];
+      }
+      const raw = fs11.readFileSync(configPath, "utf-8");
+      const registry = JSON.parse(raw);
+      return registry.templates;
+    } catch {
+      return [];
+    }
+  }
+  getPostInitCommands() {
+    const templates = AgentProjectGenerator.getAvailableTemplates();
+    const config = templates.find((t) => t.name === this.template);
+    return config?.postInit ?? [];
+  }
+  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.
+
+Searched:
+${tried}
+
+Ensure the ADK package is properly installed or run the CLI build.`);
+  }
+  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.1",
+      "{{packageManager}}": this.packageManager
+    };
+    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)) {
@@ -5681,229 +6200,19 @@ class AgentProjectGenerator {
       throw new Error(`Directory ${this.projectPath} is not empty. Please use an empty directory.`);
     }
   }
-  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.16.7"}`
-      },
-      devDependencies: {
-        typescript: "^5.9.3"
-      }
-    };
-    if (packageJson.packageManager === undefined) {
-      delete packageJson.packageManager;
-    }
-    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;
-  }
-  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({}),
-  },
-
-  user: {
-    state: z.object({}),
-  },
-
-  dependencies: {
-    integrations: ${integrationsJson},
-  },
-});
-`;
-    await this.writeFormattedFile("agent.config.ts", agentConfig);
-  }
-  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"]
-    };
-    this.writeJsonFile("tsconfig.json", tsConfig);
-  }
   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
-
-# 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) + `
 `);
@@ -6227,7 +6536,7 @@ if (typeof globalThis !== 'undefined') {
   }
 }
 // src/generators/integration-types.ts
-import { transforms } from "@botpress/sdk";
+import { z as z3 } from "@botpress/sdk";
 import crypto2 from "crypto";
 import path18 from "path";
 
@@ -6255,6 +6564,7 @@ function getPluginAlias(pluginName) {
 }
 
 // src/generators/integration-types.ts
+var { transforms } = z3;
 var getIntegrationHash = (integration) => {
   return crypto2.createHash("sha256").update(`${integration.alias}|${integration.definition?.id}|${integration.definition?.version}|${integration.definition?.updatedAt}`).digest("hex");
 };
@@ -6487,9 +6797,10 @@ Description: ${tag?.description}`);
   }
   if (integration.definition?.configurations) {
     for (const [key, config] of Object.entries(integration.definition.configurations)) {
-      const title = config.title || key;
-      const description = config.description || "";
-      const schema = config.schema;
+      const configRecord = config;
+      const title = configRecord.title || key;
+      const description = configRecord.description || "";
+      const schema = configRecord.schema;
       let tsType = "{}";
       if (schema) {
         tsType = transforms.fromJSONSchema(schema).toTypescriptType();
@@ -6606,12 +6917,14 @@ async function generateClientWrapper(project) {
           let schema;
           let computed = false;
           if (typeof colDef === "object" && colDef !== null && "schema" in colDef) {
-            schema = colDef.schema;
-            computed = colDef.computed || false;
+            const colDefRecord = colDef;
+            schema = colDefRecord.schema;
+            computed = colDefRecord.computed || false;
           } else {
             schema = colDef;
           }
-          const tsType = schema.toTypescriptType ? schema.toTypescriptType({ treatDefaultAsOptional: true }) : "any";
+          const schemaObj = schema;
+          const tsType = typeof schemaObj.toTypescriptType === "function" ? schemaObj.toTypescriptType({ treatDefaultAsOptional: true }) : "any";
           if (!computed) {
             inputColumns.push(`${colName}: ${tsType}`);
           }
@@ -6921,15 +7234,16 @@ 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";
 
 // src/generators/plugin-types.ts
-import { transforms as transforms2 } from "@botpress/sdk";
+import { z as z4 } from "@botpress/sdk";
 import crypto4 from "crypto";
 import path20 from "path";
 init_utils();
+var { transforms: transforms2 } = z4;
 function stripRefs(schema) {
   if (typeof schema !== "object" || schema === null) {
     return schema;
@@ -7075,10 +7389,11 @@ export type PluginActions = PluginsMap<Plugins>;
 }
 
 // src/generators/interface-types.ts
-import { transforms as transforms3 } from "@botpress/sdk";
+import { z as z5 } from "@botpress/sdk";
 import crypto5 from "crypto";
 import path22 from "path";
 init_utils();
+var { transforms: transforms3 } = z5;
 var sameMajorVersion = (a, b) => {
   const majorA = a.split(".")[0];
   const majorB = b.split(".")[0];
@@ -7804,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;
@@ -7840,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 {};
@@ -7864,7 +8196,7 @@ class DevIdManager {
       if (!project.agentInfo) {
         throw ValidationErrors.agentNotLinked();
       }
-      await project.updateAgentInfo({
+      await project.updateAgentLocalInfo({
         devId: projectCache.devId
       });
     }
@@ -7891,18 +8223,24 @@ class DevIdManager {
         const client = await this.getClient();
         await client.getBot({ id: agentInfo.devId });
         return true;
-      } catch (error) {
+      } catch {
         return false;
       }
     }
     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;
@@ -7942,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");
@@ -7980,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 });
     }
   }
@@ -8025,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;
@@ -8053,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");
@@ -8105,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 });
     }
   }
@@ -8150,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;
@@ -8182,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");
@@ -8220,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 });
     }
   }
@@ -8264,10 +8602,11 @@ class PluginSync {
 
 // src/bot-generator/generator.ts
 init_utils();
-import { transforms as transforms4 } from "@botpress/sdk";
+import { z as z6 } from "@botpress/sdk";
 init_constants();
 import { BuiltInActions as BuiltInActions2, BuiltInWorkflows as BuiltInWorkflows4, Primitives as Primitives3 } from "@botpress/runtime/internal";
 import { BUILT_IN_TAGS as BUILT_IN_TAGS2 } from "@botpress/runtime/definition";
+var { transforms: transforms4 } = z6;
 var plural = (n, word) => `${n} ${word}${n === 1 ? "" : "s"}`;
 function isBuiltinWorkflow3(name) {
   return !!Object.values(BuiltInWorkflows4).find((x) => x.name === name);
@@ -8292,7 +8631,7 @@ class BotGenerator {
   }
   async listFilesRecursive(rootDir) {
     try {
-      if (!existsSync8(rootDir))
+      if (!existsSync7(rootDir))
         return [];
       const result = [];
       const walk = async (dir, relativeBase) => {
@@ -8314,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 });
@@ -8520,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}"`);
@@ -8578,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;
@@ -8643,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}`);
@@ -8748,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) {
@@ -9191,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);
     }
@@ -9281,7 +9617,9 @@ export default bot;`;
     }
     {
       const dest = path38.join(srcDir, "triggers.ts");
-      const { transforms: transforms5 } = await import("@botpress/sdk");
+      const {
+        z: { transforms: transforms5 }
+      } = await import("@botpress/sdk");
       const imports = new Map;
       const exports = new Set;
       const payloadTypes = {};
@@ -9527,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));
     }
@@ -9569,7 +9907,9 @@ async function generateBotProject(options) {
 }
 // src/tables/table-manager.ts
 import { Client as Client15 } from "@botpress/client";
-import { transforms as transforms5 } from "@botpress/sdk";
+import { z as z7 } from "@botpress/sdk";
+var { transforms: transforms5 } = z7;
+
 class TableManager {
   client;
   botId;
@@ -9600,13 +9940,14 @@ class TableManager {
   }
   getSchemaType(schema) {
     if (schema.type) {
-      if (schema.type === "array" && schema.items?.type) {
-        return `array<${schema.items.type}>`;
+      const items = schema.items;
+      if (schema.type === "array" && items?.type) {
+        return `array<${items.type}>`;
       }
-      return schema.type;
+      return String(schema.type);
     }
     if (schema.$ref) {
-      return schema.$ref.split("/").pop() || "unknown";
+      return String(schema.$ref).split("/").pop() || "unknown";
     }
     return "unknown";
   }
@@ -9617,8 +9958,8 @@ class TableManager {
     } else if (Math.abs(oldPosition - newPosition) <= 1) {
       score += 1;
     }
-    const oldDesc = (oldSchema?.description || "").toLowerCase();
-    const newDesc = (newSchema?.description || "").toLowerCase();
+    const oldDesc = String(oldSchema?.description || "").toLowerCase();
+    const newDesc = String(newSchema?.description || "").toLowerCase();
     if (oldDesc && newDesc && oldDesc === newDesc) {
       score += 5;
     } else if (oldDesc && newDesc && oldDesc.length > 5 && newDesc.length > 5) {
@@ -9633,8 +9974,10 @@ class TableManager {
         }
       }
     }
-    const oldOptional = oldSchema?.type?.includes("null") || oldSchema?.nullable === true;
-    const newOptional = newSchema?.type?.includes("null") || newSchema?.nullable === true;
+    const oldType = oldSchema?.type;
+    const newType = newSchema?.type;
+    const oldOptional = typeof oldType === "string" && oldType.includes("null") || oldSchema?.nullable === true;
+    const newOptional = typeof newType === "string" && newType.includes("null") || newSchema?.nullable === true;
     if (oldOptional === newOptional) {
       score += 1;
     }
@@ -10586,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))
@@ -10598,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 });
@@ -10762,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 {
@@ -10771,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";
@@ -10862,10 +11231,10 @@ class KBSyncFormatter {
   }
 }
 // src/file-watcher/watcher.ts
-import { watch as watch2, readdirSync as readdirSync2 } from "fs";
+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;
@@ -10883,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);
     }
@@ -10904,7 +11273,7 @@ class FileWatcher2 extends EventEmitter3 {
           this.updateFileState(fullPath);
         }
       }
-    } catch (error) {}
+    } catch {}
   }
   watchFile(filePath) {
     if (this.watchers.has(filePath)) {
@@ -10937,7 +11306,13 @@ class FileWatcher2 extends EventEmitter3 {
     }
   }
   handleFileChange(filePath) {
-    const fileExists = existsSync9(filePath);
+    try {
+      if (existsSync8(filePath) && statSync(filePath).isDirectory()) {
+        this.scanDirectoryForChanges(filePath);
+        return;
+      }
+    } catch {}
+    const fileExists = existsSync8(filePath);
     const previousState = this.fileStates.get(filePath);
     let changeType;
     if (!fileExists && previousState !== undefined) {
@@ -10957,12 +11332,7 @@ class FileWatcher2 extends EventEmitter3 {
       path: relativePath,
       type: changeType
     });
-    if (this.debounceTimer) {
-      clearTimeout(this.debounceTimer);
-    }
-    this.debounceTimer = setTimeout(() => {
-      this.emitPendingChanges();
-    }, this.debounceMs);
+    this.scheduleDebouncedEmit();
   }
   emitPendingChanges() {
     if (this.pendingChanges.size === 0) {
@@ -10976,8 +11346,46 @@ class FileWatcher2 extends EventEmitter3 {
     };
     this.emit("change", event);
   }
+  scanDirectoryForChanges(dirPath) {
+    try {
+      const entries = readdirSync2(dirPath, { withFileTypes: true });
+      const currentFiles = new Set;
+      for (const entry of entries) {
+        const fullPath = join9(dirPath, entry.name);
+        if (entry.isFile()) {
+          currentFiles.add(fullPath);
+          if (!this.fileStates.has(fullPath)) {
+            this.updateFileState(fullPath);
+            const relativePath = relative3(this.projectPath, fullPath);
+            this.pendingChanges.set(relativePath, { path: relativePath, type: "added" });
+            this.scheduleDebouncedEmit();
+          }
+        } else if (entry.isDirectory()) {
+          this.scanDirectoryForChanges(fullPath);
+        }
+      }
+      for (const [trackedPath] of this.fileStates) {
+        if (trackedPath.startsWith(dirPath) && !trackedPath.includes("/", dirPath.length + 1)) {
+          if (!currentFiles.has(trackedPath)) {
+            this.fileStates.delete(trackedPath);
+            const relativePath = relative3(this.projectPath, trackedPath);
+            this.pendingChanges.set(relativePath, { path: relativePath, type: "deleted" });
+            this.scheduleDebouncedEmit();
+          }
+        }
+      }
+    } catch {}
+  }
+  scheduleDebouncedEmit() {
+    if (this.debounceTimer) {
+      clearTimeout(this.debounceTimer);
+    }
+    this.debounceTimer = setTimeout(() => {
+      this.emitPendingChanges();
+    }, this.debounceMs);
+  }
   updateFileState(filePath) {
-    if (existsSync9(filePath)) {
+    if (existsSync8(filePath)) {
       this.fileStates.set(filePath, Date.now());
     }
   }
@@ -11059,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 {
@@ -11068,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";
@@ -11250,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,
@@ -11372,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";
@@ -11410,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);
@@ -11568,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");
@@ -11590,7 +11995,7 @@ class ScriptRunner {
           botId,
           client,
           cognitive,
-          citations: new Autonomous.CitationsManager,
+          citations: new Autonomous2.CitationsManager,
           logger,
           configuration: configuration ?? {},
           integrations: agentRegistry.integrations,
@@ -11606,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;
@@ -11695,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);
+    }
+  }
+  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 def;
+  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;
 }
@@ -11755,6 +12196,7 @@ function filterEvals(evals, filter) {
 }
 // src/eval/runner.ts
 import { Client as BpClient2 } from "@botpress/client";
+import { BUILT_IN_STATES as BUILT_IN_STATES2 } from "@botpress/runtime/internal";
 
 // src/eval/client.ts
 import { Client as BpClient } from "@botpress/client";
@@ -11775,20 +12217,21 @@ class ChatSession {
     }
     return this.client.user.id;
   }
-  async sendMessage(message, options = {}) {
+  async ensureConversation() {
     if (!this.client) {
       throw new Error("ChatSession not connected. Call connect() first.");
     }
-    const { timeout = 30000, idleTimeout = 3000 } = options;
     if (!this.conversationId) {
       const conv = await this.client.createConversation({});
       this.conversationId = conv.conversation.id;
+      return conv.conversation.id;
     }
-    const conversationId = this.conversationId;
+    return this.conversationId;
+  }
+  async _awaitResponses(conversationId, trigger, options = {}) {
+    const { timeout = 30000, idleTimeout = 3000 } = options;
     const responses = [];
-    const listener = await this.client.listenConversation({
-      id: conversationId
-    });
+    const listener = await this.client.listenConversation({ id: conversationId });
     return new Promise((resolve4, reject) => {
       let idleTimer = null;
       let resolved = false;
@@ -11808,7 +12251,7 @@ class ChatSession {
       };
       const overallTimer = setTimeout(() => {
         if (!resolved) {
-          if (responses.length > 0) {
+          if (responses.length > 0 || options.expectSilence) {
             done();
           } else {
             resolved = true;
@@ -11831,10 +12274,7 @@ class ChatSession {
           done();
         }
       });
-      this.client.createMessage({
-        conversationId,
-        payload: { type: "text", text: message }
-      }).then(() => {
+      trigger().then(() => {
         resetIdle();
       }).catch((err) => {
         clearTimeout(overallTimer);
@@ -11845,6 +12285,20 @@ class ChatSession {
       });
     });
   }
+  async sendMessage(message, options = {}) {
+    if (!this.client) {
+      throw new Error("ChatSession not connected. Call connect() first.");
+    }
+    const conversationId = await this.ensureConversation();
+    return this._awaitResponses(conversationId, () => this.client.createMessage({ conversationId, payload: { type: "text", text: message } }), options);
+  }
+  async sendEvent(type, payload, options = {}) {
+    if (!this.client) {
+      throw new Error("ChatSession not connected. Call connect() first.");
+    }
+    const conversationId = await this.ensureConversation();
+    return this._awaitResponses(conversationId, () => this.client.createEvent({ type, payload, conversationId }), options);
+  }
 }
 async function discoverWebhookId(botId, token, apiUrl) {
   const client = new BpClient({ token, botId, apiUrl });
@@ -11852,7 +12306,7 @@ async function discoverWebhookId(botId, token, apiUrl) {
   const integrations = bot.integrations || {};
   const chat = Object.values(integrations).find((int) => int.name === "chat");
   const webhookId = chat?.webhookId;
-  if (!webhookId) {
+  if (!webhookId || typeof webhookId !== "string") {
     throw new Error("No chat integration found on bot. Make sure the bot has the chat integration enabled.");
   }
   return webhookId;
@@ -11914,9 +12368,11 @@ async function getTraceData(conversationId, devServerUrl, options = {}) {
 }
 
 // src/eval/graders/llm.ts
-import { Cognitive } from "@botpress/cognitive";
+import { Cognitive } from "@botpress/runtime";
 import { Client as Client18 } from "@botpress/client";
-var JUDGE_SYSTEM_PROMPT = `You are an evaluation judge for a chatbot. You will be given:
+var DEFAULT_PASS_THRESHOLD = 3;
+function buildJudgeSystemPrompt(passThreshold) {
+  return `You are an evaluation judge for a chatbot. You will be given:
 - The user's message
 - The bot's response
 - Grading criteria
@@ -11937,32 +12393,44 @@ Scoring guide:
 - 2: Barely meets criteria, significant issues
 - 1: Does not meet criteria
 
-A score of 3 or above is a pass.`;
+A score of ${passThreshold} or above is a pass.`;
+}
+var MODEL_ALIASES = ["fast", "best"];
 var _cognitive = null;
-function getCognitive() {
-  if (_cognitive)
-    return _cognitive;
-  const token = process.env.BP_TOKEN || process.env.ADK_TOKEN;
-  const botId = process.env.ADK_BOT_ID;
-  const apiUrl = process.env.ADK_API_URL || "https://api.botpress.cloud";
-  if (!token || !botId)
-    return null;
-  const client = new Client18({ token, apiUrl, botId });
-  _cognitive = new Cognitive({ client, __experimental_beta: true });
-  return _cognitive;
+var _availableModels = [];
+var _judgeModel = "fast";
+function _isModelValid(model) {
+  if (MODEL_ALIASES.includes(model))
+    return true;
+  if (_availableModels.length === 0)
+    return false;
+  return _availableModels.includes(model);
 }
-function initLLMJudge(credentials) {
+async function initLLMJudge(credentials, options) {
+  const log = options?.logger ?? console;
   const client = new Client18({
     token: credentials.token,
     apiUrl: credentials.apiUrl,
     botId: credentials.botId
   });
   _cognitive = new Cognitive({ client, __experimental_beta: true });
+  try {
+    _availableModels = Array.from((await _cognitive.fetchRemoteModels()).keys());
+  } catch (err) {
+    log.warn(`Failed to fetch available models: ${err.message}. LLM judge will be unavailable.`);
+    _availableModels = [];
+  }
+  _judgeModel = options?.model ?? "fast";
+  if (_availableModels.length === 0) {
+    log.warn("No available Cognitive models: cannot validate judge model.");
+  } else if (!_isModelValid(_judgeModel)) {
+    log.warn(`Configured LLM judge model "${_judgeModel}" is invalid. Run "adk models" to list available models.`);
+  }
 }
 async function gradeLLMJudge(botResponse, criteria, context) {
+  const threshold = Math.max(1, Math.min(5, context.passThreshold ?? DEFAULT_PASS_THRESHOLD));
   try {
-    const cognitive = getCognitive();
-    if (!cognitive) {
+    if (!_cognitive) {
       return {
         assertion: `llm_judge: "${criteria}"`,
         pass: true,
@@ -11970,11 +12438,19 @@ async function gradeLLMJudge(botResponse, criteria, context) {
         actual: "SKIPPED — LLM judge unavailable: no credentials configured"
       };
     }
-    const { output } = await cognitive.generateContent({
-      model: "fast",
+    if (!_isModelValid(_judgeModel)) {
+      return {
+        assertion: `llm_judge: "${criteria}"`,
+        pass: false,
+        expected: criteria,
+        actual: "FAILED — invalid LLM judge model"
+      };
+    }
+    const { output } = await _cognitive.generateContent({
+      model: _judgeModel,
       temperature: 0,
       responseFormat: "json_object",
-      systemPrompt: JUDGE_SYSTEM_PROMPT,
+      systemPrompt: buildJudgeSystemPrompt(threshold),
       messages: [
         {
           role: "user",
@@ -11999,9 +12475,9 @@ Criteria: ${criteria}`
     const verdict = JSON.parse(content);
     return {
       assertion: `llm_judge: "${criteria}"`,
-      pass: verdict.score >= 3,
+      pass: verdict.score >= threshold,
       expected: criteria,
-      actual: `Score ${verdict.score}/5 — ${verdict.reason}`
+      actual: `Score ${verdict.score}/5 (threshold: ${threshold}) — ${verdict.reason}`
     };
   } catch (err) {
     return {
@@ -12049,7 +12525,10 @@ async function gradeResponse(botResponse, assertions, context) {
       continue;
     }
     if ("llm_judge" in assertion) {
-      const result = await gradeLLMJudge(botResponse, assertion.llm_judge, context);
+      const result = await gradeLLMJudge(botResponse, assertion.llm_judge, {
+        userMessage: context.userMessage,
+        passThreshold: context.judgePassThreshold
+      });
       results.push(result);
       continue;
     }
@@ -12201,6 +12680,7 @@ function gradeTools(toolCalls, assertions) {
 }
 
 // src/eval/graders/state.ts
+import { BUILT_IN_STATES } from "@botpress/runtime/internal";
 function parseStatePath(path42) {
   const dot = path42.indexOf(".");
   if (dot === -1) {
@@ -12210,11 +12690,16 @@ function parseStatePath(path42) {
   const field = path42.slice(dot + 1);
   switch (prefix) {
     case "bot":
-      return { type: "bot", stateName: "botState", stateId: (ctx) => ctx.botId, field };
+      return { type: "bot", stateName: BUILT_IN_STATES.bot, stateId: (ctx) => ctx.botId, field };
     case "user":
-      return { type: "user", stateName: "userState", stateId: (ctx) => ctx.userId, field };
+      return { type: "user", stateName: BUILT_IN_STATES.user, stateId: (ctx) => ctx.userId, field };
     case "conversation":
-      return { type: "conversation", stateName: "conversationState", stateId: (ctx) => ctx.conversationId, field };
+      return {
+        type: "conversation",
+        stateName: BUILT_IN_STATES.conversation,
+        stateId: (ctx) => ctx.conversationId,
+        field
+      };
     default:
       throw new Error(`Unknown state type "${prefix}" in path "${path42}" — expected bot, user, or conversation`);
   }
@@ -12225,7 +12710,9 @@ async function fetchState(client, type, id, name) {
     const payload = result.state?.payload;
     return payload?.value ?? payload ?? null;
   } catch (err) {
-    if (err?.code === 404 || err?.message?.includes("404") || err?.message?.includes("doesn't exist")) {
+    const code = err != null && typeof err === "object" && "code" in err ? err.code : undefined;
+    const message = err instanceof Error ? err.message : "";
+    if (code === 404 || message.includes("404") || message.includes("doesn't exist")) {
       return null;
     }
     throw err;
@@ -12249,7 +12736,7 @@ async function snapshotState(client, assertions, ctx) {
     if (assertion.changed === undefined)
       continue;
     const parsed = parseStatePath(assertion.path);
-    if (parsed.type === "conversation")
+    if (parsed.type === "conversation" && !ctx.conversationId)
       continue;
     const payload = await fetchState(client, parsed.type, parsed.stateId(ctx), parsed.stateName);
     snapshots.set(assertion.path, payload ? payload[parsed.field] : undefined);
@@ -12462,6 +12949,22 @@ function gradeWorkflows(spans, assertions) {
   return results;
 }
 
+// src/eval/graders/timing.ts
+function gradeTiming(botDuration, assertions) {
+  const results = [];
+  for (const assertion of assertions) {
+    const pass = matchValue(assertion.response_time, botDuration);
+    const expected = operatorToString(assertion.response_time);
+    results.push({
+      assertion: `response_time ${expected}`,
+      pass,
+      expected: `Response time ${expected}`,
+      actual: `${botDuration}ms`
+    });
+  }
+  return results;
+}
+
 // src/eval/graders/outcome.ts
 async function snapshotOutcomeState(client, evalDef, ctx) {
   if (!evalDef.outcome?.state) {
@@ -12492,9 +12995,64 @@ async function gradeOutcome(client, evalDef, ctx, traceSpans, preSnapshots) {
 // src/eval/runner.ts
 import { randomUUID } from "crypto";
 var DEFAULT_IDLE_TIMEOUT = 15000;
+var WORKFLOW_TRIGGER_TIMEOUT_MS = 5 * 60 * 1000;
+function buildStatePayload(value) {
+  return {
+    value,
+    location: { type: "state" }
+  };
+}
+async function seedEvalState(client, ctx, setup) {
+  const state = setup?.state;
+  if (!state)
+    return;
+  const writes = [];
+  if (state.bot) {
+    writes.push(client.setState({
+      type: "bot",
+      id: ctx.botId,
+      name: BUILT_IN_STATES2.bot,
+      payload: buildStatePayload(state.bot)
+    }));
+  }
+  if (state.user) {
+    writes.push(client.setState({
+      type: "user",
+      id: ctx.userId,
+      name: BUILT_IN_STATES2.user,
+      payload: buildStatePayload(state.user)
+    }));
+  }
+  if (state.conversation) {
+    if (!ctx.conversationId) {
+      throw new Error("Cannot seed conversation state before a conversation is created.");
+    }
+    writes.push(client.setState({
+      type: "conversation",
+      id: ctx.conversationId,
+      name: BUILT_IN_STATES2.conversation,
+      payload: buildStatePayload(state.conversation)
+    }));
+  }
+  await Promise.all(writes);
+}
+async function triggerEvalWorkflow(client, ctx, setup) {
+  const workflow = setup?.workflow;
+  if (!workflow)
+    return;
+  await client.createWorkflow({
+    name: workflow.trigger,
+    input: workflow.input ?? {},
+    status: "pending",
+    conversationId: ctx.conversationId,
+    userId: ctx.userId,
+    timeoutAt: new Date(Date.now() + WORKFLOW_TRIGGER_TIMEOUT_MS).toISOString()
+  });
+}
 async function runEval(evalDef, connection, options = {}) {
   const devServerUrl = options.devServerUrl || "http://localhost:3001";
   const idleTimeout = evalDef.options?.idleTimeout ?? options.idleTimeout ?? DEFAULT_IDLE_TIMEOUT;
+  const judgePassThreshold = evalDef.options?.judgePassThreshold ?? options.judgePassThreshold;
   const start = Date.now();
   const turns = [];
   let outcomeAssertions = [];
@@ -12512,34 +13070,67 @@ async function runEval(evalDef, connection, options = {}) {
       }
       return bpClient;
     };
+    let lastConversationId = "";
+    if (evalDef.setup?.state?.conversation || evalDef.setup?.workflow) {
+      lastConversationId = await session.ensureConversation();
+    }
+    await seedEvalState(getBpClient(), {
+      botId: connection.botId,
+      userId: session.userId,
+      conversationId: lastConversationId || undefined
+    }, evalDef.setup);
+    await triggerEvalWorkflow(getBpClient(), {
+      userId: session.userId,
+      conversationId: lastConversationId || undefined
+    }, evalDef.setup);
     let preSnapshots = new Map;
     if (evalDef.outcome?.state) {
       const ctx = {
         botId: connection.botId,
         userId: session.userId,
-        conversationId: ""
+        conversationId: lastConversationId
       };
       preSnapshots = await snapshotOutcomeState(getBpClient(), evalDef, ctx);
     }
     let previousToolCallCount = 0;
-    let lastConversationId = "";
     let allSpans = [];
     for (let i = 0;i < evalDef.conversation.length; i++) {
       const turn = evalDef.conversation[i];
       const turnStart = Date.now();
-      const result = await session.sendMessage(turn.user, {
-        timeout: Math.max(30000, idleTimeout * 2),
-        idleTimeout
-      });
+      if (turn.expectSilence && turn.assert?.response) {
+        throw new Error(`Turn ${i + 1}: 'expectSilence' and 'assert.response' are mutually exclusive.`);
+      }
+      if (turn.user && turn.event) {
+        throw new Error(`Turn ${i + 1}: 'user' and 'event' are mutually exclusive.`);
+      }
+      if (!turn.user && !turn.event) {
+        throw new Error(`Turn ${i + 1}: must have either 'user' or 'event'.`);
+      }
+      const sendOptions = { timeout: Math.max(30000, idleTimeout * 2), idleTimeout, expectSilence: turn.expectSilence };
+      const result = turn.event ? await session.sendEvent(turn.event.type, turn.event.payload ?? {}, sendOptions) : await session.sendMessage(turn.user, sendOptions);
       const botDuration = Date.now() - turnStart;
+      if (!turn.expectSilence && result.responses.length === 0) {
+        throw new Error(`Turn ${i + 1}: bot produced no response.`);
+      }
       lastConversationId = result.conversationId;
       const botResponse = result.responses.map((r) => r.text).join(`
 `);
+      const turnLabel = turn.event ? `[event: ${turn.event.type}]` : turn.user;
       const evalStart = Date.now();
       let assertions = [];
+      if (turn.expectSilence) {
+        const wasSilent = result.responses.length === 0;
+        assertions.push({
+          assertion: "no_response",
+          pass: wasSilent,
+          expected: "No response",
+          actual: wasSilent ? "No response" : `Bot responded: "${botResponse}"`
+        });
+      }
       if (turn.assert?.response) {
         assertions = await gradeResponse(botResponse, turn.assert.response, {
-          userMessage: turn.user
+          userMessage: turnLabel,
+          judgePassThreshold
         });
       }
       if (turn.assert?.tools) {
@@ -12606,11 +13197,15 @@ async function runEval(evalDef, connection, options = {}) {
         const workflowResults = gradeWorkflows(allSpans, turn.assert.workflow);
         assertions.push(...workflowResults);
       }
+      if (turn.assert?.timing) {
+        const timingResults = gradeTiming(botDuration, turn.assert.timing);
+        assertions.push(...timingResults);
+      }
       const turnPass = assertions.every((a) => a.pass);
       const evalDuration = Date.now() - evalStart;
       turns.push({
         turnNumber: i + 1,
-        userMessage: turn.user,
+        userMessage: turnLabel,
         botResponse,
         assertions,
         pass: turnPass,
@@ -12672,11 +13267,11 @@ async function runEval(evalDef, connection, options = {}) {
 async function runEvalSuite(config, filter) {
   const start = Date.now();
   const runId = randomUUID().replace(/-/g, "").slice(0, 26);
-  initLLMJudge({
+  await initLLMJudge({
     token: config.credentials.token,
     apiUrl: config.credentials.apiUrl,
     botId: config.credentials.botId
-  });
+  }, { model: config.evalOptions?.judgeModel, logger: config.logger });
   const evalsDir = `${config.agentPath}/evals`;
   const allEvals = await loadEvalsFromDir(evalsDir);
   const evals = filterEvals(allEvals, filter);
@@ -12708,7 +13303,11 @@ async function runEvalSuite(config, filter) {
   for (let i = 0;i < evals.length; i++) {
     const evalDef = evals[i];
     config.onProgress?.({ type: "eval_start", evalName: evalDef.name, index: i });
-    const report = await runEval(evalDef, connection, { devServerUrl, idleTimeout: config.evalOptions?.idleTimeout });
+    const report = await runEval(evalDef, connection, {
+      devServerUrl,
+      idleTimeout: config.evalOptions?.idleTimeout,
+      judgePassThreshold: config.evalOptions?.judgePassThreshold
+    });
     reports.push(report);
     config.onProgress?.({ type: "eval_complete", evalName: evalDef.name, index: i, report });
   }
@@ -12726,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;
@@ -12748,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) {
@@ -12794,11 +13393,11 @@ export {
   generateAssetsRuntime,
   filterEvals,
   dependenciesKeyOrder,
-  defineEval,
   coerceConfigValue,
   buildOpenCodeConfig,
   bpCliImporter,
   auth,
+  agentLocalInfoKeyOrder,
   agentInfoKeyOrder,
   ValidationSeverity,
   ValidationErrors,
@@ -12825,6 +13424,7 @@ export {
   IntegrationCache,
   HubCache,
   FileWatcher2 as FileWatcher,
+  Eval,
   EnhancedInterfaceCache,
   DevIdManager,
   CredentialsManager,
@@ -12845,4 +13445,4 @@ export {
   AgentProject
 };
 
-//# debugId=BA9CF8B5F775A63B64756E2164756E21
+//# debugId=E3104143A79BCF1564756E2164756E21