@botpress/adk 1.8.4 → 1.10.1

package/dist/index.js

@@ -654,7 +654,7 @@ var PRETTIER_CONFIG, formatCode = async (code, filepath) => {
 `));
     return code;
   }
-}, ADK_VERSION = "1.8.4", relative2 = (from, to) => {
+}, ADK_VERSION = "1.10.1", relative2 = (from, to) => {
   const fromDir = path10.dirname(from);
   const relative3 = path10.relative(fromDir, to);
   return relative3.startsWith(".") ? relative3 : `./${relative3}`;
@@ -678,7 +678,7 @@ var exports_action_types = {};
 __export(exports_action_types, {
   generateActionTypes: () => generateActionTypes
 });
-import path28 from "path";
+import path30 from "path";
 async function generateActionTypes(project) {
   const actionDefs = [];
   for (const action of project.actions) {
@@ -693,7 +693,7 @@ async function generateActionTypes(project) {
     };`);
         continue;
       }
-      const absolutePath = path28.join(project.path, action.path);
+      const absolutePath = path30.join(project.path, action.path);
       const actionModule = await import(`${absolutePath}?t=${Date.now()}`);
       const actionInstance = actionModule[action.export] || actionModule.default;
       if (actionInstance && actionInstance.input && actionInstance.output) {
@@ -738,7 +738,7 @@ ${actionDefs.join(`
   };
 }
 `;
-  const actionTypesPath = path28.join(project.path, ".adk", "action-types.d.ts");
+  const actionTypesPath = path30.join(project.path, ".adk", "action-types.d.ts");
   await createFile(actionTypesPath, await formatCode(content));
 }
 var init_action_types = __esm(() => {
@@ -751,7 +751,7 @@ var exports_integration_action_types = {};
 __export(exports_integration_action_types, {
   generateIntegrationActionTypes: () => generateIntegrationActionTypes
 });
-import path29 from "path";
+import path31 from "path";
 async function generateIntegrationActionTypes(project) {
   const content = `
 ////////////////////////////////////////////////////////
@@ -785,7 +785,7 @@ type IntegrationsMap<T> = {
 export type IntegrationActions = IntegrationsMap<Integrations>;
 }
 `;
-  const integrationActionTypesPath = path29.join(project.path, ".adk", "integration-action-types.d.ts");
+  const integrationActionTypesPath = path31.join(project.path, ".adk", "integration-action-types.d.ts");
   await createFile(integrationActionTypesPath, await formatCode(content));
 }
 var init_integration_action_types = __esm(() => {
@@ -797,7 +797,7 @@ var init_integration_action_types = __esm(() => {
 var require_package = __commonJS((exports, module) => {
   module.exports = {
     name: "@botpress/adk",
-    version: "1.8.4",
+    version: "1.10.1",
     description: "Core ADK library for building AI agents on Botpress",
     type: "module",
     main: "dist/index.js",
@@ -844,8 +844,9 @@ var require_package = __commonJS((exports, module) => {
       "@botpress/cli": "^4.27.3",
       "@botpress/client": "^1.27.2",
       "@botpress/cognitive": "^0.2.0",
-      "@botpress/runtime": "^1.8.4",
+      "@botpress/runtime": "^1.10.1",
       "@botpress/sdk": "^4.18.1",
+      "@bpinternal/jex": "^1.2.4",
       "@bpinternal/yargs-extra": "^0.0.21",
       "@parcel/watcher": "^2.5.1",
       "@types/glob": "^9.0.0",
@@ -1069,81 +1070,24 @@ class BaseCommand {
   }
 }
 // src/commands/bp-add-command.ts
-import { execa as execa2 } from "execa";
+import { execa } from "execa";
 
 // src/commands/bp-cli.ts
-import { execa } from "execa";
+import { existsSync } from "fs";
+import os3 from "os";
 import path4 from "path";
-import { createRequire as createRequire2 } from "module";
-import { access } from "fs/promises";
-async function findBundledBpPath() {
-  try {
-    const require2 = createRequire2(import.meta.url);
-    try {
-      const cliPackagePath = require2.resolve("@botpress/adk-cli/package.json");
-      const cliDir = path4.dirname(cliPackagePath);
-      const bundledBpPath = path4.join(cliDir, "dist", "bp-cli", "bin.js");
-      await access(bundledBpPath);
-      return bundledBpPath;
-    } catch {}
-    return null;
-  } catch {
-    return null;
-  }
-}
-async function findBpPath(projectPath) {
-  const basePath = projectPath || process.cwd();
-  const bundledPath = await findBundledBpPath();
-  if (bundledPath) {
-    return bundledPath;
-  }
-  try {
-    const require2 = createRequire2(path4.join(basePath, "package.json"));
-    const cliPath = require2.resolve("@botpress/cli/package.json");
-    const cliDir = path4.dirname(cliPath);
-    return path4.join(cliDir, "bin.js");
-  } catch {
-    try {
-      const require2 = createRequire2(path4.join(process.cwd(), "package.json"));
-      const cliPath = require2.resolve("@botpress/cli/package.json");
-      const cliDir = path4.dirname(cliPath);
-      return path4.join(cliDir, "bin.js");
-    } catch {
-      return null;
-    }
-  }
-}
-async function getVersionFromPath(bpPath) {
-  try {
-    const { stdout } = await execa("node", [bpPath, "--version"]);
-    return parseVersion(stdout);
-  } catch {
-    return "unknown";
-  }
-}
-function parseVersion(versionOutput) {
-  const match = versionOutput.match(/v?(\d+\.\d+\.\d+)/);
-  return match?.[1] || "0.0.0";
-}
-async function getBpCli(projectPath) {
-  const localBpPath = await findBpPath(projectPath);
-  if (localBpPath) {
-    const version = await getVersionFromPath(localBpPath);
-    return {
-      path: localBpPath,
-      version
-    };
-  }
-  try {
-    const { stdout } = await execa("bp", ["--version"]);
-    const version = parseVersion(stdout);
-    return {
-      path: "bp",
-      version
-    };
-  } catch {
-    throw new Error("Botpress CLI not found. This should not happen as @botpress/cli is bundled with the ADK CLI.");
+var BP_CLI_VERSION = "4.27.3";
+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");
+function getBpCli() {
+  if (!existsSync(BP_CLI_BIN_PATH)) {
+    throw new Error(`@botpress/cli version ${BP_CLI_VERSION} is not installed in the ADK directory "${BP_CLI_INSTALL_DIR}". This is a bug, please report it to the Botpress team.`);
   }
+  return {
+    path: BP_CLI_BIN_PATH,
+    version: BP_CLI_VERSION
+  };
 }
 
 // src/commands/bp-add-command.ts
@@ -1157,7 +1101,7 @@ class BpAddCommand extends BaseCommand {
   }
   async run() {
     const { resource, botPath, workspaceId, credentials } = this.options;
-    const { path: bpCommand } = await getBpCli(botPath);
+    const { path: bpCommand } = getBpCli();
     const args = [
       "add",
       resource,
@@ -1171,7 +1115,7 @@ class BpAddCommand extends BaseCommand {
       "--apiUrl",
       credentials.apiUrl
     ];
-    this.childProcess = execa2(bpCommand, args, {
+    this.childProcess = execa(bpCommand, args, {
       cwd: botPath,
       stdio: ["ignore", "pipe", "pipe"]
     });
@@ -1209,9 +1153,9 @@ class BpAddCommand extends BaseCommand {
   }
 }
 // src/commands/bp-build-command.ts
-import { execa as execa3 } from "execa";
+import { execa as execa2 } from "execa";
 import { join } from "path";
-import { access as access2 } from "fs/promises";
+import { access } from "fs/promises";
 
 // src/utils/source-map-optimizer.ts
 import { readFile, writeFile } from "fs/promises";
@@ -1467,9 +1411,9 @@ class BpBuildCommand extends BaseCommand {
   }
   async run() {
     const { botPath } = this.options;
-    const { path: bpCommand } = await getBpCli(botPath);
+    const { path: bpCommand } = getBpCli();
     const args = ["build", "--sourceMap"];
-    this.childProcess = execa3(bpCommand, args, {
+    this.childProcess = execa2(bpCommand, args, {
       cwd: botPath,
       stdio: ["ignore", "pipe", "pipe"]
     });
@@ -1504,7 +1448,7 @@ class BpBuildCommand extends BaseCommand {
     const { botPath } = this.options;
     const sourceMapPath = join(botPath, ".botpress", "dist", "index.cjs.map");
     try {
-      await access2(sourceMapPath);
+      await access(sourceMapPath);
       const agentSrcPath = join(botPath, "..", "..", "src");
       await optimizeSourceMap({
         sourceMapPath,
@@ -1520,7 +1464,7 @@ class BpBuildCommand extends BaseCommand {
   }
 }
 // src/commands/bp-deploy-command.ts
-import { execa as execa4 } from "execa";
+import { execa as execa3 } from "execa";
 class BpDeployCommand extends BaseCommand {
   options;
   childProcess = null;
@@ -1531,7 +1475,7 @@ class BpDeployCommand extends BaseCommand {
   }
   async run() {
     const { botPath, botId, workspaceId, credentials } = this.options;
-    const { path: bpCommand } = await getBpCli(botPath);
+    const { path: bpCommand } = getBpCli();
     const args = [
       "deploy",
       "--botId",
@@ -1544,7 +1488,7 @@ class BpDeployCommand extends BaseCommand {
       "--apiUrl",
       credentials.apiUrl
     ];
-    this.childProcess = execa4(bpCommand, args, {
+    this.childProcess = execa3(bpCommand, args, {
       cwd: botPath,
       stdio: ["ignore", "pipe", "pipe"]
     });
@@ -1582,9 +1526,9 @@ class BpDeployCommand extends BaseCommand {
   }
 }
 // src/commands/bp-dev-command.ts
-import { execa as execa5 } from "execa";
+import { execa as execa4 } from "execa";
 import { join as join2 } from "path";
-import { access as access3 } from "fs/promises";
+import { access as access2 } from "fs/promises";
 class BpDevCommand extends BaseCommand {
   options;
   childProcess = null;
@@ -1598,7 +1542,7 @@ class BpDevCommand extends BaseCommand {
   }
   async run() {
     const { port, botPath, workspaceId, credentials, sourceMap = true } = this.options;
-    const { path: bpCommand } = await getBpCli(botPath);
+    const { path: bpCommand } = getBpCli();
     const bpArgs = [
       "dev",
       "--port",
@@ -1613,7 +1557,7 @@ class BpDevCommand extends BaseCommand {
     if (sourceMap) {
       bpArgs.push("--sourceMap");
     }
-    this.childProcess = execa5(bpCommand, bpArgs, {
+    this.childProcess = execa4(bpCommand, bpArgs, {
       cwd: botPath,
       env: {
         ...process.env,
@@ -1783,7 +1727,7 @@ ${this.stderrLines.join(`
     const { botPath } = this.options;
     const sourceMapPath = join2(botPath, ".botpress", "dist", "index.cjs.map");
     try {
-      await access3(sourceMapPath);
+      await access2(sourceMapPath);
       const agentSrcPath = join2(botPath, "..", "..", "src");
       await optimizeSourceMap({
         sourceMapPath,
@@ -1812,7 +1756,7 @@ ${this.stderrLines.join(`
   }
 }
 // src/commands/bp-chat-command.ts
-import { execa as execa6 } from "execa";
+import { execa as execa5 } from "execa";
 class BpChatCommand extends BaseCommand {
   options;
   childProcess = null;
@@ -1821,8 +1765,8 @@ class BpChatCommand extends BaseCommand {
     this.options = options;
   }
   async run() {
-    const { botId, workspaceId, credentials, projectPath } = this.options;
-    const { path: bpCommand } = await getBpCli(projectPath);
+    const { botId, workspaceId, credentials } = this.options;
+    const { path: bpCommand } = getBpCli();
     const bpArgs = [
       "chat",
       "--botId",
@@ -1834,7 +1778,7 @@ class BpChatCommand extends BaseCommand {
       "--apiUrl",
       credentials.apiUrl
     ];
-    this.childProcess = execa6(bpCommand, bpArgs, {
+    this.childProcess = execa5(bpCommand, bpArgs, {
       stdio: "inherit"
     });
     try {
@@ -2415,7 +2359,7 @@ import { Client as Client4 } from "@botpress/client";
 // src/integrations/enhanced-cache.ts
 import fs6 from "fs/promises";
 import path7 from "path";
-import os3 from "os";
+import os4 from "os";
 
 class EnhancedIntegrationCache {
   cacheDir;
@@ -2424,7 +2368,7 @@ class EnhancedIntegrationCache {
   noCache;
   constructor(noCache = false) {
     this.noCache = noCache;
-    this.cacheDir = path7.join(os3.homedir(), ".adk", "cache", "integrations");
+    this.cacheDir = path7.join(os4.homedir(), ".adk", "cache", "integrations");
     this.resolutionsDir = path7.join(this.cacheDir, "resolutions");
     this.definitionsDir = path7.join(this.cacheDir, "definitions");
   }
@@ -2805,13 +2749,13 @@ class IntegrationManager {
 // src/integrations/cache.ts
 import fs7 from "fs/promises";
 import path8 from "path";
-import os4 from "os";
+import os5 from "os";
 
 class IntegrationCache {
   cacheDir;
   integrationsDir;
   constructor() {
-    this.cacheDir = path8.join(os4.homedir(), ".adk", "cache");
+    this.cacheDir = path8.join(os5.homedir(), ".adk", "cache");
     this.integrationsDir = path8.join(this.cacheDir, "integrations");
   }
   async ensureCacheDir() {
@@ -2891,10 +2835,10 @@ import * as process2 from "process";
 import { Client as Client5 } from "@botpress/client";
 import * as fs8 from "fs/promises";
 import * as path9 from "path";
-import * as os5 from "os";
+import * as os6 from "os";
 class HubCache {
   static CACHE_FILE = "botpress-hub-cache.json";
-  static CACHE_DIR = path9.join(os5.homedir(), ".adk", "cache");
+  static CACHE_DIR = path9.join(os6.homedir(), ".adk", "cache");
   static CACHE_PATH = path9.join(HubCache.CACHE_DIR, HubCache.CACHE_FILE);
   static CACHE_DURATION = 30 * 60 * 1000;
   client;
@@ -3661,7 +3605,7 @@ import { Client as Client9 } from "@botpress/client";
 // src/interfaces/enhanced-cache.ts
 import fs9 from "fs/promises";
 import path12 from "path";
-import os6 from "os";
+import os7 from "os";
 
 class EnhancedInterfaceCache {
   cacheDir;
@@ -3670,7 +3614,7 @@ class EnhancedInterfaceCache {
   noCache;
   constructor(noCache = false) {
     this.noCache = noCache;
-    this.cacheDir = path12.join(os6.homedir(), ".adk", "cache", "interfaces");
+    this.cacheDir = path12.join(os7.homedir(), ".adk", "cache", "interfaces");
     this.resolutionsDir = path12.join(this.cacheDir, "resolutions");
     this.definitionsDir = path12.join(this.cacheDir, "definitions");
   }
@@ -4781,6 +4725,99 @@ class FileWatcher extends EventEmitter2 {
 init_validation_errors();
 init_agent_resolver();
 init_types();
+// src/config/manager.ts
+import { Client as Client10 } from "@botpress/client";
+import { sync as jex } from "@bpinternal/jex";
+class ConfigManager {
+  botId;
+  client;
+  constructor(botId) {
+    this.botId = botId;
+  }
+  async getClient() {
+    if (!this.client) {
+      const credentials = await auth.getActiveCredentials();
+      this.client = new Client10({
+        token: credentials.token,
+        apiUrl: credentials.apiUrl,
+        botId: this.botId,
+        headers: {
+          "x-multiple-integrations": "true"
+        }
+      });
+    }
+    return this.client;
+  }
+  async load() {
+    try {
+      const client = await this.getClient();
+      const { bot } = await client.getBot({ id: this.botId });
+      return bot.configuration?.data || {};
+    } catch (error) {
+      console.warn(`Failed to load configuration from bot ${this.botId}:`, error);
+      return {};
+    }
+  }
+  async save(config, schema) {
+    try {
+      const client = await this.getClient();
+      const { bot } = await client.getBot({ id: this.botId });
+      const updates = {
+        id: this.botId,
+        configuration: {
+          data: config
+        }
+      };
+      if (schema) {
+        const schemaJson = schema.toJSONSchema();
+        const currentSchema = bot.configuration?.schema || {};
+        if (!jex.jsonSchemaEquals(currentSchema, schemaJson)) {
+          updates.configuration.schema = schemaJson;
+        }
+      }
+      await client.updateBot(updates);
+    } catch (error) {
+      throw new Error(`Failed to save configuration to bot ${this.botId}: ${error}`);
+    }
+  }
+  async get(key) {
+    const config = await this.load();
+    return config[key];
+  }
+  async set(key, value, schema) {
+    const config = await this.load();
+    config[key] = value;
+    await this.save(config, schema);
+  }
+  async getAll() {
+    return await this.load();
+  }
+  async validate(schema) {
+    const config = await this.getAll();
+    const result = schema.safeParse(config);
+    if (result.success) {
+      return { valid: true, errors: [], missing: [] };
+    }
+    const errors = [];
+    const missing = [];
+    for (const issue of result.error.issues) {
+      const key = issue.path.join(".");
+      if (issue.code === "invalid_type" && issue.received === "undefined") {
+        missing.push(key);
+      }
+      errors.push(`${key}: ${issue.message}`);
+    }
+    return { valid: false, errors, missing };
+  }
+  async getMissingKeys(schema) {
+    const validation = await this.validate(schema);
+    return validation.missing;
+  }
+  async isValid(schema) {
+    const validation = await this.validate(schema);
+    return validation.valid;
+  }
+}
 // src/agent-init/agent-project-generator.ts
 init_utils();
 import * as fs11 from "fs";
@@ -4829,7 +4866,7 @@ class AgentProjectGenerator {
         deploy: "adk deploy"
       },
       dependencies: {
-        "@botpress/runtime": `^${"1.8.4"}`
+        "@botpress/runtime": `^${"1.10.1"}`
       },
       devDependencies: {
         typescript: "^5.9.3"
@@ -5405,9 +5442,9 @@ Description: ${tag?.description}`);
 }
 // src/bot-generator/generator.ts
 import dedent from "dedent";
-import { existsSync as existsSync5 } from "fs";
+import { existsSync as existsSync6 } from "fs";
 import fs15 from "fs/promises";
-import path30 from "path";
+import path32 from "path";
 
 // src/generators/interface-types.ts
 import { transforms as transforms2 } from "@botpress/sdk";
@@ -5724,10 +5761,201 @@ declare module "@botpress/runtime/_types/state" {
   await createFile(stateTypesPath, await formatCode(content));
 }
 
+// src/generators/tag-types.ts
+init_utils();
+init_fs();
+import path22 from "path";
+async function generateTagTypes(project) {
+  let botTagsType = "Record<string, string | undefined>";
+  let userTagsType = "Record<string, string | undefined>";
+  let conversationTagsType = "Record<string, string | undefined>";
+  let messageTagsType = "Record<string, string | undefined>";
+  let workflowTagsType = "Record<string, string | undefined>";
+  try {
+    const configPath = path22.join(project.path, "agent.config.ts");
+    const configModule = await import(`${configPath}?t=${Date.now()}`);
+    const config = configModule.default;
+    if (config?.bot?.tags) {
+      const tagKeys = Object.keys(config.bot.tags);
+      if (tagKeys.length > 0) {
+        const tagProps = tagKeys.map((key) => {
+          const tag = config.bot.tags[key];
+          const jsdoc = tag.description ? `/**
+   * ${tag.title}
+   * 
+   * ${tag.description}
+   */
+  ` : `/** ${tag.title} */
+  `;
+          return `${jsdoc}${key}?: string | undefined`;
+        }).join(`
+  `);
+        botTagsType = `{
+  ${tagProps}
+}`;
+      }
+    }
+    if (config?.user?.tags) {
+      const tagKeys = Object.keys(config.user.tags);
+      if (tagKeys.length > 0) {
+        const tagProps = tagKeys.map((key) => {
+          const tag = config.user.tags[key];
+          const jsdoc = tag.description ? `/**
+   * ${tag.title}
+   * 
+   * ${tag.description}
+   */
+  ` : `/** ${tag.title} */
+  `;
+          return `${jsdoc}${key}?: string | undefined`;
+        }).join(`
+  `);
+        userTagsType = `{
+  ${tagProps}
+}`;
+      }
+    }
+    if (config?.conversation?.tags) {
+      const tagKeys = Object.keys(config.conversation.tags);
+      if (tagKeys.length > 0) {
+        const tagProps = tagKeys.map((key) => {
+          const tag = config.conversation.tags[key];
+          const jsdoc = tag.description ? `/**
+   * ${tag.title}
+   * 
+   * ${tag.description}
+   */
+  ` : `/** ${tag.title} */
+  `;
+          return `${jsdoc}${key}?: string | undefined`;
+        }).join(`
+  `);
+        conversationTagsType = `{
+  ${tagProps}
+}`;
+      }
+    }
+    if (config?.message?.tags) {
+      const tagKeys = Object.keys(config.message.tags);
+      if (tagKeys.length > 0) {
+        const tagProps = tagKeys.map((key) => {
+          const tag = config.message.tags[key];
+          const jsdoc = tag.description ? `/**
+   * ${tag.title}
+   * 
+   * ${tag.description}
+   */
+  ` : `/** ${tag.title} */
+  `;
+          return `${jsdoc}${key}?: string | undefined`;
+        }).join(`
+  `);
+        messageTagsType = `{
+  ${tagProps}
+}`;
+      }
+    }
+    if (config?.workflow?.tags) {
+      const tagKeys = Object.keys(config.workflow.tags);
+      if (tagKeys.length > 0) {
+        const tagProps = tagKeys.map((key) => {
+          const tag = config.workflow.tags[key];
+          const jsdoc = tag.description ? `/**
+   * ${tag.title}
+   * 
+   * ${tag.description}
+   */
+  ` : `/** ${tag.title} */
+  `;
+          return `${jsdoc}${key}?: string | undefined`;
+        }).join(`
+  `);
+        workflowTagsType = `{
+  ${tagProps}
+}`;
+      }
+    }
+  } catch (error) {
+    console.warn("Failed to load agent config for tag types:", error);
+  }
+  const content = `
+////////////////////////////////////////////////////////
+// DO NOT EDIT THIS FILE DIRECTLY
+// This file is auto-generated from the Botpress ADK
+// ADK Version: ${ADK_VERSION}
+// Generated at: ${new Date().toISOString()}
+////////////////////////////////////////////////////////
+
+declare module "@botpress/runtime/_types/tags" {
+  /**
+   * Bot-level tags defined in agent.config.ts
+   */
+  export type BotTags = ${botTagsType};
+
+  /**
+   * User-level tags defined in agent.config.ts
+   */
+  export type UserTags = ${userTagsType};
+
+  /**
+   * Conversation-level tags defined in agent.config.ts
+   */
+  export type ConversationTags = ${conversationTagsType};
+
+  /**
+   * Message-level tags defined in agent.config.ts
+   */
+  export type MessageTags = ${messageTagsType};
+
+  /**
+   * Workflow-level tags defined in agent.config.ts
+   */
+  export type WorkflowTags = ${workflowTagsType};
+}
+`;
+  const tagTypesPath = path22.join(project.path, ".adk", "tag-types.d.ts");
+  await createFile(tagTypesPath, await formatCode(content));
+}
+
+// src/generators/configuration-types.ts
+init_utils();
+init_fs();
+import path23 from "path";
+async function generateConfigurationTypes(project) {
+  let configurationType = "{}";
+  try {
+    const configPath = path23.join(project.path, "agent.config.ts");
+    const configModule = await import(`${configPath}?t=${Date.now()}`);
+    const config = configModule.default;
+    if (config?.configuration?.schema) {
+      const configSchema = config.configuration.schema;
+      if (configSchema.toTypescriptType) {
+        configurationType = configSchema.toTypescriptType();
+      }
+    }
+  } catch (error) {
+    console.warn("Failed to load agent config for configuration types:", error);
+  }
+  const content = `
+////////////////////////////////////////////////////////
+// DO NOT EDIT THIS FILE DIRECTLY
+// This file is auto-generated from the Botpress ADK
+// ADK Version: ${ADK_VERSION}
+// Generated at: ${new Date().toISOString()}
+////////////////////////////////////////////////////////
+
+declare module "@botpress/runtime/_types/configuration" {
+  export type Configuration = ${configurationType};
+}
+`;
+  const configTypesPath = path23.join(project.path, ".adk", "configuration-types.d.ts");
+  await createFile(configTypesPath, await formatCode(content));
+}
+
 // src/generators/workflow-types.ts
 init_utils();
 init_fs();
-import * as path22 from "path";
+import * as path24 from "path";
 import { BuiltInWorkflows as BuiltInWorkflows2 } from "@botpress/runtime/internal";
 function isBuiltinWorkflow(name) {
   return !!Object.values(BuiltInWorkflows2).find((x) => x.name === name);
@@ -5739,7 +5967,7 @@ async function generateWorkflowTypes(project) {
       if (isBuiltinWorkflow(workflowRef.definition.name)) {
         continue;
       }
-      const workflowPath = path22.join(project.path, workflowRef.path);
+      const workflowPath = path24.join(project.path, workflowRef.path);
       const workflowModule = await import(`${workflowPath}?t=${Date.now()}`);
       const workflowInstance = workflowModule[workflowRef.export] || workflowModule.default;
       if (!workflowInstance) {
@@ -5773,29 +6001,32 @@ async function generateWorkflowTypes(project) {
       output: ${workflow.output};
       state: ${workflow.state};
       requests: ${workflow.requests};
+      tags: WorkflowTags;
     };`).join(`
 `);
   const content = `// Generated workflow type definitions
 // Do not edit this file directly - it will be overwritten
 
+type WorkflowTags = import("@botpress/runtime/_types/tags").WorkflowTags;
+
 declare module "@botpress/runtime/_types/workflows" {
   export type WorkflowDefinitions = {
 ${typeDefinitions || "    // No workflows defined yet"}
   };
 }`;
-  const workflowTypesPath = path22.join(project.path, ".adk", "workflow-types.d.ts");
+  const workflowTypesPath = path24.join(project.path, ".adk", "workflow-types.d.ts");
   await createFile(workflowTypesPath, await formatCode(content));
 }
 
 // src/generators/conversation-types.ts
 init_utils();
 init_fs();
-import path23 from "path";
+import path25 from "path";
 async function generateConversationTypes(project) {
   const conversationTypes = {};
   for (const conversationRef of project.conversations) {
     try {
-      const conversationPath = path23.join(project.path, conversationRef.path);
+      const conversationPath = path25.join(project.path, conversationRef.path);
       const conversationModule = await import(`${conversationPath}?t=${Date.now()}`);
       const conversationInstance = conversationModule[conversationRef.export] || conversationModule.default;
       if (!conversationInstance) {
@@ -5827,8 +6058,8 @@ async function generateConversationTypes(project) {
       channel: "${channel}";
       integration: "${integration}";
       state: ${info.state};
-      tags: Integrations["${integration}"]["channels"]["${channelName}"]["conversation"]["tags"];
-      messageTags: Integrations["${integration}"]["channels"]["${channelName}"]["message"]["tags"];
+      tags: Integrations["${integration}"]["channels"]["${channelName}"]["conversation"]["tags"] & ConversationTags;
+      messageTags: Integrations["${integration}"]["channels"]["${channelName}"]["message"]["tags"] & MessageTags;
       messages: Integrations["${integration}"]["channels"]["${channelName}"]["messages"];
       events: Integrations["${integration}"]["events"];
     };`;
@@ -5843,6 +6074,8 @@ async function generateConversationTypes(project) {
 ////////////////////////////////////////////////////////
 
 type Integrations = import("@botpress/runtime/_types/integrations").Integrations;
+type ConversationTags = import("@botpress/runtime/_types/tags").ConversationTags;
+type MessageTags = import("@botpress/runtime/_types/tags").MessageTags;
 
 declare module "@botpress/runtime/_types/conversations" {
   export type ConversationDefinitions = {
@@ -5850,14 +6083,14 @@ ${channelDefinitions || "    // No conversations defined yet"}
   };
 }
 `;
-  const conversationTypesPath = path23.join(project.path, ".adk", "conversation-types.d.ts");
+  const conversationTypesPath = path25.join(project.path, ".adk", "conversation-types.d.ts");
   await createFile(conversationTypesPath, await formatCode(content));
 }
 
 // src/generators/event-types.ts
 init_utils();
 init_fs();
-import path24 from "path";
+import path26 from "path";
 async function generateEventTypes(project) {
   const integrationEvents = [];
   for (const int of project.integrations) {
@@ -5896,7 +6129,7 @@ ${integrationEvents.join(`
   export type EventPayload<T extends EventName> = Events[T];
 }
 `;
-  const eventTypesPath = path24.join(project.path, ".adk", "event-types.d.ts");
+  const eventTypesPath = path26.join(project.path, ".adk", "event-types.d.ts");
   await createFile(eventTypesPath, await formatCode(content));
 }
 
@@ -5904,10 +6137,10 @@ ${integrationEvents.join(`
 init_fs();
 
 // src/bot-generator/dev-id-manager.ts
-import path25 from "path";
+import path27 from "path";
 import fs12 from "fs/promises";
-import { existsSync as existsSync2 } from "fs";
-import { Client as Client10 } from "@botpress/client";
+import { existsSync as existsSync3 } from "fs";
+import { Client as Client11 } from "@botpress/client";
 class DevIdManager {
   projectPath;
   botProjectPath;
@@ -5916,7 +6149,7 @@ class DevIdManager {
   constructor(projectPath, botProjectPath) {
     this.projectPath = projectPath;
     this.botProjectPath = botProjectPath;
-    this.projectCachePath = path25.join(botProjectPath, ".botpress", "project.cache.json");
+    this.projectCachePath = path27.join(botProjectPath, ".botpress", "project.cache.json");
   }
   async getClient() {
     if (!this.client) {
@@ -5926,7 +6159,7 @@ class DevIdManager {
       if (!workspaceId) {
         throw new Error('No workspace ID found in agent.json or current profile. Please login again with "adk login"');
       }
-      this.client = new Client10({
+      this.client = new Client11({
         token: credentials.token,
         apiUrl: credentials.apiUrl,
         workspaceId,
@@ -5942,7 +6175,7 @@ class DevIdManager {
   }
   async readProjectCache() {
     try {
-      if (existsSync2(this.projectCachePath)) {
+      if (existsSync3(this.projectCachePath)) {
         const content = await fs12.readFile(this.projectCachePath, "utf-8");
         return JSON.parse(content);
       }
@@ -5953,7 +6186,7 @@ class DevIdManager {
   }
   async saveProjectCache(cache2) {
     try {
-      await fs12.mkdir(path25.dirname(this.projectCachePath), { recursive: true });
+      await fs12.mkdir(path27.dirname(this.projectCachePath), { recursive: true });
       await fs12.writeFile(this.projectCachePath, JSON.stringify(cache2, null, 2));
     } catch (error) {
       console.error("Error saving project.cache.json:", error);
@@ -6002,9 +6235,9 @@ class DevIdManager {
 }
 
 // src/bot-generator/integration-sync.ts
-import path26 from "path";
+import path28 from "path";
 import fs13 from "fs/promises";
-import { existsSync as existsSync3 } from "fs";
+import { existsSync as existsSync4 } from "fs";
 class IntegrationSync {
   projectPath;
   botProjectPath;
@@ -6012,7 +6245,7 @@ class IntegrationSync {
   constructor(projectPath, botProjectPath) {
     this.projectPath = projectPath;
     this.botProjectPath = botProjectPath;
-    this.bpModulesPath = path26.join(botProjectPath, "bp_modules");
+    this.bpModulesPath = path28.join(botProjectPath, "bp_modules");
   }
   async parseIntegrations() {
     const project = await AgentProject.load(this.projectPath);
@@ -6043,13 +6276,13 @@ class IntegrationSync {
     return integrations;
   }
   async isIntegrationSynced(integration) {
-    const targetFolder = path26.join(this.bpModulesPath, `integration_${integration.alias}`);
-    if (!existsSync3(targetFolder)) {
+    const targetFolder = path28.join(this.bpModulesPath, `integration_${integration.alias}`);
+    if (!existsSync4(targetFolder)) {
       return false;
     }
     try {
-      const indexPath = path26.join(targetFolder, "index.ts");
-      if (!existsSync3(indexPath)) {
+      const indexPath = path28.join(targetFolder, "index.ts");
+      if (!existsSync4(indexPath)) {
         return false;
       }
       const indexContent = await fs13.readFile(indexPath, "utf-8");
@@ -6081,19 +6314,19 @@ class IntegrationSync {
   }
   async renameIntegrationFolder(integration) {
     console.log(integration.name, integration.alias);
-    const sourceFolder = path26.join(this.bpModulesPath, integration.name.replace("/", "-"));
-    const targetFolder = path26.join(this.bpModulesPath, `integration_${integration.alias}`);
-    if (!existsSync3(sourceFolder)) {
+    const sourceFolder = path28.join(this.bpModulesPath, integration.name.replace("/", "-"));
+    const targetFolder = path28.join(this.bpModulesPath, `integration_${integration.alias}`);
+    if (!existsSync4(sourceFolder)) {
       throw new Error(`Integration folder not found: ${sourceFolder}`);
     }
-    if (existsSync3(targetFolder)) {
+    if (existsSync4(targetFolder)) {
       await fs13.rm(targetFolder, { recursive: true, force: true });
     }
     await fs13.rename(sourceFolder, targetFolder);
   }
   async removeIntegrationFolder(alias) {
-    const targetFolder = path26.join(this.bpModulesPath, `integration_${alias}`);
-    if (existsSync3(targetFolder)) {
+    const targetFolder = path28.join(this.bpModulesPath, `integration_${alias}`);
+    if (existsSync4(targetFolder)) {
       await fs13.rm(targetFolder, { recursive: true, force: true });
     }
   }
@@ -6126,9 +6359,9 @@ class IntegrationSync {
 }
 
 // src/bot-generator/interface-sync.ts
-import path27 from "path";
+import path29 from "path";
 import fs14 from "fs/promises";
-import { existsSync as existsSync4 } from "fs";
+import { existsSync as existsSync5 } from "fs";
 init_constants();
 class InterfaceSync {
   projectPath;
@@ -6137,7 +6370,7 @@ class InterfaceSync {
   constructor(projectPath, botProjectPath) {
     this.projectPath = projectPath;
     this.botProjectPath = botProjectPath;
-    this.bpModulesPath = path27.join(botProjectPath, "bp_modules");
+    this.bpModulesPath = path29.join(botProjectPath, "bp_modules");
   }
   async parseInterfaces() {
     const interfaces = [];
@@ -6155,13 +6388,13 @@ class InterfaceSync {
     return interfaces;
   }
   async isInterfaceSynced(interfaceInfo) {
-    const targetFolder = path27.join(this.bpModulesPath, `interface_${pascalCase(interfaceInfo.alias)}`);
-    if (!existsSync4(targetFolder)) {
+    const targetFolder = path29.join(this.bpModulesPath, `interface_${pascalCase(interfaceInfo.alias)}`);
+    if (!existsSync5(targetFolder)) {
       return false;
     }
     try {
-      const indexPath = path27.join(targetFolder, "index.ts");
-      if (!existsSync4(indexPath)) {
+      const indexPath = path29.join(targetFolder, "index.ts");
+      if (!existsSync5(indexPath)) {
         return false;
       }
       const indexContent = await fs14.readFile(indexPath, "utf-8");
@@ -6206,19 +6439,19 @@ class InterfaceSync {
     });
   }
   async renameInterfaceFolder(interfaceInfo) {
-    const sourceFolder = path27.join(this.bpModulesPath, interfaceInfo.name);
-    const targetFolder = path27.join(this.bpModulesPath, `interface_${pascalCase(interfaceInfo.alias)}`);
-    if (!existsSync4(sourceFolder)) {
+    const sourceFolder = path29.join(this.bpModulesPath, interfaceInfo.name);
+    const targetFolder = path29.join(this.bpModulesPath, `interface_${pascalCase(interfaceInfo.alias)}`);
+    if (!existsSync5(sourceFolder)) {
       throw new Error(`Interface folder not found: ${sourceFolder}`);
     }
-    if (existsSync4(targetFolder)) {
+    if (existsSync5(targetFolder)) {
       await fs14.rm(targetFolder, { recursive: true, force: true });
     }
     await fs14.rename(sourceFolder, targetFolder);
   }
   async removeInterfaceFolder(alias) {
-    const targetFolder = path27.join(this.bpModulesPath, `interface_${pascalCase(alias)}`);
-    if (existsSync4(targetFolder)) {
+    const targetFolder = path29.join(this.bpModulesPath, `interface_${pascalCase(alias)}`);
+    if (existsSync5(targetFolder)) {
       await fs14.rm(targetFolder, { recursive: true, force: true });
     }
   }
@@ -6262,26 +6495,26 @@ function isBuiltinAction(name) {
   return !!Object.values(BuiltInActions2).find((x) => x.name === name);
 }
 function getImportPath(from, to) {
-  return path30.relative(path30.dirname(from), to).replace(/\.ts$/, "").replace(/\\/g, "/");
+  return path32.relative(path32.dirname(from), to).replace(/\.ts$/, "").replace(/\\/g, "/");
 }
 
 class BotGenerator {
   projectPath;
   outputPath;
   constructor(options) {
-    this.projectPath = path30.resolve(options.projectPath);
-    this.outputPath = path30.resolve(options.outputPath || path30.join(this.projectPath, ".adk"));
+    this.projectPath = path32.resolve(options.projectPath);
+    this.outputPath = path32.resolve(options.outputPath || path32.join(this.projectPath, ".adk"));
   }
   async listFilesRecursive(rootDir) {
     try {
-      if (!existsSync5(rootDir))
+      if (!existsSync6(rootDir))
         return [];
       const result = [];
       const walk = async (dir, relativeBase) => {
         const entries = await fs15.readdir(dir, { withFileTypes: true });
         for (const entry of entries) {
-          const abs = path30.join(dir, entry.name);
-          const rel = path30.join(relativeBase, entry.name);
+          const abs = path32.join(dir, entry.name);
+          const rel = path32.join(relativeBase, entry.name);
           if (entry.isDirectory()) {
             await walk(abs, rel);
           } else {
@@ -6296,13 +6529,13 @@ class BotGenerator {
     }
   }
   async removeEmptyDirectories(rootDir) {
-    if (!existsSync5(rootDir))
+    if (!existsSync6(rootDir))
       return;
     const removeIfEmpty = async (dir) => {
       const entries = await fs15.readdir(dir, { withFileTypes: true });
       for (const entry of entries) {
         if (entry.isDirectory()) {
-          const subdir = path30.join(dir, entry.name);
+          const subdir = path32.join(dir, entry.name);
           await removeIfEmpty(subdir);
         }
       }
@@ -6325,7 +6558,9 @@ class BotGenerator {
     await this.generateInterfacesTypes();
     await this.generateTableTypes();
     await this.generateTriggerTypes();
+    await this.generateTagTypes();
     await this.generateStateTypes();
+    await this.generateConfigurationTypes();
     await this.generateWorkflowTypes();
     await this.generateConversationTypes();
     await this.generateActionTypes();
@@ -6340,22 +6575,22 @@ class BotGenerator {
   }
   async generateIntegrationsTypes() {
     const project = await AgentProject.load(this.projectPath);
-    const manager2 = new IntegrationManager({
+    const manager3 = new IntegrationManager({
       workspaceId: project.agentInfo?.workspaceId
     });
-    const integrations = await manager2.loadIntegrations(project.dependencies || {});
-    const integrationsDir = path30.join(this.projectPath, ".adk", "integrations");
+    const integrations = await manager3.loadIntegrations(project.dependencies || {});
+    const integrationsDir = path32.join(this.projectPath, ".adk", "integrations");
     const existingIntegrationFiles = await this.listFilesRecursive(integrationsDir);
     let aliases = new Set;
     let files = new Set;
     for (const integration of integrations.integrations) {
       if (integration.enabled && integration.definition) {
         const types6 = await generateIntegrationTypes(integration);
-        const importPath = `./${path30.join("integrations", types6.names.paths.index).replace(/\\/g, "/")}`;
+        const importPath = `./${path32.join("integrations", types6.names.paths.index).replace(/\\/g, "/")}`;
         aliases.add(`"${integration.alias}": import("${importPath}").${types6.names.typings.index}`);
         for (const [filePath, content] of Object.entries(types6.files)) {
-          const fullPath = path30.join(this.projectPath, ".adk", "integrations", filePath);
-          const dir = path30.dirname(fullPath);
+          const fullPath = path32.join(this.projectPath, ".adk", "integrations", filePath);
+          const dir = path32.dirname(fullPath);
           await fs15.mkdir(dir, { recursive: true });
           await createFile(fullPath, content);
           files.add(filePath);
@@ -6376,11 +6611,11 @@ class BotGenerator {
         };
       }
       `;
-    await createFile(path30.join(this.projectPath, ".adk", "integrations-types.d.ts"), await formatCode(types5));
+    await createFile(path32.join(this.projectPath, ".adk", "integrations-types.d.ts"), await formatCode(types5));
     const staleIntegrationFiles = existingIntegrationFiles.filter((f) => !files.has(f));
     if (staleIntegrationFiles.length > 0) {
       for (const rel of staleIntegrationFiles) {
-        const abs = path30.join(integrationsDir, rel);
+        const abs = path32.join(integrationsDir, rel);
         try {
           await fs15.rm(abs, { force: true });
         } catch {}
@@ -6396,10 +6631,18 @@ class BotGenerator {
     const project = await AgentProject.load(this.projectPath);
     await generateTriggerTypes(project);
   }
+  async generateTagTypes() {
+    const project = await AgentProject.load(this.projectPath);
+    await generateTagTypes(project);
+  }
   async generateStateTypes() {
     const project = await AgentProject.load(this.projectPath);
     await generateStateTypes(project);
   }
+  async generateConfigurationTypes() {
+    const project = await AgentProject.load(this.projectPath);
+    await generateConfigurationTypes(project);
+  }
   async generateEventTypes() {
     const project = await AgentProject.load(this.projectPath);
     await generateEventTypes(project);
@@ -6424,10 +6667,10 @@ class BotGenerator {
   }
   async generateRuntimeTypes() {
     const project = await AgentProject.load(this.projectPath);
-    const manager2 = new IntegrationManager({
+    const manager3 = new IntegrationManager({
       workspaceId: project.agentInfo?.workspaceId
     });
-    const integrations = await manager2.loadIntegrations(project.dependencies || {});
+    const integrations = await manager3.loadIntegrations(project.dependencies || {});
     const channels = [];
     for (const integration of integrations.integrations) {
       if (integration.enabled && integration.definition) {
@@ -6441,7 +6684,7 @@ class BotGenerator {
     let botStateType = "{}";
     let userStateType = "{}";
     try {
-      const configPath = path30.join(project.path, "agent.config.ts");
+      const configPath = path32.join(project.path, "agent.config.ts");
       const configModule = await import(`${configPath}?t=${Date.now()}`);
       const config = configModule.default;
       if (config?.bot?.state) {
@@ -6477,28 +6720,28 @@ declare module "@botpress/runtime/_types/state" {
   export type UserState = ${userStateType};
 }
 `;
-    await createFile(path30.join(this.projectPath, ".adk", "runtime.d.ts"), await formatCode(types5));
+    await createFile(path32.join(this.projectPath, ".adk", "runtime.d.ts"), await formatCode(types5));
   }
   async generateInterfacesTypes() {
     const project = await AgentProject.load(this.projectPath);
     const integrationManager = new IntegrationManager({
       workspaceId: project.agentInfo?.workspaceId
     });
-    const manager2 = new InterfaceManager;
-    const interfacesDir = path30.join(this.projectPath, ".adk", "interfaces");
+    const manager3 = new InterfaceManager;
+    const interfacesDir = path32.join(this.projectPath, ".adk", "interfaces");
     const existingInterfaceFiles = await this.listFilesRecursive(interfacesDir);
-    const interfaces = await manager2.loadInterfaces(project.dependencies || {}).then((result) => result.interfaces.filter((int) => int.definition).map((x) => x.definition));
+    const interfaces = await manager3.loadInterfaces(project.dependencies || {}).then((result) => result.interfaces.filter((int) => int.definition).map((x) => x.definition));
     const integrations = await integrationManager.loadIntegrations(project.dependencies || {}).then((result) => result.integrations.filter((int) => int.enabled && int.definition).map((x) => x.definition));
     let imports = new Set;
     let aliases = new Set;
     let files = new Set;
     for (const int of interfaces) {
       const types6 = await generateInterfaceTypes(int, integrations);
-      imports.add(`import { ${types6.names.typings.index} } from "./${path30.join("interfaces", types6.names.paths.index).replace(/\\/g, "/")}";`);
+      imports.add(`import { ${types6.names.typings.index} } from "./${path32.join("interfaces", types6.names.paths.index).replace(/\\/g, "/")}";`);
       aliases.add(`"${types6.names.name}": ${types6.names.typings.index}`);
       for (const [filePath, content] of Object.entries(types6.files)) {
-        const fullPath = path30.join(this.projectPath, ".adk", "interfaces", filePath);
-        const dir = path30.dirname(fullPath);
+        const fullPath = path32.join(this.projectPath, ".adk", "interfaces", filePath);
+        const dir = path32.dirname(fullPath);
         await fs15.mkdir(dir, { recursive: true });
         await createFile(fullPath, content);
         files.add(filePath);
@@ -6535,12 +6778,12 @@ declare module "@botpress/runtime/_types/state" {
 `)}
       };
       `;
-    await createFile(path30.join(this.projectPath, ".adk", "interfaces.d.ts"), await formatCode(types5));
-    await createFile(path30.join(this.projectPath, ".adk", "interfaces.ts"), await formatCode(consts));
+    await createFile(path32.join(this.projectPath, ".adk", "interfaces.d.ts"), await formatCode(types5));
+    await createFile(path32.join(this.projectPath, ".adk", "interfaces.ts"), await formatCode(consts));
     const staleInterfaceFiles = existingInterfaceFiles.filter((f) => !files.has(f));
     if (staleInterfaceFiles.length > 0) {
       for (const rel of staleInterfaceFiles) {
-        const abs = path30.join(interfacesDir, rel);
+        const abs = path32.join(interfacesDir, rel);
         try {
           await fs15.rm(abs, { force: true });
         } catch {}
@@ -6573,7 +6816,7 @@ declare module "@botpress/runtime/_types/state" {
 `) : ""}
       } as Record<string, IntegrationPackage>;
     `;
-    await createFile(path30.join(this.outputPath, "src", "integrations.ts"), content);
+    await createFile(path32.join(this.outputPath, "src", "integrations.ts"), content);
   }
   async generateInterfacesDefinition() {
     const interfaces = BUILTIN_INTERFACES;
@@ -6596,7 +6839,7 @@ declare module "@botpress/runtime/_types/state" {
 `) : ""}
       } as Record<string, InterfacePackage>;
     `;
-    await createFile(path30.join(this.outputPath, "src", "interfaces.ts"), await formatCode(content));
+    await createFile(path32.join(this.outputPath, "src", "interfaces.ts"), await formatCode(content));
   }
   async generateBotDefinition() {
     const project = await AgentProject.load(this.projectPath);
@@ -6611,8 +6854,22 @@ declare module "@botpress/runtime/_types/state" {
       const configData = config && Object.keys(config).length > 0 ? `, configuration: ${JSON.stringify(config)}` : "";
       addIntegrations.push(`bot.addIntegration(${importName}, { alias: "${alias}", enabled: true${configType}${configData} });`);
     }
+    const userTags = {};
     const conversationTags = {};
+    const messageTags = {};
     const workflowTags = {};
+    if (project.config?.user?.tags) {
+      Object.assign(userTags, project.config.user.tags);
+    }
+    if (project.config?.conversation?.tags) {
+      Object.assign(conversationTags, project.config.conversation.tags);
+    }
+    if (project.config?.message?.tags) {
+      Object.assign(messageTags, project.config.message.tags);
+    }
+    if (project.config?.workflow?.tags) {
+      Object.assign(workflowTags, project.config.workflow.tags);
+    }
     const crypto4 = __require("crypto");
     const hashString = (str) => {
       return crypto4.createHash("md5").update(str).digest("hex").substring(0, 5).toUpperCase();
@@ -6633,7 +6890,7 @@ declare module "@botpress/runtime/_types/state" {
         if (isBuiltinWorkflow2(workflow.definition.name)) {
           continue;
         }
-        const workflowPath = path30.join(project.path, workflow.path);
+        const workflowPath = path32.join(project.path, workflow.path);
         const workflowModule = await import(`${workflowPath}?t=${Date.now()}`);
         const workflowInstance = workflowModule.default || workflowModule[workflow.export];
         if (workflowInstance) {
@@ -6690,6 +6947,8 @@ declare module "@botpress/runtime/_types/state" {
       };
     }
     const toEventName = (ename) => ename.replaceAll(/[^a-zA-Z0-9]/g, "").toLowerCase();
+    const configSchema = project.config?.configuration?.schema;
+    const configSchemaCode = configSchema ? transforms3.fromJSONSchema(configSchema.toJSONSchema()).toTypescriptSchema() : undefined;
     const content = dedent`
       import { BotDefinition, z } from "@botpress/sdk";
       import {
@@ -6712,20 +6971,40 @@ declare module "@botpress/runtime/_types/state" {
           runtime: "adk",
           runtimeVersion: "${ADK_VERSION}",
         },
-
+        ${configSchemaCode ? `
+configuration: {
+  schema: ${configSchemaCode}
+},
+` : ""}
+        ${Object.keys(userTags).length > 0 ? `user: {
+          tags: {
+            ${Object.entries(userTags).map(([tag, meta]) => `// ${meta.title}
+            ${meta.description ? `// ${meta.description}
+            ` : ""}"${tag}": ${JSON.stringify(meta)}`).join(`,
+            `)}
+          },
+        },` : ""}
+        ${Object.keys(messageTags).length > 0 ? `message: {
+          tags: {
+            ${Object.entries(messageTags).map(([tag, meta]) => `// ${meta.title}
+            ${meta.description ? `// ${meta.description}
+            ` : ""}"${tag}": ${JSON.stringify(meta)}`).join(`,
+            `)}
+          },
+        },` : ""}
         conversation: {
           tags: {
             ${Object.entries(conversationTags).map(([tag, meta]) => `// ${meta.title}
-            // ${meta.description}
-            "${tag}": ${JSON.stringify(meta)}`).join(`,
-            `)}
+            ${meta.description ? `// ${meta.description}
+            ` : ""}"${tag}": ${JSON.stringify(meta)}`).join(`,
+            `)}${Object.keys(conversationTags).length > 0 ? "," : ""}
           },
         },
         ${Object.keys(workflowTags).length > 0 ? `workflow: {
           tags: {
             ${Object.entries(workflowTags).map(([tag, meta]) => `// ${meta.title}
-            // ${meta.description}
-            "${tag}": ${JSON.stringify(meta)}`).join(`,
+            ${meta.description ? `// ${meta.description}
+            ` : ""}"${tag}": ${JSON.stringify(meta)}`).join(`,
             `)}
           },
         },` : ""}
@@ -6839,7 +7118,7 @@ declare module "@botpress/runtime/_types/state" {
 
       export default bot;
     `;
-    await createFile(path30.join(this.outputPath, "bot.definition.ts"), await formatCode(content));
+    await createFile(path32.join(this.outputPath, "bot.definition.ts"), await formatCode(content));
   }
   async generateBotIndex() {
     const content = dedent`
@@ -6873,7 +7152,7 @@ declare module "@botpress/runtime/_types/state" {
 
       export default bot
     `;
-    await createFile(path30.join(this.outputPath, "src", "index.ts"), await formatCode(content));
+    await createFile(path32.join(this.outputPath, "src", "index.ts"), await formatCode(content));
   }
   async generatePackageJson(project) {
     const packageJson = {
@@ -6892,7 +7171,7 @@ declare module "@botpress/runtime/_types/state" {
         typescript: "^5.9.3"
       }
     };
-    await createFile(path30.join(this.outputPath, "package.json"), JSON.stringify(packageJson, null, 2));
+    await createFile(path32.join(this.outputPath, "package.json"), JSON.stringify(packageJson, null, 2));
   }
   async generateTsConfig() {
     const tsConfig = {
@@ -6923,7 +7202,7 @@ declare module "@botpress/runtime/_types/state" {
       },
       include: [".botpress/**/*", "src/**/*", "bp_modules/**/*", "./*.ts", "./*.json", "../*.d.ts"]
     };
-    await createFile(path30.join(this.outputPath, "tsconfig.json"), JSON.stringify(tsConfig, null, 2));
+    await createFile(path32.join(this.outputPath, "tsconfig.json"), JSON.stringify(tsConfig, null, 2));
   }
   async generateGlobalTypes() {
     const content = dedent`
@@ -6946,12 +7225,12 @@ declare module "@botpress/runtime/_types/state" {
 
       export {};
     `;
-    await createFile(path30.join(this.outputPath, "global.d.ts"), await formatCode(content));
+    await createFile(path32.join(this.outputPath, "global.d.ts"), await formatCode(content));
   }
   async copyAssets() {
-    const assetsPath = path30.join(this.projectPath, "assets");
-    const targetPath = path30.join(this.outputPath, "assets");
-    if (existsSync5(assetsPath)) {
+    const assetsPath = path32.join(this.projectPath, "assets");
+    const targetPath = path32.join(this.outputPath, "assets");
+    if (existsSync6(assetsPath)) {
       await fs15.mkdir(targetPath, { recursive: true });
       await this.copyDirectory(assetsPath, targetPath);
     }
@@ -6959,8 +7238,8 @@ declare module "@botpress/runtime/_types/state" {
   async copyDirectory(src, dest) {
     const entries = await fs15.readdir(src, { withFileTypes: true });
     for (const entry of entries) {
-      const srcPath = path30.join(src, entry.name);
-      const destPath = path30.join(dest, entry.name);
+      const srcPath = path32.join(src, entry.name);
+      const destPath = path32.join(dest, entry.name);
       if (entry.isDirectory()) {
         await fs15.mkdir(destPath, { recursive: true });
         await this.copyDirectory(srcPath, destPath);
@@ -6972,16 +7251,16 @@ declare module "@botpress/runtime/_types/state" {
   async generateAdkRuntime() {
     const project = new AgentProject(this.projectPath);
     await project.reload();
-    const srcDir = path30.join(this.outputPath, "src");
+    const srcDir = path32.join(this.outputPath, "src");
     {
-      const dest = path30.join(srcDir, "conversations.ts");
+      const dest = path32.join(srcDir, "conversations.ts");
       const imports = new Map;
       const exports = new Set;
       let index = 1;
       for (const conversation of project.conversations) {
         if (!imports.has(conversation.path)) {
           const name = `conversations_${index++}`;
-          const importPath = getImportPath(dest, path30.join(project.path, conversation.path));
+          const importPath = getImportPath(dest, path32.join(project.path, conversation.path));
           imports.set(conversation.path, {
             name,
             statement: `import * as ${name} from "${importPath}";`
@@ -7007,14 +7286,14 @@ declare module "@botpress/runtime/_types/state" {
       await createFile(dest, await formatCode(content2));
     }
     {
-      const dest = path30.join(srcDir, "knowledge.ts");
+      const dest = path32.join(srcDir, "knowledge.ts");
       const imports = new Map;
       const exports = new Set;
       let index = 1;
       for (const knowledge of project.knowledge) {
         if (!imports.has(knowledge.path)) {
           const name = `knowledge_${index++}`;
-          const importPath = getImportPath(dest, path30.join(project.path, knowledge.path));
+          const importPath = getImportPath(dest, path32.join(project.path, knowledge.path));
           imports.set(knowledge.path, {
             name,
             statement: `import * as ${name} from "${importPath}";`
@@ -7040,7 +7319,7 @@ declare module "@botpress/runtime/_types/state" {
       await createFile(dest, await formatCode(content2));
     }
     {
-      const dest = path30.join(srcDir, "triggers.ts");
+      const dest = path32.join(srcDir, "triggers.ts");
       const { transforms: transforms4 } = await import("@botpress/sdk");
       const imports = new Map;
       const exports = new Set;
@@ -7049,7 +7328,7 @@ declare module "@botpress/runtime/_types/state" {
       for (const trigger of project.triggers) {
         if (!imports.has(trigger.path)) {
           const name = `triggers_${index++}`;
-          const importPath = getImportPath(dest, path30.join(project.path, trigger.path));
+          const importPath = getImportPath(dest, path32.join(project.path, trigger.path));
           imports.set(trigger.path, {
             name,
             statement: `import * as ${name} from "${importPath}";`
@@ -7059,7 +7338,7 @@ declare module "@botpress/runtime/_types/state" {
       }
       for (const trigger of project.triggers) {
         try {
-          const absolutePath = path30.join(project.path, trigger.path);
+          const absolutePath = path32.join(project.path, trigger.path);
           const triggerModule = await import(`${absolutePath}?t=${Date.now()}`);
           const triggerInstance = triggerModule[trigger.export] || triggerModule.default;
           if (triggerInstance && triggerInstance.payload) {
@@ -7102,7 +7381,7 @@ declare module "@botpress/runtime/_types/state" {
       await createFile(dest, await formatCode(content2));
     }
     {
-      const dest = path30.join(srcDir, "workflows.ts");
+      const dest = path32.join(srcDir, "workflows.ts");
       const imports = new Map;
       const exports = new Set;
       let index = 1;
@@ -7112,7 +7391,7 @@ declare module "@botpress/runtime/_types/state" {
         }
         if (!imports.has(workflow.path)) {
           const name = `workflows_${index++}`;
-          const importPath = getImportPath(dest, path30.join(project.path, workflow.path));
+          const importPath = getImportPath(dest, path32.join(project.path, workflow.path));
           const statement = `import * as ${name} from "${importPath}";`;
           imports.set(workflow.path, {
             name,
@@ -7146,7 +7425,7 @@ declare module "@botpress/runtime/_types/state" {
       await createFile(dest, await formatCode(content2));
     }
     {
-      const dest = path30.join(srcDir, "actions.ts");
+      const dest = path32.join(srcDir, "actions.ts");
       const imports = new Map;
       const exports = new Set;
       let index = 1;
@@ -7156,7 +7435,7 @@ declare module "@botpress/runtime/_types/state" {
         }
         if (!imports.has(action.path)) {
           const name = `actions_${index++}`;
-          const importPath = getImportPath(dest, path30.join(project.path, action.path));
+          const importPath = getImportPath(dest, path32.join(project.path, action.path));
           imports.set(action.path, {
             name,
             statement: `import * as ${name} from "${importPath}";`
@@ -7182,14 +7461,14 @@ declare module "@botpress/runtime/_types/state" {
       await createFile(dest, await formatCode(content2));
     }
     {
-      const dest = path30.join(srcDir, "tables.ts");
+      const dest = path32.join(srcDir, "tables.ts");
       const imports = new Map;
       const exports = new Set;
       let index = 1;
       for (const table of project.tables) {
         if (!imports.has(table.path)) {
           const name = `tables_${index++}`;
-          const importPath = getImportPath(dest, path30.join(project.path, table.path));
+          const importPath = getImportPath(dest, path32.join(project.path, table.path));
           imports.set(table.path, {
             name,
             statement: `import * as ${name} from "${importPath}";`
@@ -7215,8 +7494,8 @@ declare module "@botpress/runtime/_types/state" {
       await createFile(dest, await formatCode(content2));
     }
     {
-      const dest = path30.join(srcDir, "config.ts");
-      const importPath = getImportPath(dest, path30.join(project.path, "agent.config.ts"));
+      const dest = path32.join(srcDir, "config.ts");
+      const importPath = getImportPath(dest, path32.join(project.path, "agent.config.ts"));
       const content2 = `
       ////////////////////////////////////////////////////////
       // DO NOT EDIT THIS FILE DIRECTLY
@@ -7282,13 +7561,13 @@ declare module "@botpress/runtime/_types/state" {
         handlers.actions.setup(bot);
       }
     `;
-    await createFile(path30.join(this.outputPath, "src", "adk-runtime.ts"), await formatCode(content));
+    await createFile(path32.join(this.outputPath, "src", "adk-runtime.ts"), await formatCode(content));
   }
   async copyAssetsRuntime() {
-    const assetsRuntimePath = path30.join(this.projectPath, ".adk", "assets-runtime.ts");
-    if (existsSync5(assetsRuntimePath)) {
+    const assetsRuntimePath = path32.join(this.projectPath, ".adk", "assets-runtime.ts");
+    if (existsSync6(assetsRuntimePath)) {
       const content = await fs15.readFile(assetsRuntimePath, "utf-8");
-      await createFile(path30.join(this.outputPath, "src", "assets-runtime.ts"), await formatCode(content));
+      await createFile(path32.join(this.outputPath, "src", "assets-runtime.ts"), await formatCode(content));
     }
   }
 }
@@ -7297,9 +7576,9 @@ async function generateBotProject(options) {
   await generator.generate();
   await generator.generateAdkRuntime();
   await generator.copyAssetsRuntime();
-  const devIdManager = new DevIdManager(options.projectPath, options.outputPath || path30.join(options.projectPath, ".adk", "bot"));
+  const devIdManager = new DevIdManager(options.projectPath, options.outputPath || path32.join(options.projectPath, ".adk", "bot"));
   await devIdManager.restoreDevId();
-  const integrationSync = new IntegrationSync(options.projectPath, options.outputPath || path30.join(options.projectPath, ".adk", "bot"));
+  const integrationSync = new IntegrationSync(options.projectPath, options.outputPath || path32.join(options.projectPath, ".adk", "bot"));
   const integrationSyncResult = await integrationSync.syncIntegrations();
   if (integrationSyncResult.errors.length > 0) {
     console.warn(`⚠️  Some integrations failed to sync:`);
@@ -7307,7 +7586,7 @@ async function generateBotProject(options) {
       console.warn(`  - ${alias}: ${error}`);
     });
   }
-  const interfaceSync = new InterfaceSync(options.projectPath, options.outputPath || path30.join(options.projectPath, ".adk", "bot"));
+  const interfaceSync = new InterfaceSync(options.projectPath, options.outputPath || path32.join(options.projectPath, ".adk", "bot"));
   const interfaceSyncResult = await interfaceSync.syncInterfaces();
   if (interfaceSyncResult.errors.length > 0) {
     console.warn(`⚠️  Some interfaces failed to sync:`);
@@ -7317,7 +7596,7 @@ async function generateBotProject(options) {
   }
 }
 // src/tables/table-manager.ts
-import { Client as Client11 } from "@botpress/client";
+import { Client as Client12 } from "@botpress/client";
 import { transforms as transforms4 } from "@botpress/sdk";
 class TableManager {
   client;
@@ -7331,7 +7610,7 @@ class TableManager {
     if (!this.client) {
       const credentials = await auth.getActiveCredentials();
       this.assertBotId("initialize client");
-      this.client = new Client11({
+      this.client = new Client12({
         token: credentials.token,
         apiUrl: credentials.apiUrl,
         botId: this.botId,
@@ -7795,10 +8074,10 @@ class TableManager {
 }
 // src/knowledge/manager.ts
 import crypto4 from "crypto";
-import path31 from "path";
+import path33 from "path";
 import fs16 from "fs/promises";
 import { glob } from "glob";
-import { Client as Client12 } from "@botpress/client";
+import { Client as Client13 } from "@botpress/client";
 import { DataSource } from "@botpress/runtime";
 
 // src/knowledge/types.ts
@@ -7842,7 +8121,7 @@ class KnowledgeManager {
     if (!this.client) {
       const credentials = await auth.getActiveCredentials();
       this.assertBotId("initialize client");
-      this.client = new Client12({
+      this.client = new Client13({
         token: credentials.token,
         apiUrl: credentials.apiUrl,
         botId: this.botId,
@@ -8185,14 +8464,14 @@ class KnowledgeManager {
   }
   async scanLocalFileHashes(directoryPath, filterFn) {
     const projectDir = this.project.path;
-    const directory = path31.resolve(projectDir, directoryPath);
+    const directory = path33.resolve(projectDir, directoryPath);
     if (this.fileHashCache.has(directory)) {
       return this.fileHashCache.get(directory);
     }
     const files = glob.sync(directory + "/**/*.*", { absolute: true, nodir: true }).filter((file) => !filterFn || filterFn(file));
     const hashes = {};
     for (const file of files) {
-      const relPath = path31.relative(directory, file);
+      const relPath = path33.relative(directory, file);
       const content = await fs16.readFile(file);
       hashes[relPath] = crypto4.createHash("sha256").update(content).digest("hex");
     }
@@ -8297,7 +8576,7 @@ class KnowledgeManager {
   }
   async syncDirectorySource(client, kbName, sourceId, directoryPath, filterFn, force) {
     const projectDir = this.project.path;
-    const directory = path31.resolve(projectDir, directoryPath);
+    const directory = path33.resolve(projectDir, directoryPath);
     if (!directory.startsWith(projectDir)) {
       throw new Error("Directory path must be within the agent's directory");
     }
@@ -8318,8 +8597,8 @@ class KnowledgeManager {
       return true;
     }).map((f) => ({
       abs: f,
-      rel: path31.relative(directory, f),
-      name: path31.basename(f)
+      rel: path33.relative(directory, f),
+      name: path33.basename(f)
     }));
     console.log(`  Found ${allFiles.length} files in ${directoryPath}`);
     const cachedHashes = await this.scanLocalFileHashes(directoryPath, filterFn);
@@ -8391,7 +8670,7 @@ class KnowledgeManager {
         return null;
       }
     } catch {}
-    const title = path31.basename(local.name, path31.extname(local.name));
+    const title = path33.basename(local.name, path33.extname(local.name));
     const metadata = {
       hash,
       sourceId,
@@ -8519,7 +8798,7 @@ class KBSyncFormatter {
 import { watch as watch2, readdirSync as readdirSync2 } from "fs";
 import { EventEmitter as EventEmitter3 } from "events";
 import { join as join8, relative as relative3 } from "path";
-import { existsSync as existsSync6 } from "fs";
+import { existsSync as existsSync7 } from "fs";
 
 class FileWatcher2 extends EventEmitter3 {
   projectPath;
@@ -8537,12 +8816,12 @@ class FileWatcher2 extends EventEmitter3 {
     const rootFiles = ["package.json", "agent.json", "agent.config.ts"];
     for (const file of rootFiles) {
       const filePath = join8(this.projectPath, file);
-      if (existsSync6(filePath)) {
+      if (existsSync7(filePath)) {
         this.watchFile(filePath);
       }
     }
     const srcPath = join8(this.projectPath, "src");
-    if (existsSync6(srcPath)) {
+    if (existsSync7(srcPath)) {
       this.initializeDirectoryState(srcPath);
       this.watchDirectory(srcPath);
     }
@@ -8591,7 +8870,7 @@ class FileWatcher2 extends EventEmitter3 {
     }
   }
   handleFileChange(filePath) {
-    const fileExists = existsSync6(filePath);
+    const fileExists = existsSync7(filePath);
     const previousState = this.fileStates.get(filePath);
     let changeType;
     if (!fileExists && previousState !== undefined) {
@@ -8631,7 +8910,7 @@ class FileWatcher2 extends EventEmitter3 {
     this.emit("change", event);
   }
   updateFileState(filePath) {
-    if (existsSync6(filePath)) {
+    if (existsSync7(filePath)) {
       this.fileStates.set(filePath, Date.now());
     }
   }
@@ -8655,8 +8934,8 @@ class FileWatcher2 extends EventEmitter3 {
   }
 }
 // src/preflight/checker.ts
-import { Client as Client13 } from "@botpress/client";
-import path32 from "path";
+import { Client as Client14 } from "@botpress/client";
+import path34 from "path";
 
 // src/preflight/types.ts
 function hasIntegrationChanges(integrations) {
@@ -8870,7 +9149,7 @@ class PreflightChecker {
       if (!workspaceId) {
         throw new Error('No workspace ID found. Please login with "adk login"');
       }
-      this.client = new Client13({
+      this.client = new Client14({
         token: credentials.token,
         apiUrl: credentials.apiUrl,
         workspaceId,
@@ -9018,7 +9297,7 @@ class PreflightChecker {
     options?.onProgress?.("Regenerating bot project...");
     await generateBotProject({
       projectPath: this.projectPath,
-      outputPath: path32.join(this.projectPath, ".adk", "bot")
+      outputPath: path34.join(this.projectPath, ".adk", "bot")
     });
     options?.onSuccess?.("Bot project regenerated");
   }
@@ -9062,6 +9341,8 @@ export {
   FileWatcher2 as FileWatcher,
   EnhancedInterfaceCache,
   DevIdManager,
+  CredentialsManager,
+  ConfigManager,
   BpDevCommand,
   BpDeployCommand,
   BpChatCommand,
@@ -9069,10 +9350,13 @@ export {
   BpAddCommand,
   BotGenerator,
   BaseCommand,
+  BP_CLI_VERSION,
+  BP_CLI_INSTALL_DIR,
+  BP_CLI_BIN_PATH,
   AssetsManager,
   AgentProjectGenerator,
   AgentProject
 };
 
-//# debugId=48F84F096052D59764756E2164756E21
+//# debugId=DE1D2CDC9130C9B064756E2164756E21
 //# sourceMappingURL=index.js.map