@botpress/adk 1.15.3 → 1.15.4

package/dist/index.js

@@ -15,14 +15,23 @@ var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
 // src/agent-project/types.ts
 import { z } from "@botpress/sdk";
-var dependenciesSchema, agentInfoSchema, ValidationErrorCode, ValidationSeverity, ProjectState;
+var pluginDependencyMappingSchema, dependenciesSchema, agentInfoSchema, 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(),
+    plugins: z.record(z.object({
+      version: z.string(),
+      config: z.record(z.any()).optional(),
+      dependencies: z.record(pluginDependencyMappingSchema).optional()
     })).optional()
   });
   agentInfoSchema = z.object({
@@ -44,7 +53,10 @@ var init_types = __esm(() => {
     ValidationErrorCode2["INVALID_DEPENDENCIES_SCHEMA"] = "INVALID_DEPENDENCIES_SCHEMA";
     ValidationErrorCode2["INVALID_VERSION_FORMAT"] = "INVALID_VERSION_FORMAT";
     ValidationErrorCode2["INVALID_INTEGRATION_ALIAS"] = "INVALID_INTEGRATION_ALIAS";
+    ValidationErrorCode2["INVALID_PLUGIN_ALIAS"] = "INVALID_PLUGIN_ALIAS";
     ValidationErrorCode2["UNKNOWN_INTEGRATION"] = "UNKNOWN_INTEGRATION";
+    ValidationErrorCode2["UNKNOWN_PLUGIN"] = "UNKNOWN_PLUGIN";
+    ValidationErrorCode2["INVALID_PLUGIN_DEPENDENCY"] = "INVALID_PLUGIN_DEPENDENCY";
     ValidationErrorCode2["INCOMPATIBLE_VERSION"] = "INCOMPATIBLE_VERSION";
     ValidationErrorCode2["CIRCULAR_DEPENDENCY"] = "CIRCULAR_DEPENDENCY";
     ValidationErrorCode2["FILE_TOO_LARGE"] = "FILE_TOO_LARGE";
@@ -227,6 +239,61 @@ class ValidationErrors {
       context: { integration, required, available }
     };
   }
+  static invalidPluginAlias(alias) {
+    return {
+      $type: ValidationErrors.$type,
+      code: "INVALID_PLUGIN_ALIAS" /* INVALID_PLUGIN_ALIAS */,
+      severity: "error" /* ERROR */,
+      message: `Invalid plugin alias '${alias}'`,
+      file: "agent.config.ts",
+      hint: 'Plugin aliases must be 2-100 characters and contain only lowercase letters, numbers, underscores, and hyphens (e.g., "hitl", "my-plugin")',
+      context: { alias }
+    };
+  }
+  static invalidPluginVersionFormat(plugin, version) {
+    return {
+      $type: ValidationErrors.$type,
+      code: "INVALID_VERSION_FORMAT" /* INVALID_VERSION_FORMAT */,
+      severity: "error" /* ERROR */,
+      message: `Invalid version format '${version}' for plugin '${plugin}'`,
+      file: "agent.config.ts",
+      hint: 'Use exact versioning (e.g., "1.2.3", "2.0.0", "1.5.0")',
+      context: { plugin, version }
+    };
+  }
+  static unknownPlugin(plugin, source, detailedMessage) {
+    return {
+      $type: ValidationErrors.$type,
+      code: "UNKNOWN_PLUGIN" /* UNKNOWN_PLUGIN */,
+      severity: "error" /* ERROR */,
+      message: detailedMessage || `Unknown plugin '${plugin}' from source '${source}'`,
+      file: "agent.config.ts",
+      hint: detailedMessage ? undefined : `Check if the plugin name is correct or if it exists on the Botpress Hub`,
+      context: { plugin, source }
+    };
+  }
+  static invalidPluginDependency(plugin, integrationAlias, availableIntegrations) {
+    const available = availableIntegrations.length > 0 ? availableIntegrations.join(", ") : "(none)";
+    return {
+      $type: ValidationErrors.$type,
+      code: "INVALID_PLUGIN_DEPENDENCY" /* INVALID_PLUGIN_DEPENDENCY */,
+      severity: "error" /* ERROR */,
+      message: `Plugin "${plugin}" references integration "${integrationAlias}" in its dependencies, but "${integrationAlias}" is not declared in dependencies.integrations`,
+      file: "agent.config.ts",
+      hint: `Add "${integrationAlias}" to dependencies.integrations, or update the plugin dependency to reference one of: ${available}`,
+      context: { plugin, integrationAlias, availableIntegrations }
+    };
+  }
+  static pluginVersionError(plugin, errorMessage) {
+    return {
+      $type: ValidationErrors.$type,
+      code: "UNKNOWN_PLUGIN" /* UNKNOWN_PLUGIN */,
+      severity: "error" /* ERROR */,
+      message: errorMessage,
+      file: "agent.config.ts",
+      hint: `Update the version for "${plugin}" in agent.config.ts dependencies`
+    };
+  }
   static fileTooLarge(file, size, maxSize) {
     return {
       $type: ValidationErrors.$type,
@@ -651,7 +718,7 @@ var PRETTIER_CONFIG, formatCode = async (code, filepath) => {
 `));
     return code;
   }
-}, ADK_VERSION = "1.15.3", relative2 = (from, to) => {
+}, ADK_VERSION = "1.15.4", relative2 = (from, to) => {
   const fromDir = path10.dirname(from);
   const relative3 = path10.relative(fromDir, to);
   return relative3.startsWith(".") ? relative3 : `./${relative3}`;
@@ -675,7 +742,7 @@ var exports_action_types = {};
 __export(exports_action_types, {
   generateActionTypes: () => generateActionTypes
 });
-import path32 from "path";
+import path36 from "path";
 async function generateActionTypes(project) {
   const actionDefs = [];
   for (const action of project.actions) {
@@ -690,7 +757,7 @@ async function generateActionTypes(project) {
     };`);
         continue;
       }
-      const absolutePath = path32.join(project.path, action.path);
+      const absolutePath = path36.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) {
@@ -735,7 +802,7 @@ ${actionDefs.join(`
   };
 }
 `;
-  const actionTypesPath = path32.join(project.path, ".adk", "action-types.d.ts");
+  const actionTypesPath = path36.join(project.path, ".adk", "action-types.d.ts");
   await createFile(actionTypesPath, await formatCode(content));
 }
 var init_action_types = __esm(() => {
@@ -748,7 +815,7 @@ var exports_integration_action_types = {};
 __export(exports_integration_action_types, {
   generateIntegrationActionTypes: () => generateIntegrationActionTypes
 });
-import path33 from "path";
+import path37 from "path";
 async function generateIntegrationActionTypes(project) {
   const content = `
 ////////////////////////////////////////////////////////
@@ -782,7 +849,7 @@ type IntegrationsMap<T> = {
 export type IntegrationActions = IntegrationsMap<Integrations>;
 }
 `;
-  const integrationActionTypesPath = path33.join(project.path, ".adk", "integration-action-types.d.ts");
+  const integrationActionTypesPath = path37.join(project.path, ".adk", "integration-action-types.d.ts");
   await createFile(integrationActionTypesPath, await formatCode(content));
 }
 var init_integration_action_types = __esm(() => {
@@ -794,7 +861,7 @@ var init_integration_action_types = __esm(() => {
 var require_package = __commonJS((exports, module) => {
   module.exports = {
     name: "@botpress/adk",
-    version: "1.15.3",
+    version: "1.15.4",
     description: "Core ADK library for building AI agents on Botpress",
     type: "module",
     main: "dist/index.js",
@@ -841,7 +908,7 @@ var require_package = __commonJS((exports, module) => {
       "@botpress/cli": "^5.2.0",
       "@botpress/client": "^1.35.0",
       "@botpress/cognitive": "^0.3.14",
-      "@botpress/runtime": "^1.15.3",
+      "@botpress/runtime": "^1.15.4",
       "@botpress/sdk": "^5.4.3",
       "@bpinternal/jex": "^1.2.4",
       "@bpinternal/yargs-extra": "^0.0.21",
@@ -2618,6 +2685,118 @@ class IntegrationParser {
     return errors;
   }
 }
+var PLUGIN_ALIAS_MIN_LENGTH = 2;
+var PLUGIN_ALIAS_MAX_LENGTH = 100;
+var PLUGIN_ALIAS_REGEX = /^[a-z][a-z0-9_-]*$/;
+function isPluginAliasValid(alias) {
+  return alias.length >= PLUGIN_ALIAS_MIN_LENGTH && alias.length <= PLUGIN_ALIAS_MAX_LENGTH && PLUGIN_ALIAS_REGEX.test(alias);
+}
+var pluginRefSchema = z2.string().transform((val, ctx) => {
+  const match = val.match(/^([^/@]+)@(.+)$/);
+  if (!match) {
+    ctx.addIssue({
+      code: ZodIssueCode.custom,
+      message: `Invalid plugin version format: ${val}. Expected format: 'name@version' (no workspace prefix)`
+    });
+    return z2.NEVER;
+  }
+  const [, name, version] = match;
+  return {
+    name,
+    version,
+    fullName: name
+  };
+});
+
+class PluginParser {
+  static parsePluginRef(versionString) {
+    const result = pluginRefSchema.safeParse(versionString);
+    if (!result.success) {
+      throw new Error(result.error.errors[0]?.message || "Invalid plugin version format");
+    }
+    return result.data;
+  }
+  static parsePlugins(dependencies) {
+    const plugins = [];
+    const errors = [];
+    if (!dependencies.plugins) {
+      return { plugins, errors };
+    }
+    for (const [alias, value] of Object.entries(dependencies.plugins)) {
+      try {
+        if (!isPluginAliasValid(alias)) {
+          errors.push(ValidationErrors.invalidPluginAlias(alias));
+          continue;
+        }
+        const ref = this.parsePluginRef(value.version);
+        const versionResult = versionSchema.safeParse(ref.version);
+        if (!versionResult.success) {
+          errors.push(ValidationErrors.invalidPluginVersionFormat(alias, ref.version));
+        }
+        plugins.push({
+          alias,
+          ref,
+          config: value.config,
+          dependencies: value.dependencies
+        });
+      } catch (error) {
+        errors.push(ValidationErrors.invalidDependenciesSyntax(`Invalid plugin '${alias}': ${error instanceof Error ? error.message : String(error)}`));
+      }
+    }
+    return { plugins, errors };
+  }
+  static validateDependencyReferences(dependencies) {
+    const errors = [];
+    if (!dependencies.plugins) {
+      return errors;
+    }
+    const integrationAliases = Object.keys(dependencies.integrations || {});
+    for (const [alias, pluginConfig] of Object.entries(dependencies.plugins)) {
+      if (!pluginConfig.dependencies) {
+        continue;
+      }
+      for (const [depAlias, depMapping] of Object.entries(pluginConfig.dependencies)) {
+        if (!integrationAliases.includes(depMapping.integrationAlias)) {
+          errors.push(ValidationErrors.invalidPluginDependency(alias, depMapping.integrationAlias, integrationAliases));
+        }
+      }
+    }
+    return errors;
+  }
+  static checkDuplicates(plugins) {
+    const errors = [];
+    const seen = new Map;
+    for (const plugin of plugins) {
+      const key = plugin.ref.fullName;
+      const group = seen.get(key) || [];
+      group.push(plugin);
+      seen.set(key, group);
+    }
+    for (const [pluginName, group] of seen.entries()) {
+      if (group.length > 1) {
+        const duplicateConfigs = [];
+        for (let i = 0;i < group.length; i++) {
+          for (let j = i + 1;j < group.length; j++) {
+            const configA = JSON.stringify(group[i].config ?? {});
+            const configB = JSON.stringify(group[j].config ?? {});
+            if (configA === configB) {
+              if (!duplicateConfigs.includes(group[i].alias)) {
+                duplicateConfigs.push(group[i].alias);
+              }
+              if (!duplicateConfigs.includes(group[j].alias)) {
+                duplicateConfigs.push(group[j].alias);
+              }
+            }
+          }
+        }
+        if (duplicateConfigs.length > 0) {
+          errors.push(ValidationErrors.warning(`Plugin '${pluginName}' has aliases with identical configurations: ${duplicateConfigs.join(", ")}. Consider using different configs or removing duplicates.`, "agent.config.ts"));
+        }
+      }
+    }
+    return errors;
+  }
+}
 
 // src/integrations/manager.ts
 init_validation_errors();
@@ -6403,7 +6582,7 @@ class AgentProjectGenerator {
         deploy: "adk deploy"
       },
       dependencies: {
-        "@botpress/runtime": `^${"1.15.3"}`
+        "@botpress/runtime": `^${"1.15.4"}`
       },
       devDependencies: {
         typescript: "^5.9.3"
@@ -6616,133 +6795,352 @@ export default {};
 `);
   }
 }
-// src/generators/assets.ts
-init_fs();
+// src/plugins/enhanced-cache.ts
+import fs12 from "fs/promises";
 import path16 from "path";
-async function generateAssetsTypes(projectPath) {
-  const assetsManager = new AssetsManager({ projectPath });
-  const typesCode = await assetsManager.generateTypes();
-  const typesPath = path16.join(projectPath, defaultAdkFolder, "assets.d.ts");
-  await createFile(typesPath, typesCode);
-}
-async function generateAssetsRuntime(projectPath, botId, workspaceId) {
-  const assetsManager = new AssetsManager({ projectPath, botId, workspaceId });
-  const enrichedAssets = await assetsManager.getEnrichedLocalAssets();
-  const assetsMap = {};
-  const localHashesMap = {};
-  const cacheManager = new AssetsCacheManager(projectPath);
-  const cache2 = await cacheManager.load();
-  for (const asset of enrichedAssets) {
-    assetsMap[asset.path] = asset;
-    const cacheEntry = cache2.entries[asset.path];
-    if (cacheEntry) {
-      localHashesMap[asset.path] = cacheEntry.localHash;
+import os8 from "os";
+
+class EnhancedPluginCache {
+  cacheDir;
+  resolutionsDir;
+  definitionsDir;
+  noCache;
+  constructor(noCache = false) {
+    this.noCache = noCache;
+    this.cacheDir = path16.join(os8.homedir(), ".adk", "cache", "plugins");
+    this.resolutionsDir = path16.join(this.cacheDir, "resolutions");
+    this.definitionsDir = path16.join(this.cacheDir, "definitions");
+  }
+  async ensureCacheDirs() {
+    await fs12.mkdir(this.resolutionsDir, { recursive: true });
+    await fs12.mkdir(this.definitionsDir, { recursive: true });
+  }
+  async getResolution(name, version) {
+    if (this.noCache) {
+      return null;
+    }
+    try {
+      const key = this.getResolutionKey(name, version);
+      const cachePath = path16.join(this.resolutionsDir, `${key}.json`);
+      const data = await fs12.readFile(cachePath, "utf-8");
+      const resolution = JSON.parse(data);
+      const cachedAt = new Date(resolution.cachedAt);
+      const now = new Date;
+      const ageMinutes = (now.getTime() - cachedAt.getTime()) / (1000 * 60);
+      if (ageMinutes > 5) {
+        return null;
+      }
+      return resolution;
+    } catch {
+      return null;
     }
   }
-  const runtimeCode = `
-// Auto-generated assets metadata
-import { Asset, initAssets } from '@botpress/runtime/runtime';
-
-// Static asset metadata (populated at build time)
-export const assetsMetadata: Record<string, Asset> = ${JSON.stringify(assetsMap, null, 2)};
-
-// Local hashes from cache
-export const localHashes: Record<string, string> = ${JSON.stringify(localHashesMap, null, 2)};
-
-// Initialize the assets runtime with metadata and local hashes
-// The global object should be passed by the agent initialization code
-export function initializeAssets(globalObj: any = globalThis) {
-  initAssets(globalObj, assetsMetadata, localHashes);
-}
-
-// Auto-initialize if running in a supported environment
-if (typeof globalThis !== 'undefined') {
-  initializeAssets(globalThis);
-} else if (typeof global !== 'undefined') {
-  initializeAssets(global);
-}
-`;
-  const runtimePath = path16.join(projectPath, defaultAdkFolder, "assets-runtime.ts");
-  await createFile(runtimePath, runtimeCode);
-}
-async function initAssets(projectPath, botId, workspaceId) {
-  const assetsManager = new AssetsManager({ projectPath, botId, workspaceId });
-  if (await assetsManager.hasAssetsDirectory()) {
-    await generateAssetsTypes(projectPath);
-    await generateAssetsRuntime(projectPath, botId, workspaceId);
-  } else {
-    const emptyTypesCode = `// No assets directory found
-import { Asset } from '@botpress/runtime';
-
-export type AssetPaths = never;
-
-export interface AssetPathMap {}
-
-// Runtime asset access
-declare global {
-  const assets: {
-    get<T extends AssetPaths>(path: T): Asset;
-    list(): Asset[];
-    getSyncStatus(): { 
-      synced: boolean; 
-      neverSynced: string[]; 
-      stale: string[];
-      upToDate: string[];
+  async setResolution(name, version, pluginId, updatedAt) {
+    await this.ensureCacheDirs();
+    const key = this.getResolutionKey(name, version);
+    const cachePath = path16.join(this.resolutionsDir, `${key}.json`);
+    const resolution = {
+      pluginId,
+      updatedAt,
+      cachedAt: new Date().toISOString()
     };
-  };
-}
-`;
-    const typesPath = path16.join(projectPath, defaultAdkFolder, "assets.d.ts");
-    await createFile(typesPath, emptyTypesCode);
-    const emptyRuntimeCode = `
-// No assets available
-import { Asset, initAssets } from '@botpress/runtime';
-
-// Empty asset metadata
-export const assetsMetadata: Record<string, Asset> = {};
-
-// Initialize with empty metadata
-export function initializeAssets(globalObj: any = globalThis) {
-  initAssets(globalObj, assetsMetadata);
-}
-
-// Auto-initialize if running in a supported environment
-if (typeof globalThis !== 'undefined') {
-  initializeAssets(globalThis);
-} else if (typeof global !== 'undefined') {
-  initializeAssets(global);
-}
-`;
-    const runtimePath = path16.join(projectPath, defaultAdkFolder, "assets-runtime.ts");
-    await createFile(runtimePath, emptyRuntimeCode);
+    await fs12.writeFile(cachePath, JSON.stringify(resolution, null, 2));
   }
-}
-// src/generators/integration-types.ts
-import { transforms } from "@botpress/sdk";
-import crypto2 from "crypto";
-import path17 from "path";
-
-// src/utils/strings.ts
-function pascalCase(str) {
-  return str.split(/[-_\s]+/).map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()).join("");
-}
-function camelCase(str) {
-  const pascal = pascalCase(str);
-  return pascal.charAt(0).toLowerCase() + pascal.slice(1);
-}
-function snakeCase(str) {
-  return str.replace(/([a-z])([A-Z])/g, "$1_$2").replace(/[\s-]+/g, "_").toLowerCase();
-}
-
-// src/generators/integration-types.ts
-init_utils();
-
-// src/utils/ids.ts
-function getIntegrationAlias(integrationName) {
-  return integrationName.replace(/\//g, "__").replace(/-/g, "_").toLowerCase();
-}
-
-// src/generators/integration-types.ts
+  async getDefinition(pluginId, updatedAt) {
+    if (this.noCache) {
+      return null;
+    }
+    try {
+      const key = this.getDefinitionKey(pluginId, updatedAt);
+      const cachePath = path16.join(this.definitionsDir, `${key}.json`);
+      const data = await fs12.readFile(cachePath, "utf-8");
+      const cached = JSON.parse(data);
+      return cached.definition;
+    } catch {
+      return null;
+    }
+  }
+  async setDefinition(pluginId, updatedAt, definition) {
+    await this.ensureCacheDirs();
+    const key = this.getDefinitionKey(pluginId, updatedAt);
+    const cachePath = path16.join(this.definitionsDir, `${key}.json`);
+    const cached = {
+      definition,
+      cachedAt: new Date().toISOString()
+    };
+    await fs12.writeFile(cachePath, JSON.stringify(cached, null, 2));
+  }
+  async clear() {
+    try {
+      const resolutionFiles = await fs12.readdir(this.resolutionsDir);
+      await Promise.all(resolutionFiles.map((file) => fs12.unlink(path16.join(this.resolutionsDir, file))));
+      const definitionFiles = await fs12.readdir(this.definitionsDir);
+      await Promise.all(definitionFiles.map((file) => fs12.unlink(path16.join(this.definitionsDir, file))));
+    } catch {}
+  }
+  async getStats() {
+    const getDirectoryStats = async (dir) => {
+      try {
+        const files = await fs12.readdir(dir);
+        let totalSize = 0;
+        for (const file of files) {
+          const stats = await fs12.stat(path16.join(dir, file));
+          totalSize += stats.size;
+        }
+        return {
+          count: files.length,
+          sizeBytes: totalSize
+        };
+      } catch {
+        return { count: 0, sizeBytes: 0 };
+      }
+    };
+    const [resolutions, definitions] = await Promise.all([
+      getDirectoryStats(this.resolutionsDir),
+      getDirectoryStats(this.definitionsDir)
+    ]);
+    return { resolutions, definitions };
+  }
+  getResolutionKey(name, version) {
+    const key = `${name}_${version}`;
+    return key.replace(/[^a-zA-Z0-9_-]/g, "_");
+  }
+  getDefinitionKey(pluginId, updatedAt) {
+    const key = `${pluginId}_${updatedAt}`;
+    return key.replace(/[^a-zA-Z0-9_-]/g, "_");
+  }
+}
+// src/plugins/manager.ts
+import { Client as Client13 } from "@botpress/client";
+init_validation_errors();
+
+class PluginManager {
+  cache;
+  options;
+  client;
+  constructor(options = {}) {
+    this.options = options;
+    this.cache = new EnhancedPluginCache(options.noCache || false);
+  }
+  async getClient() {
+    if (!this.client) {
+      const credentials = this.options.credentials || await auth.getActiveCredentials();
+      if (!this.options.workspaceId && !credentials.workspaceId) {
+        throw new Error('No workspace ID found in current profile. Please login again with "adk login"');
+      }
+      const workspaceId = this.options.workspaceId || credentials.workspaceId;
+      this.client = new Client13({
+        token: credentials.token,
+        apiUrl: credentials.apiUrl,
+        workspaceId,
+        headers: {
+          "x-multiple-integrations": "true"
+        }
+      });
+    }
+    return this.client;
+  }
+  async loadPlugins(dependencies) {
+    const errors = [];
+    const warnings = [];
+    const parseResult = PluginParser.parsePlugins(dependencies);
+    const plugins = parseResult.plugins;
+    errors.push(...parseResult.errors);
+    const duplicateWarnings = PluginParser.checkDuplicates(plugins);
+    warnings.push(...duplicateWarnings);
+    const fetchPromises = plugins.map(async (plugin) => {
+      try {
+        plugin.definition = await this.fetchPlugin(plugin.ref);
+      } catch (error) {
+        if (error instanceof Error && error.message.includes("version")) {
+          errors.push(ValidationErrors.pluginVersionError(plugin.alias, error.message));
+        } else {
+          const errorMessage = error instanceof Error ? error.message : undefined;
+          errors.push(ValidationErrors.unknownPlugin(plugin.alias, plugin.ref.fullName, errorMessage));
+        }
+      }
+    });
+    await Promise.all(fetchPromises);
+    return { plugins, errors, warnings };
+  }
+  async fetchPlugin(ref) {
+    const cachedResolution = await this.cache.getResolution(ref.name, ref.version);
+    if (cachedResolution) {
+      const cachedDefinition = await this.cache.getDefinition(cachedResolution.pluginId, cachedResolution.updatedAt);
+      if (cachedDefinition) {
+        return cachedDefinition;
+      }
+    }
+    const client = await this.getClient();
+    const plugin = await this._findPublicPlugin(client, ref);
+    if (!plugin) {
+      throw new Error(`Plugin "${ref.name}" not found on the Botpress Hub`);
+    }
+    await this.cache.setResolution(ref.name, ref.version, plugin.id, plugin.updatedAt);
+    await this.cache.setDefinition(plugin.id, plugin.updatedAt, plugin);
+    return plugin;
+  }
+  async _findPublicPlugin(client, ref) {
+    try {
+      const response = await client.getPublicPlugin({
+        name: ref.name,
+        version: ref.version
+      });
+      return response.plugin;
+    } catch (error) {
+      if (this._isResourceNotFoundError(error)) {
+        return;
+      }
+      throw error;
+    }
+  }
+  _isResourceNotFoundError(error) {
+    if (error && typeof error === "object" && "type" in error) {
+      return error.type === "ResourceNotFound";
+    }
+    return false;
+  }
+  async getCacheStats() {
+    const stats = await this.cache.getStats();
+    return {
+      count: stats.resolutions.count + stats.definitions.count,
+      sizeBytes: stats.resolutions.sizeBytes + stats.definitions.sizeBytes
+    };
+  }
+  async clearCache() {
+    await this.cache.clear();
+  }
+}
+// src/generators/assets.ts
+init_fs();
+import path17 from "path";
+async function generateAssetsTypes(projectPath) {
+  const assetsManager = new AssetsManager({ projectPath });
+  const typesCode = await assetsManager.generateTypes();
+  const typesPath = path17.join(projectPath, defaultAdkFolder, "assets.d.ts");
+  await createFile(typesPath, typesCode);
+}
+async function generateAssetsRuntime(projectPath, botId, workspaceId) {
+  const assetsManager = new AssetsManager({ projectPath, botId, workspaceId });
+  const enrichedAssets = await assetsManager.getEnrichedLocalAssets();
+  const assetsMap = {};
+  const localHashesMap = {};
+  const cacheManager = new AssetsCacheManager(projectPath);
+  const cache2 = await cacheManager.load();
+  for (const asset of enrichedAssets) {
+    assetsMap[asset.path] = asset;
+    const cacheEntry = cache2.entries[asset.path];
+    if (cacheEntry) {
+      localHashesMap[asset.path] = cacheEntry.localHash;
+    }
+  }
+  const runtimeCode = `
+// Auto-generated assets metadata
+import { Asset, initAssets } from '@botpress/runtime/runtime';
+
+// Static asset metadata (populated at build time)
+export const assetsMetadata: Record<string, Asset> = ${JSON.stringify(assetsMap, null, 2)};
+
+// Local hashes from cache
+export const localHashes: Record<string, string> = ${JSON.stringify(localHashesMap, null, 2)};
+
+// Initialize the assets runtime with metadata and local hashes
+// The global object should be passed by the agent initialization code
+export function initializeAssets(globalObj: any = globalThis) {
+  initAssets(globalObj, assetsMetadata, localHashes);
+}
+
+// Auto-initialize if running in a supported environment
+if (typeof globalThis !== 'undefined') {
+  initializeAssets(globalThis);
+} else if (typeof global !== 'undefined') {
+  initializeAssets(global);
+}
+`;
+  const runtimePath = path17.join(projectPath, defaultAdkFolder, "assets-runtime.ts");
+  await createFile(runtimePath, runtimeCode);
+}
+async function initAssets(projectPath, botId, workspaceId) {
+  const assetsManager = new AssetsManager({ projectPath, botId, workspaceId });
+  if (await assetsManager.hasAssetsDirectory()) {
+    await generateAssetsTypes(projectPath);
+    await generateAssetsRuntime(projectPath, botId, workspaceId);
+  } else {
+    const emptyTypesCode = `// No assets directory found
+import { Asset } from '@botpress/runtime';
+
+export type AssetPaths = never;
+
+export interface AssetPathMap {}
+
+// Runtime asset access
+declare global {
+  const assets: {
+    get<T extends AssetPaths>(path: T): Asset;
+    list(): Asset[];
+    getSyncStatus(): { 
+      synced: boolean; 
+      neverSynced: string[]; 
+      stale: string[];
+      upToDate: string[];
+    };
+  };
+}
+`;
+    const typesPath = path17.join(projectPath, defaultAdkFolder, "assets.d.ts");
+    await createFile(typesPath, emptyTypesCode);
+    const emptyRuntimeCode = `
+// No assets available
+import { Asset, initAssets } from '@botpress/runtime';
+
+// Empty asset metadata
+export const assetsMetadata: Record<string, Asset> = {};
+
+// Initialize with empty metadata
+export function initializeAssets(globalObj: any = globalThis) {
+  initAssets(globalObj, assetsMetadata);
+}
+
+// Auto-initialize if running in a supported environment
+if (typeof globalThis !== 'undefined') {
+  initializeAssets(globalThis);
+} else if (typeof global !== 'undefined') {
+  initializeAssets(global);
+}
+`;
+    const runtimePath = path17.join(projectPath, defaultAdkFolder, "assets-runtime.ts");
+    await createFile(runtimePath, emptyRuntimeCode);
+  }
+}
+// src/generators/integration-types.ts
+import { transforms } from "@botpress/sdk";
+import crypto2 from "crypto";
+import path18 from "path";
+
+// src/utils/strings.ts
+function pascalCase(str) {
+  return str.split(/[-_\s]+/).map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()).join("");
+}
+function camelCase(str) {
+  const pascal = pascalCase(str);
+  return pascal.charAt(0).toLowerCase() + pascal.slice(1);
+}
+function snakeCase(str) {
+  return str.replace(/([a-z])([A-Z])/g, "$1_$2").replace(/[\s-]+/g, "_").toLowerCase();
+}
+
+// src/generators/integration-types.ts
+init_utils();
+
+// src/utils/ids.ts
+function getIntegrationAlias(integrationName) {
+  return integrationName.replace(/\//g, "__").replace(/-/g, "_").toLowerCase();
+}
+function getPluginAlias(pluginName) {
+  return pluginName.replace(/-/g, "_").toLowerCase();
+}
+
+// src/generators/integration-types.ts
 var getIntegrationHash = (integration) => {
   return crypto2.createHash("sha256").update(`${integration.alias}|${integration.definition?.id}|${integration.definition?.version}|${integration.definition?.updatedAt}`).digest("hex");
 };
@@ -6757,12 +7155,12 @@ var getIntegrationNames = (integration) => ({
     configurations: `Integration_Configurations_${getPascalAlias(integration)}`
   },
   paths: {
-    index: path17.join(snakeCase(getPascalAlias(integration)), `index.ts`),
-    actions: path17.join(snakeCase(getPascalAlias(integration)), `actions.ts`),
-    channels: path17.join(snakeCase(getPascalAlias(integration)), `channels.ts`),
-    events: path17.join(snakeCase(getPascalAlias(integration)), `events.ts`),
-    users: path17.join(snakeCase(getPascalAlias(integration)), `users.ts`),
-    configurations: path17.join(snakeCase(getPascalAlias(integration)), `configurations.ts`)
+    index: path18.join(snakeCase(getPascalAlias(integration)), `index.ts`),
+    actions: path18.join(snakeCase(getPascalAlias(integration)), `actions.ts`),
+    channels: path18.join(snakeCase(getPascalAlias(integration)), `channels.ts`),
+    events: path18.join(snakeCase(getPascalAlias(integration)), `events.ts`),
+    users: path18.join(snakeCase(getPascalAlias(integration)), `users.ts`),
+    configurations: path18.join(snakeCase(getPascalAlias(integration)), `configurations.ts`)
   }
 });
 async function generateIntegrationTypes(integration) {
@@ -7016,7 +7414,7 @@ Description: ${tag?.description}`);
 // src/generators/client-wrapper.ts
 init_utils();
 init_fs();
-import path18 from "path";
+import path19 from "path";
 import crypto3 from "crypto";
 import { readFile as readFile3 } from "fs/promises";
 import { BuiltInWorkflows as BuiltInWorkflows2 } from "@botpress/runtime/internal";
@@ -7038,7 +7436,7 @@ async function generateClientWrapper(project) {
         });
         continue;
       }
-      const absolutePath = path18.join(project.path, action.path);
+      const absolutePath = path19.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) {
@@ -7065,7 +7463,7 @@ async function generateClientWrapper(project) {
       if (isBuiltinWorkflow(workflow.definition.name)) {
         continue;
       }
-      const workflowPath = path18.join(project.path, workflow.path);
+      const workflowPath = path19.join(project.path, workflow.path);
       const workflowModule = await import(`${workflowPath}?t=${Date.now()}`);
       const workflowInstance = workflowModule[workflow.export] || workflowModule.default;
       if (workflowInstance) {
@@ -7084,7 +7482,7 @@ async function generateClientWrapper(project) {
   const tableTypes = [];
   for (const table of project.tables) {
     try {
-      const tablePath = path18.join(project.path, table.path);
+      const tablePath = path19.join(project.path, table.path);
       const tableModule = await import(`${tablePath}?t=${Date.now()}`);
       const tableInstance = tableModule.default || tableModule[table.export];
       if (tableInstance && tableInstance.columns) {
@@ -7347,76 +7745,225 @@ export function createAdkClient(client: Client): AdkClient {
 `)}
     },
 
-    tables: {
-      ${tableTypes.map((table) => `
-      '${table.name}': {
-        findTableRows: async (params) => {
-          return client.findTableRows({
-            table: '${table.name}',
-            ...params,
-          }) as any
-        },
-        getTableRow: async (params) => {
-          return client.getTableRow({
-            table: '${table.name}',
-            ...params,
-          }) as any
-        },
-        createTableRows: async (params) => {
-          return client.createTableRows({
-            table: '${table.name}',
-            ...params,
-          }) as any
-        },
-        updateTableRows: async (params) => {
-          return client.updateTableRows({
-            table: '${table.name}',
-            ...params,
-          }) as any
-        },
-        upsertTableRows: async (params) => {
-          return client.upsertTableRows({
-            table: '${table.name}',
-            ...params,
-          }) as any
-        },
-        deleteTableRows: async (params) => {
-          return client.deleteTableRows({
-            table: '${table.name}',
-            ...params,
-          }) as any
-        },
+    tables: {
+      ${tableTypes.map((table) => `
+      '${table.name}': {
+        findTableRows: async (params) => {
+          return client.findTableRows({
+            table: '${table.name}',
+            ...params,
+          }) as any
+        },
+        getTableRow: async (params) => {
+          return client.getTableRow({
+            table: '${table.name}',
+            ...params,
+          }) as any
+        },
+        createTableRows: async (params) => {
+          return client.createTableRows({
+            table: '${table.name}',
+            ...params,
+          }) as any
+        },
+        updateTableRows: async (params) => {
+          return client.updateTableRows({
+            table: '${table.name}',
+            ...params,
+          }) as any
+        },
+        upsertTableRows: async (params) => {
+          return client.upsertTableRows({
+            table: '${table.name}',
+            ...params,
+          }) as any
+        },
+        deleteTableRows: async (params) => {
+          return client.deleteTableRows({
+            table: '${table.name}',
+            ...params,
+          }) as any
+        },
+      }
+      `).join(`,
+`)}
+    },
+
+    client,
+  }
+}
+`;
+  const clientWrapperPath = path19.join(project.path, ".adk", "client.ts");
+  const formattedContent = await formatCode(content);
+  const contentHash = crypto3.createHash("sha256").update(formattedContent.replace(/\/\/ Generated at: .+\n/, "")).digest("hex");
+  try {
+    const existingContent = await readFile3(clientWrapperPath, "utf-8");
+    const existingHash = crypto3.createHash("sha256").update(existingContent.replace(/\/\/ Generated at: .+\n/, "")).digest("hex");
+    if (contentHash === existingHash) {
+      return;
+    }
+  } catch {}
+  await createFile(clientWrapperPath, formattedContent);
+}
+// src/bot-generator/generator.ts
+import dedent from "dedent";
+import { existsSync as existsSync8 } from "fs";
+import fs18 from "fs/promises";
+import path38 from "path";
+
+// src/generators/plugin-types.ts
+import { transforms as transforms2 } from "@botpress/sdk";
+import crypto4 from "crypto";
+import path20 from "path";
+init_utils();
+function stripRefs(schema) {
+  if (typeof schema !== "object" || schema === null) {
+    return schema;
+  }
+  if (schema.$ref) {
+    return { type: "object", additionalProperties: true, "x-stripped-ref": schema.$ref };
+  }
+  const result = {};
+  for (const [key, value] of Object.entries(schema)) {
+    if (key === "$defs" || key === "definitions") {
+      continue;
+    }
+    if (Array.isArray(value)) {
+      result[key] = value.map((item) => typeof item === "object" && item !== null ? stripRefs(item) : item);
+    } else if (typeof value === "object" && value !== null) {
+      result[key] = stripRefs(value);
+    } else {
+      result[key] = value;
+    }
+  }
+  return result;
+}
+function jsonSchemaToTypescript(schema) {
+  const cleaned = stripRefs(schema);
+  return transforms2.fromJSONSchema(cleaned).toTypescriptType();
+}
+var getPluginHash = (plugin) => {
+  return crypto4.createHash("sha256").update(`${plugin.alias}|${plugin.definition?.id}|${plugin.definition?.version}|${plugin.definition?.updatedAt}`).digest("hex");
+};
+var getPascalAlias2 = (plugin) => pascalCase(getPluginAlias(plugin.alias));
+var getPluginNames = (plugin) => ({
+  typings: {
+    index: `Plugin_All_${getPascalAlias2(plugin)}`,
+    actions: `Plugin_Actions_${getPascalAlias2(plugin)}`
+  },
+  paths: {
+    index: path20.join(snakeCase(getPascalAlias2(plugin)), `index.ts`),
+    actions: path20.join(snakeCase(getPascalAlias2(plugin)), `actions.ts`)
+  }
+});
+async function generatePluginTypes(plugin) {
+  const names = getPluginNames(plugin);
+  const hash = getPluginHash(plugin);
+  const rel = (to) => {
+    const from = names.paths.index;
+    return relative2(from, to).replace(/\.ts$/i, "");
+  };
+  let tIndex = `
+  ////////////////////////////////////////////////////////
+  // DO NOT EDIT THIS FILE DIRECTLY
+  // This file is auto-generated from the Botpress ADK
+  // ADK Version: ${ADK_VERSION}
+  // Plugin: ${plugin.definition?.name}
+  // Version: ${plugin.definition?.version}
+  // File: ${names.paths.index}
+  // Hash: ${hash}
+  // Updated at: ${plugin.definition?.updatedAt}
+  ////////////////////////////////////////////////////////
+
+  import { Plugin_Actions_${getPascalAlias2(plugin)} } from "${rel(names.paths.actions)}";
+
+  export * from "${rel(names.paths.actions)}";
+
+  export type Plugin_All_${getPascalAlias2(plugin)} = {
+    actions: Plugin_Actions_${getPascalAlias2(plugin)};
+  };
+  `;
+  let tActions = `
+  ////////////////////////////////////////////////////////
+  // DO NOT EDIT THIS FILE DIRECTLY
+  // This file is auto-generated from the Botpress ADK
+  // ADK Version: ${ADK_VERSION}
+  // Plugin: ${plugin.definition?.name}
+  // Version: ${plugin.definition?.version}
+  // File: ${names.paths.actions}
+  // Hash: ${hash}
+  // Updated at: ${plugin.definition?.updatedAt}
+  ////////////////////////////////////////////////////////
+
+  export type Plugin_Actions_${getPascalAlias2(plugin)} = {`;
+  for (const [name, action] of Object.entries(plugin.definition.actions)) {
+    const input = jsonSchemaToTypescript(action.input.schema);
+    const output = jsonSchemaToTypescript(action.output.schema);
+    tActions += `
+    ${toMultilineComment(`Title: ${action.title || name}
+Description: ${action.description || "No description"}`)}
+    "${name}": {
+      input: ${input};
+      output: ${output};
+    },
+`;
+  }
+  tActions += `};`;
+  return {
+    names,
+    files: {
+      [names.paths.index]: await formatCode(tIndex),
+      [names.paths.actions]: await formatCode(tActions)
+    }
+  };
+}
+
+// src/generators/plugin-action-types.ts
+init_utils();
+init_fs();
+import path21 from "path";
+async function generatePluginActionTypes(project) {
+  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()}
+////////////////////////////////////////////////////////
+
+type Plugins = import("@botpress/runtime/_types/plugins").Plugins;
+
+declare module "@botpress/runtime/_types/plugin-actions" {
+
+export interface CallableAction<I, O> {
+  (input: I): Promise<O>;
+}
+
+type Callable<T> = T extends { input: infer I; output: infer O }
+  ? CallableAction<I, O>
+  : never;
+
+type PluginsMap<T> = {
+  [Plugin in keyof T]: T[Plugin] extends { actions: infer Actions }
+    ? {
+        actions: {
+          [Action in keyof Actions]: Callable<Actions[Action]>;
+        };
       }
-      `).join(`,
-`)}
-    },
+    : never;
+};
 
-    client,
-  }
+export type PluginActions = PluginsMap<Plugins>;
 }
 `;
-  const clientWrapperPath = path18.join(project.path, ".adk", "client.ts");
-  const formattedContent = await formatCode(content);
-  const contentHash = crypto3.createHash("sha256").update(formattedContent.replace(/\/\/ Generated at: .+\n/, "")).digest("hex");
-  try {
-    const existingContent = await readFile3(clientWrapperPath, "utf-8");
-    const existingHash = crypto3.createHash("sha256").update(existingContent.replace(/\/\/ Generated at: .+\n/, "")).digest("hex");
-    if (contentHash === existingHash) {
-      return;
-    }
-  } catch {}
-  await createFile(clientWrapperPath, formattedContent);
+  const pluginActionTypesPath = path21.join(project.path, ".adk", "plugin-action-types.d.ts");
+  await createFile(pluginActionTypesPath, await formatCode(content));
 }
-// src/bot-generator/generator.ts
-import dedent from "dedent";
-import { existsSync as existsSync7 } from "fs";
-import fs16 from "fs/promises";
-import path34 from "path";
 
 // src/generators/interface-types.ts
-import { transforms as transforms2 } from "@botpress/sdk";
-import crypto4 from "crypto";
-import path19 from "path";
+import { transforms as transforms3 } from "@botpress/sdk";
+import crypto5 from "crypto";
+import path22 from "path";
 init_utils();
 var sameMajorVersion = (a, b) => {
   const majorA = a.split(".")[0];
@@ -7428,7 +7975,7 @@ var getIntegrationInterface = (integration, int) => {
 };
 var getInterfaceHash = (int, integrations) => {
   const versions = integrations.filter((x) => !!getIntegrationInterface(x.definition, int)).map((x) => `${x.definition.id}|${x.definition.version}|${x.definition.updatedAt}|${x.alias}`).sort().join("|");
-  return crypto4.createHash("sha256").update(`${int.id}|${int.version}|${int.updatedAt}|${versions}`).digest("hex");
+  return crypto5.createHash("sha256").update(`${int.id}|${int.version}|${int.updatedAt}|${versions}`).digest("hex");
 };
 var getInterfaceNames = (int) => ({
   name: camelCase(int.name),
@@ -7437,8 +7984,8 @@ var getInterfaceNames = (int) => ({
     actions: `Interface_Actions_${pascalCase(int.name)}`
   },
   paths: {
-    index: path19.join(snakeCase(int.name), `index.ts`),
-    actions: path19.join(snakeCase(int.name), `actions.ts`)
+    index: path22.join(snakeCase(int.name), `index.ts`),
+    actions: path22.join(snakeCase(int.name), `actions.ts`)
   }
 });
 async function generateInterfaceTypes(int, integrations) {
@@ -7490,12 +8037,12 @@ async function generateInterfaceTypes(int, integrations) {
       const entities = Object.entries(integrationInt.entities).reduce((acc, [entityName, value]) => {
         const entity = integration.entities[value.name];
         if (entity) {
-          acc[entityName] = transforms2.fromJSONSchema(entity.schema).title(entity.title || entityName).describe(entity.description || "No description");
+          acc[entityName] = transforms3.fromJSONSchema(entity.schema).title(entity.title || entityName).describe(entity.description || "No description");
         }
         return acc;
       }, {});
-      const input = transforms2.fromJSONSchema(action.input.schema).dereference(entities).toTypescriptType();
-      const output = transforms2.fromJSONSchema(action.output.schema).dereference(entities).toTypescriptType();
+      const input = transforms3.fromJSONSchema(action.input.schema).dereference(entities).toTypescriptType();
+      const output = transforms3.fromJSONSchema(action.output.schema).dereference(entities).toTypescriptType();
       cActions.add(`"${alias}:${name}": "${alias}:${mapping}"`);
       iActions += `
       ${toMultilineComment(`Title: ${action.title || name}
@@ -7543,12 +8090,12 @@ Description: ${action.description || "No description"}`)}
 // src/generators/table-types.ts
 init_utils();
 init_fs();
-import path20 from "path";
+import path23 from "path";
 async function generateTableTypes(project) {
   const tables = [];
   for (const tableRef of project.tables) {
     try {
-      const tablePath = path20.join(project.path, tableRef.path);
+      const tablePath = path23.join(project.path, tableRef.path);
       const tableModule = await import(`${tablePath}?t=${Date.now()}`);
       const tableInstance = tableModule.default || tableModule[tableRef.export];
       if (tableInstance && tableInstance.columns) {
@@ -7634,14 +8181,14 @@ ${outputColumns}
   content += `  };
 }
 `;
-  const tableTypesPath = path20.join(project.path, ".adk", "table-types.d.ts");
+  const tableTypesPath = path23.join(project.path, ".adk", "table-types.d.ts");
   await createFile(tableTypesPath, await formatCode(content));
 }
 
 // src/generators/trigger-types.ts
 init_utils();
 init_fs();
-import path21 from "path";
+import path24 from "path";
 async function generateTriggerTypes(project) {
   const triggerEvents = {};
   for (const trigger of project.triggers) {
@@ -7681,19 +8228,19 @@ ${triggersType}
   };
 }
 `;
-  const triggerTypesPath = path21.join(project.path, ".adk", "trigger-types.d.ts");
+  const triggerTypesPath = path24.join(project.path, ".adk", "trigger-types.d.ts");
   await createFile(triggerTypesPath, await formatCode(content));
 }
 
 // src/generators/state-types.ts
 init_utils();
 init_fs();
-import path22 from "path";
+import path25 from "path";
 async function generateStateTypes(project) {
   let botStateType = "{}";
   let userStateType = "{}";
   try {
-    const configPath = path22.join(project.path, "agent.config.ts");
+    const configPath = path25.join(project.path, "agent.config.ts");
     const configModule = await import(`${configPath}?t=${Date.now()}`);
     const config = configModule.default;
     if (config?.bot?.state) {
@@ -7724,14 +8271,14 @@ declare module "@botpress/runtime/_types/state" {
   export type UserState = ${userStateType};
 }
 `;
-  const stateTypesPath = path22.join(project.path, ".adk", "state-types.d.ts");
+  const stateTypesPath = path25.join(project.path, ".adk", "state-types.d.ts");
   await createFile(stateTypesPath, await formatCode(content));
 }
 
 // src/generators/tag-types.ts
 init_utils();
 init_fs();
-import path23 from "path";
+import path26 from "path";
 import { BUILT_IN_TAGS } from "@botpress/runtime/definition";
 function generateTagTypeString(builtInTags, configTags) {
   const builtInTagStrings = Object.entries(builtInTags).map(([key, tag]) => {
@@ -7770,7 +8317,7 @@ async function generateTagTypes(project) {
   let messageTagsType = "Record<string, string | undefined>";
   let workflowTagsType = "Record<string, string | undefined>";
   try {
-    const configPath = path23.join(project.path, "agent.config.ts");
+    const configPath = path26.join(project.path, "agent.config.ts");
     const configModule = await import(`${configPath}?t=${Date.now()}`);
     const config = configModule.default;
     botTagsType = generateTagTypeString(BUILT_IN_TAGS.bot, config?.bot?.tags);
@@ -7816,18 +8363,18 @@ declare module "@botpress/runtime/_types/tags" {
   export type WorkflowTags = ${workflowTagsType};
 }
 `;
-  const tagTypesPath = path23.join(project.path, ".adk", "tag-types.d.ts");
+  const tagTypesPath = path26.join(project.path, ".adk", "tag-types.d.ts");
   await createFile(tagTypesPath, await formatCode(content));
 }
 
 // src/generators/configuration-types.ts
 init_utils();
 init_fs();
-import path24 from "path";
+import path27 from "path";
 async function generateConfigurationTypes(project) {
   let configurationType = "{}";
   try {
-    const configPath = path24.join(project.path, "agent.config.ts");
+    const configPath = path27.join(project.path, "agent.config.ts");
     const configModule = await import(`${configPath}?t=${Date.now()}`);
     const config = configModule.default;
     if (config?.configuration?.schema) {
@@ -7851,14 +8398,14 @@ declare module "@botpress/runtime/_types/configuration" {
   export type Configuration = ${configurationType};
 }
 `;
-  const configTypesPath = path24.join(project.path, ".adk", "configuration-types.d.ts");
+  const configTypesPath = path27.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 path25 from "path";
+import * as path28 from "path";
 import { BuiltInWorkflows as BuiltInWorkflows3 } from "@botpress/runtime/internal";
 function isBuiltinWorkflow2(name) {
   return !!Object.values(BuiltInWorkflows3).find((x) => x.name === name);
@@ -7870,7 +8417,7 @@ async function generateWorkflowTypes(project) {
       if (isBuiltinWorkflow2(workflowRef.definition.name)) {
         continue;
       }
-      const workflowPath = path25.join(project.path, workflowRef.path);
+      const workflowPath = path28.join(project.path, workflowRef.path);
       const workflowModule = await import(`${workflowPath}?t=${Date.now()}`);
       const workflowInstance = workflowModule[workflowRef.export] || workflowModule.default;
       if (!workflowInstance) {
@@ -7917,14 +8464,14 @@ declare module "@botpress/runtime/_types/workflows" {
 ${typeDefinitions || "    // No workflows defined yet"}
   };
 }`;
-  const workflowTypesPath = path25.join(project.path, ".adk", "workflow-types.d.ts");
+  const workflowTypesPath = path28.join(project.path, ".adk", "workflow-types.d.ts");
   await createFile(workflowTypesPath, await formatCode(content));
 }
 
 // src/generators/conversation-types.ts
 init_utils();
 init_fs();
-import path26 from "path";
+import path29 from "path";
 function hasConversationIdProperty(schema) {
   if (!schema || typeof schema !== "object") {
     return false;
@@ -7947,7 +8494,7 @@ async function generateConversationTypes(project) {
   const conversationTypes = {};
   for (const conversationRef of project.conversations) {
     try {
-      const conversationPath = path26.join(project.path, conversationRef.path);
+      const conversationPath = path29.join(project.path, conversationRef.path);
       const conversationModule = await import(`${conversationPath}?t=${Date.now()}`);
       const conversationInstance = conversationModule[conversationRef.export] || conversationModule.default;
       if (!conversationInstance) {
@@ -8033,14 +8580,14 @@ ${routableEventsDefinitions || "    // No routable events found"}
   };
 }
 `;
-  const conversationTypesPath = path26.join(project.path, ".adk", "conversation-types.d.ts");
+  const conversationTypesPath = path29.join(project.path, ".adk", "conversation-types.d.ts");
   await createFile(conversationTypesPath, await formatCode(content));
 }
 
 // src/generators/event-types.ts
 init_utils();
 init_fs();
-import path27 from "path";
+import path30 from "path";
 async function generateEventTypes(project) {
   const defaultEvents = ["register: {}"];
   const integrationEvents = [];
@@ -8092,7 +8639,7 @@ ${allEvents.map((e) => `    ${e}`).join(`
   export type EventPayload<T extends EventName> = Events[T];
 }
 `;
-  const eventTypesPath = path27.join(project.path, ".adk", "event-types.d.ts");
+  const eventTypesPath = path30.join(project.path, ".adk", "event-types.d.ts");
   await createFile(eventTypesPath, await formatCode(content));
 }
 
@@ -8101,8 +8648,8 @@ init_fs();
 
 // src/utils/link-sdk.ts
 import { existsSync as existsSync3, realpathSync } from "fs";
-import fs12 from "fs/promises";
-import path28 from "path";
+import fs13 from "fs/promises";
+import path31 from "path";
 function findPackage(name, startDir) {
   let current;
   try {
@@ -8110,17 +8657,17 @@ function findPackage(name, startDir) {
   } catch {
     current = startDir;
   }
-  while (current !== path28.dirname(current)) {
-    const pkgPath = path28.join(current, "node_modules", name);
+  while (current !== path31.dirname(current)) {
+    const pkgPath = path31.join(current, "node_modules", name);
     if (existsSync3(pkgPath)) {
       return pkgPath;
     }
-    current = path28.dirname(current);
+    current = path31.dirname(current);
   }
   return null;
 }
 async function linkSdk(agentDir, botDir) {
-  const targetSdkPath = path28.join(botDir, "node_modules", "@botpress", "sdk");
+  const targetSdkPath = path31.join(botDir, "node_modules", "@botpress", "sdk");
   if (existsSync3(targetSdkPath)) {
     return;
   }
@@ -8134,17 +8681,17 @@ async function linkSdk(agentDir, botDir) {
     console.warn(`Warning: Could not find @botpress/sdk from @botpress/runtime location (${runtimePath})`);
     return;
   }
-  const targetBotpressDir = path28.join(botDir, "node_modules", "@botpress");
-  await fs12.mkdir(targetBotpressDir, { recursive: true });
+  const targetBotpressDir = path31.join(botDir, "node_modules", "@botpress");
+  await fs13.mkdir(targetBotpressDir, { recursive: true });
   const symlinkType = process.platform === "win32" ? "junction" : undefined;
-  await fs12.symlink(sdkPath, targetSdkPath, symlinkType);
+  await fs13.symlink(sdkPath, targetSdkPath, symlinkType);
 }
 
 // src/bot-generator/dev-id-manager.ts
-import path29 from "path";
-import fs13 from "fs/promises";
+import path32 from "path";
+import fs14 from "fs/promises";
 import { existsSync as existsSync4 } from "fs";
-import { Client as Client13 } from "@botpress/client";
+import { Client as Client14 } from "@botpress/client";
 class DevIdManager {
   projectPath;
   botProjectPath;
@@ -8153,7 +8700,7 @@ class DevIdManager {
   constructor(projectPath, botProjectPath) {
     this.projectPath = projectPath;
     this.botProjectPath = botProjectPath;
-    this.projectCachePath = path29.join(botProjectPath, ".botpress", "project.cache.json");
+    this.projectCachePath = path32.join(botProjectPath, ".botpress", "project.cache.json");
   }
   async getClient() {
     if (!this.client) {
@@ -8163,7 +8710,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 Client13({
+      this.client = new Client14({
         token: credentials.token,
         apiUrl: credentials.apiUrl,
         workspaceId,
@@ -8180,7 +8727,7 @@ class DevIdManager {
   async readProjectCache() {
     try {
       if (existsSync4(this.projectCachePath)) {
-        const content = await fs13.readFile(this.projectCachePath, "utf-8");
+        const content = await fs14.readFile(this.projectCachePath, "utf-8");
         return JSON.parse(content);
       }
     } catch (error) {
@@ -8190,8 +8737,8 @@ class DevIdManager {
   }
   async saveProjectCache(cache2) {
     try {
-      await fs13.mkdir(path29.dirname(this.projectCachePath), { recursive: true });
-      await fs13.writeFile(this.projectCachePath, JSON.stringify(cache2, null, 2));
+      await fs14.mkdir(path32.dirname(this.projectCachePath), { recursive: true });
+      await fs14.writeFile(this.projectCachePath, JSON.stringify(cache2, null, 2));
     } catch (error) {
       console.error("Error saving project.cache.json:", error);
     }
@@ -8239,8 +8786,8 @@ class DevIdManager {
 }
 
 // src/bot-generator/integration-sync.ts
-import path30 from "path";
-import fs14 from "fs/promises";
+import path33 from "path";
+import fs15 from "fs/promises";
 import { existsSync as existsSync5 } from "fs";
 class IntegrationSync {
   projectPath;
@@ -8249,7 +8796,7 @@ class IntegrationSync {
   constructor(projectPath, botProjectPath) {
     this.projectPath = projectPath;
     this.botProjectPath = botProjectPath;
-    this.bpModulesPath = path30.join(botProjectPath, "bp_modules");
+    this.bpModulesPath = path33.join(botProjectPath, "bp_modules");
   }
   async parseIntegrations() {
     const project = await AgentProject.load(this.projectPath);
@@ -8280,16 +8827,16 @@ class IntegrationSync {
     return integrations;
   }
   async isIntegrationSynced(integration) {
-    const targetFolder = path30.join(this.bpModulesPath, `integration_${integration.alias}`);
+    const targetFolder = path33.join(this.bpModulesPath, `integration_${integration.alias}`);
     if (!existsSync5(targetFolder)) {
       return false;
     }
     try {
-      const indexPath = path30.join(targetFolder, "index.ts");
+      const indexPath = path33.join(targetFolder, "index.ts");
       if (!existsSync5(indexPath)) {
         return false;
       }
-      const indexContent = await fs14.readFile(indexPath, "utf-8");
+      const indexContent = await fs15.readFile(indexPath, "utf-8");
       const versionMatch = indexContent.match(/version:\s*["']([^"']+)["']/);
       if (!versionMatch) {
         return false;
@@ -8317,20 +8864,20 @@ class IntegrationSync {
     await command.output();
   }
   async renameIntegrationFolder(integration) {
-    const sourceFolder = path30.join(this.bpModulesPath, integration.name.replace("/", "-"));
-    const targetFolder = path30.join(this.bpModulesPath, `integration_${integration.alias}`);
+    const sourceFolder = path33.join(this.bpModulesPath, integration.name.replace("/", "-"));
+    const targetFolder = path33.join(this.bpModulesPath, `integration_${integration.alias}`);
     if (!existsSync5(sourceFolder)) {
       throw new Error(`Integration folder not found: ${sourceFolder}`);
     }
     if (existsSync5(targetFolder)) {
-      await fs14.rm(targetFolder, { recursive: true, force: true });
+      await fs15.rm(targetFolder, { recursive: true, force: true });
     }
-    await fs14.rename(sourceFolder, targetFolder);
+    await fs15.rename(sourceFolder, targetFolder);
   }
   async removeIntegrationFolder(alias) {
-    const targetFolder = path30.join(this.bpModulesPath, `integration_${alias}`);
+    const targetFolder = path33.join(this.bpModulesPath, `integration_${alias}`);
     if (existsSync5(targetFolder)) {
-      await fs14.rm(targetFolder, { recursive: true, force: true });
+      await fs15.rm(targetFolder, { recursive: true, force: true });
     }
   }
   async syncIntegrations() {
@@ -8340,7 +8887,7 @@ class IntegrationSync {
     if (integrations.length === 0) {
       return { synced, errors };
     }
-    await fs14.mkdir(this.bpModulesPath, { recursive: true });
+    await fs15.mkdir(this.bpModulesPath, { recursive: true });
     for (const integration of integrations) {
       try {
         const isAlreadySynced = await this.isIntegrationSynced(integration);
@@ -8362,8 +8909,8 @@ class IntegrationSync {
 }
 
 // src/bot-generator/interface-sync.ts
-import path31 from "path";
-import fs15 from "fs/promises";
+import path34 from "path";
+import fs16 from "fs/promises";
 import { existsSync as existsSync6 } from "fs";
 init_constants();
 class InterfaceSync {
@@ -8373,7 +8920,7 @@ class InterfaceSync {
   constructor(projectPath, botProjectPath) {
     this.projectPath = projectPath;
     this.botProjectPath = botProjectPath;
-    this.bpModulesPath = path31.join(botProjectPath, "bp_modules");
+    this.bpModulesPath = path34.join(botProjectPath, "bp_modules");
   }
   async parseInterfaces() {
     const interfaces = [];
@@ -8391,16 +8938,16 @@ class InterfaceSync {
     return interfaces;
   }
   async isInterfaceSynced(interfaceInfo) {
-    const targetFolder = path31.join(this.bpModulesPath, `interface_${pascalCase(interfaceInfo.alias)}`);
+    const targetFolder = path34.join(this.bpModulesPath, `interface_${pascalCase(interfaceInfo.alias)}`);
     if (!existsSync6(targetFolder)) {
       return false;
     }
     try {
-      const indexPath = path31.join(targetFolder, "index.ts");
+      const indexPath = path34.join(targetFolder, "index.ts");
       if (!existsSync6(indexPath)) {
         return false;
       }
-      const indexContent = await fs15.readFile(indexPath, "utf-8");
+      const indexContent = await fs16.readFile(indexPath, "utf-8");
       const versionMatch = indexContent.match(/version:\s*["']([^"']+)["']/);
       if (!versionMatch) {
         return false;
@@ -8442,20 +8989,20 @@ class InterfaceSync {
     });
   }
   async renameInterfaceFolder(interfaceInfo) {
-    const sourceFolder = path31.join(this.bpModulesPath, interfaceInfo.name);
-    const targetFolder = path31.join(this.bpModulesPath, `interface_${pascalCase(interfaceInfo.alias)}`);
+    const sourceFolder = path34.join(this.bpModulesPath, interfaceInfo.name);
+    const targetFolder = path34.join(this.bpModulesPath, `interface_${pascalCase(interfaceInfo.alias)}`);
     if (!existsSync6(sourceFolder)) {
       throw new Error(`Interface folder not found: ${sourceFolder}`);
     }
     if (existsSync6(targetFolder)) {
-      await fs15.rm(targetFolder, { recursive: true, force: true });
+      await fs16.rm(targetFolder, { recursive: true, force: true });
     }
-    await fs15.rename(sourceFolder, targetFolder);
+    await fs16.rename(sourceFolder, targetFolder);
   }
   async removeInterfaceFolder(alias) {
-    const targetFolder = path31.join(this.bpModulesPath, `interface_${pascalCase(alias)}`);
+    const targetFolder = path34.join(this.bpModulesPath, `interface_${pascalCase(alias)}`);
     if (existsSync6(targetFolder)) {
-      await fs15.rm(targetFolder, { recursive: true, force: true });
+      await fs16.rm(targetFolder, { recursive: true, force: true });
     }
   }
   async syncInterfaces() {
@@ -8465,7 +9012,7 @@ class InterfaceSync {
     if (interfaces.length === 0) {
       return { synced, errors };
     }
-    await fs15.mkdir(this.bpModulesPath, { recursive: true });
+    await fs16.mkdir(this.bpModulesPath, { recursive: true });
     for (const interfaceInfo of interfaces) {
       try {
         const isAlreadySynced = await this.isInterfaceSynced(interfaceInfo);
@@ -8486,9 +9033,124 @@ class InterfaceSync {
   }
 }
 
+// src/bot-generator/plugin-sync.ts
+import path35 from "path";
+import fs17 from "fs/promises";
+import { existsSync as existsSync7 } from "fs";
+class PluginSync {
+  projectPath;
+  botProjectPath;
+  bpModulesPath;
+  constructor(projectPath, botProjectPath) {
+    this.projectPath = projectPath;
+    this.botProjectPath = botProjectPath;
+    this.bpModulesPath = path35.join(botProjectPath, "bp_modules");
+  }
+  async parsePlugins() {
+    const project = await AgentProject.load(this.projectPath);
+    const dependencies = project.dependencies;
+    if (!dependencies?.plugins) {
+      return [];
+    }
+    const plugins = [];
+    for (const [alias, config] of Object.entries(dependencies.plugins)) {
+      const version = config.version;
+      const parts = version.split("@");
+      const name = parts[0] || "";
+      plugins.push({
+        alias,
+        name,
+        version: parts[1] || "latest",
+        fullVersion: version
+      });
+    }
+    return plugins;
+  }
+  async isPluginSynced(plugin) {
+    const targetFolder = path35.join(this.bpModulesPath, `plugin_${plugin.alias}`);
+    if (!existsSync7(targetFolder)) {
+      return false;
+    }
+    try {
+      const indexPath = path35.join(targetFolder, "index.ts");
+      if (!existsSync7(indexPath)) {
+        return false;
+      }
+      const indexContent = await fs17.readFile(indexPath, "utf-8");
+      const versionMatch = indexContent.match(/version:\s*["']([^"']+)["']/);
+      if (!versionMatch) {
+        return false;
+      }
+      const installedVersion = versionMatch[1];
+      return installedVersion === plugin.version;
+    } catch {
+      return false;
+    }
+  }
+  async installPlugin(plugin) {
+    const credentials = await auth.getActiveCredentials();
+    const project = await AgentProject.load(this.projectPath);
+    const workspaceId = project.agentInfo?.workspaceId || credentials.workspaceId;
+    if (!workspaceId) {
+      throw new Error('No workspace ID found. Please login with "adk login"');
+    }
+    const command = new BpAddCommand({
+      resource: `plugin:${plugin.fullVersion}`,
+      botPath: this.botProjectPath,
+      workspaceId,
+      credentials
+    });
+    await command.run();
+    await command.output();
+  }
+  async renamePluginFolder(plugin) {
+    const sourceFolder = path35.join(this.bpModulesPath, plugin.name.replace("/", "-"));
+    const targetFolder = path35.join(this.bpModulesPath, `plugin_${plugin.alias}`);
+    if (!existsSync7(sourceFolder)) {
+      throw new Error(`Plugin folder not found: ${sourceFolder}`);
+    }
+    if (existsSync7(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)) {
+      await fs17.rm(targetFolder, { recursive: true, force: true });
+    }
+  }
+  async syncPlugins() {
+    const plugins = await this.parsePlugins();
+    const synced = [];
+    const errors = [];
+    if (plugins.length === 0) {
+      return { synced, errors };
+    }
+    await fs17.mkdir(this.bpModulesPath, { recursive: true });
+    for (const plugin of plugins) {
+      try {
+        const isAlreadySynced = await this.isPluginSynced(plugin);
+        if (isAlreadySynced) {
+          synced.push(plugin);
+          continue;
+        }
+        await this.removePluginFolder(plugin.alias);
+        await this.installPlugin(plugin);
+        await this.renamePluginFolder(plugin);
+        synced.push(plugin);
+      } catch (error) {
+        const errorMsg = error instanceof Error ? error.message : String(error);
+        errors.push({ alias: plugin.alias, error: errorMsg });
+      }
+    }
+    return { synced, errors };
+  }
+}
+
 // src/bot-generator/generator.ts
 init_utils();
-import { transforms as transforms3 } from "@botpress/sdk";
+import { transforms as transforms4 } 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";
@@ -8500,7 +9162,7 @@ function isBuiltinAction(name) {
   return !!Object.values(BuiltInActions2).find((x) => x.name === name);
 }
 function getImportPath(from, to) {
-  return path34.relative(path34.dirname(from), to).replace(/\.ts$/, "").replace(/\\/g, "/");
+  return path38.relative(path38.dirname(from), to).replace(/\.ts$/, "").replace(/\\/g, "/");
 }
 
 class BotGenerator {
@@ -8509,21 +9171,21 @@ class BotGenerator {
   adkCommand;
   callbacks;
   constructor(options) {
-    this.projectPath = path34.resolve(options.projectPath);
-    this.outputPath = path34.resolve(options.outputPath || path34.join(this.projectPath, ".adk"));
+    this.projectPath = path38.resolve(options.projectPath);
+    this.outputPath = path38.resolve(options.outputPath || path38.join(this.projectPath, ".adk"));
     this.adkCommand = options.adkCommand;
     this.callbacks = options.callbacks;
   }
   async listFilesRecursive(rootDir) {
     try {
-      if (!existsSync7(rootDir))
+      if (!existsSync8(rootDir))
         return [];
       const result = [];
       const walk = async (dir, relativeBase) => {
-        const entries = await fs16.readdir(dir, { withFileTypes: true });
+        const entries = await fs18.readdir(dir, { withFileTypes: true });
         for (const entry of entries) {
-          const abs = path34.join(dir, entry.name);
-          const rel = path34.join(relativeBase, entry.name);
+          const abs = path38.join(dir, entry.name);
+          const rel = path38.join(relativeBase, entry.name);
           if (entry.isDirectory()) {
             await walk(abs, rel);
           } else {
@@ -8538,20 +9200,20 @@ class BotGenerator {
     }
   }
   async removeEmptyDirectories(rootDir) {
-    if (!existsSync7(rootDir))
+    if (!existsSync8(rootDir))
       return;
     const removeIfEmpty = async (dir) => {
-      const entries = await fs16.readdir(dir, { withFileTypes: true });
+      const entries = await fs18.readdir(dir, { withFileTypes: true });
       for (const entry of entries) {
         if (entry.isDirectory()) {
-          const subdir = path34.join(dir, entry.name);
+          const subdir = path38.join(dir, entry.name);
           await removeIfEmpty(subdir);
         }
       }
-      const after = await fs16.readdir(dir);
+      const after = await fs18.readdir(dir);
       if (after.length === 0 && dir !== rootDir) {
         try {
-          await fs16.rmdir(dir, { recursive: false });
+          await fs18.rmdir(dir, { recursive: false });
         } catch {}
       }
     };
@@ -8559,11 +9221,13 @@ class BotGenerator {
   }
   async generate() {
     const project = await AgentProject.load(this.projectPath);
-    await fs16.mkdir(this.outputPath, { recursive: true });
+    await fs18.mkdir(this.outputPath, { recursive: true });
     await this.generateBotDefinition();
     await this.generateIntegrationsDefinition();
+    await this.generatePluginsDefinition();
     await this.generateInterfacesDefinition();
     await this.generateIntegrationsTypes();
+    await this.generatePluginsTypes();
     await this.generateInterfacesTypes();
     await this.generateTableTypes();
     await this.generateTriggerTypes();
@@ -8575,6 +9239,7 @@ class BotGenerator {
     await this.generateActionTypes();
     await this.generateEventTypes();
     await this.generateIntegrationActionTypes();
+    await this.generatePluginActionTypes();
     await this.generateRuntimeTypes();
     await this.generateClientWrapper();
     await this.generateBotIndex();
@@ -8589,19 +9254,19 @@ class BotGenerator {
       workspaceId: project.agentInfo?.workspaceId
     });
     const integrations = await manager3.loadIntegrations(project.dependencies || {});
-    const integrationsDir = path34.join(this.projectPath, ".adk", "integrations");
+    const integrationsDir = path38.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.definition) {
         const types6 = await generateIntegrationTypes(integration);
-        const importPath = `./${path34.join("integrations", types6.names.paths.index).replace(/\\/g, "/")}`;
+        const importPath = `./${path38.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 = path34.join(this.projectPath, ".adk", "integrations", filePath);
-          const dir = path34.dirname(fullPath);
-          await fs16.mkdir(dir, { recursive: true });
+          const fullPath = path38.join(this.projectPath, ".adk", "integrations", filePath);
+          const dir = path38.dirname(fullPath);
+          await fs18.mkdir(dir, { recursive: true });
           await createFile(fullPath, content);
           files.add(filePath);
         }
@@ -8621,18 +9286,68 @@ class BotGenerator {
         };
       }
       `;
-    await createFile(path34.join(this.projectPath, ".adk", "integrations-types.d.ts"), await formatCode(types5));
+    await createFile(path38.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 = path34.join(integrationsDir, rel);
+        const abs = path38.join(integrationsDir, rel);
         try {
-          await fs16.rm(abs, { force: true });
+          await fs18.rm(abs, { force: true });
         } catch {}
       }
     }
     await this.removeEmptyDirectories(integrationsDir);
   }
+  async generatePluginsTypes() {
+    const project = await AgentProject.load(this.projectPath);
+    const manager3 = new PluginManager({
+      workspaceId: project.agentInfo?.workspaceId
+    });
+    const result = await manager3.loadPlugins(project.dependencies || {});
+    const pluginsDir = path38.join(this.projectPath, ".adk", "plugins");
+    const existingPluginFiles = await this.listFilesRecursive(pluginsDir);
+    let aliases = new Set;
+    let files = new Set;
+    for (const plugin of result.plugins) {
+      if (plugin.definition) {
+        const types6 = await generatePluginTypes(plugin);
+        const importPath = `./${path38.join("plugins", types6.names.paths.index).replace(/\\/g, "/")}`;
+        aliases.add(`"${plugin.alias}": import("${importPath}").${types6.names.typings.index}`);
+        for (const [filePath, content] of Object.entries(types6.files)) {
+          const fullPath = path38.join(this.projectPath, ".adk", "plugins", filePath);
+          const dir = path38.dirname(fullPath);
+          await fs18.mkdir(dir, { recursive: true });
+          await createFile(fullPath, content);
+          files.add(filePath);
+        }
+      }
+    }
+    const types5 = `
+      ////////////////////////////////////////////////////////
+      // 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/plugins" {
+        export type Plugins = {
+          ${Array.from(aliases).join(`, `)}
+        };
+      }
+      `;
+    await createFile(path38.join(this.projectPath, ".adk", "plugins-types.d.ts"), await formatCode(types5));
+    const stalePluginFiles = existingPluginFiles.filter((f) => !files.has(f));
+    if (stalePluginFiles.length > 0) {
+      for (const rel of stalePluginFiles) {
+        const abs = path38.join(pluginsDir, rel);
+        try {
+          await fs18.rm(abs, { force: true });
+        } catch {}
+      }
+    }
+    await this.removeEmptyDirectories(pluginsDir);
+  }
   async generateTableTypes() {
     const project = await AgentProject.load(this.projectPath);
     await generateTableTypes(project);
@@ -8675,6 +9390,10 @@ class BotGenerator {
     const { generateIntegrationActionTypes: generateIntegrationActionTypes2 } = await Promise.resolve().then(() => (init_integration_action_types(), exports_integration_action_types));
     await generateIntegrationActionTypes2(project);
   }
+  async generatePluginActionTypes() {
+    const project = await AgentProject.load(this.projectPath);
+    await generatePluginActionTypes(project);
+  }
   async generateClientWrapper() {
     const project = await AgentProject.load(this.projectPath);
     await generateClientWrapper(project);
@@ -8698,7 +9417,7 @@ class BotGenerator {
     let botStateType = "{}";
     let userStateType = "{}";
     try {
-      const configPath = path34.join(project.path, "agent.config.ts");
+      const configPath = path38.join(project.path, "agent.config.ts");
       const configModule = await import(`${configPath}?t=${Date.now()}`);
       const config = configModule.default;
       if (config?.bot?.state) {
@@ -8734,7 +9453,7 @@ declare module "@botpress/runtime/_types/state" {
   export type UserState = ${userStateType};
 }
 `;
-    await createFile(path34.join(this.projectPath, ".adk", "runtime.d.ts"), await formatCode(types5));
+    await createFile(path38.join(this.projectPath, ".adk", "runtime.d.ts"), await formatCode(types5));
   }
   async generateInterfacesTypes() {
     const project = await AgentProject.load(this.projectPath);
@@ -8742,7 +9461,7 @@ declare module "@botpress/runtime/_types/state" {
       workspaceId: project.agentInfo?.workspaceId
     });
     const manager3 = new InterfaceManager;
-    const interfacesDir = path34.join(this.projectPath, ".adk", "interfaces");
+    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 })));
@@ -8751,12 +9470,12 @@ declare module "@botpress/runtime/_types/state" {
     let files = new Set;
     for (const int of interfaces) {
       const types6 = await generateInterfaceTypes(int, integrationsWithAlias);
-      imports.add(`import { ${types6.names.typings.index} } from "./${path34.join("interfaces", types6.names.paths.index).replace(/\\/g, "/")}";`);
+      imports.add(`import { ${types6.names.typings.index} } from "./${path38.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 = path34.join(this.projectPath, ".adk", "interfaces", filePath);
-        const dir = path34.dirname(fullPath);
-        await fs16.mkdir(dir, { recursive: true });
+        const fullPath = path38.join(this.projectPath, ".adk", "interfaces", filePath);
+        const dir = path38.dirname(fullPath);
+        await fs18.mkdir(dir, { recursive: true });
         await createFile(fullPath, content);
         files.add(filePath);
       }
@@ -8792,14 +9511,14 @@ declare module "@botpress/runtime/_types/state" {
 `)}
       };
       `;
-    await createFile(path34.join(this.projectPath, ".adk", "interfaces.d.ts"), await formatCode(types5));
-    await createFile(path34.join(this.projectPath, ".adk", "interfaces.ts"), await formatCode(consts));
+    await createFile(path38.join(this.projectPath, ".adk", "interfaces.d.ts"), await formatCode(types5));
+    await createFile(path38.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 = path34.join(interfacesDir, rel);
+        const abs = path38.join(interfacesDir, rel);
         try {
-          await fs16.rm(abs, { force: true });
+          await fs18.rm(abs, { force: true });
         } catch {}
       }
     }
@@ -8830,7 +9549,31 @@ declare module "@botpress/runtime/_types/state" {
 `) : ""}
       } as Record<string, IntegrationPackage>;
     `;
-    await createFile(path34.join(this.outputPath, "src", "integrations.ts"), content);
+    await createFile(path38.join(this.outputPath, "src", "integrations.ts"), content);
+  }
+  async generatePluginsDefinition() {
+    const project = await AgentProject.load(this.projectPath);
+    const plugins = project.dependencies?.plugins || {};
+    const imports = [];
+    const pluginDefs = [];
+    for (const [alias] of Object.entries(plugins)) {
+      const normalizedAlias = getPluginAlias(alias);
+      imports.push(`import plugin_${normalizedAlias} from "../bp_modules/plugin_${alias}";`);
+      pluginDefs.push(`"${alias}": plugin_${normalizedAlias}`);
+    }
+    const content = dedent`
+      import { PluginPackage } from "@botpress/sdk";
+
+      ${imports.length > 0 ? `
+` + imports.join(`
+`) : ""}
+
+      export const PluginDefinitions = {
+       ${pluginDefs.length > 0 ? pluginDefs.join(`,
+`) : ""}
+      } as Record<string, PluginPackage>;
+    `;
+    await createFile(path38.join(this.outputPath, "src", "plugins.ts"), content);
   }
   async generateInterfacesDefinition() {
     const interfaces = BUILTIN_INTERFACES;
@@ -8853,7 +9596,7 @@ declare module "@botpress/runtime/_types/state" {
 `) : ""}
       } as Record<string, InterfacePackage>;
     `;
-    await createFile(path34.join(this.outputPath, "src", "interfaces.ts"), await formatCode(content));
+    await createFile(path38.join(this.outputPath, "src", "interfaces.ts"), await formatCode(content));
   }
   reportServerConfigSync(serverConfigResult, integrations) {
     if (!this.callbacks) {
@@ -8907,6 +9650,23 @@ declare module "@botpress/runtime/_types/state" {
       const configData = Object.keys(mergedConfig).length > 0 ? `, configuration: ${JSON.stringify(mergedConfig)}` : "";
       addIntegrations.push(`bot.addIntegration(${importName}, { alias: "${alias}", enabled: true${configType}${configData} });`);
     }
+    const depRefErrors = PluginParser.validateDependencyReferences(project.dependencies || {});
+    if (depRefErrors.length > 0) {
+      const messages = depRefErrors.map((e) => e.message).join(`
+  `);
+      throw new Error(`Plugin dependency validation failed:
+  ${messages}`);
+    }
+    const plugins = project.dependencies?.plugins || {};
+    const addPlugins = [];
+    for (const [alias, pluginConfig] of Object.entries(plugins)) {
+      const normalizedAlias = getPluginAlias(alias);
+      const importName = `plugin_${normalizedAlias}`;
+      imports.push(`import ${importName} from "./bp_modules/plugin_${alias}";`);
+      const configData = pluginConfig.config && Object.keys(pluginConfig.config).length > 0 ? `, configuration: ${JSON.stringify(pluginConfig.config)}` : "";
+      const depsData = pluginConfig.dependencies && Object.keys(pluginConfig.dependencies).length > 0 ? `, dependencies: ${JSON.stringify(pluginConfig.dependencies)}` : "";
+      addPlugins.push(`bot.addPlugin(${importName}, { alias: "${alias}"${configData}${depsData} });`);
+    }
     const botTags = {};
     const userTags = {};
     const conversationTags = {};
@@ -8927,9 +9687,9 @@ declare module "@botpress/runtime/_types/state" {
     if (project.config?.workflow?.tags) {
       Object.assign(workflowTags, project.config.workflow.tags);
     }
-    const crypto5 = __require("crypto");
+    const crypto6 = __require("crypto");
     const hashString = (str) => {
-      return crypto5.createHash("md5").update(str).digest("hex").substring(0, 5).toUpperCase();
+      return crypto6.createHash("md5").update(str).digest("hex").substring(0, 5).toUpperCase();
     };
     for (const trigger of project.triggers) {
       const triggerName = trigger.definition.name;
@@ -8947,7 +9707,7 @@ declare module "@botpress/runtime/_types/state" {
         if (isBuiltinWorkflow3(workflow.definition.name)) {
           continue;
         }
-        const workflowPath = path34.join(project.path, workflow.path);
+        const workflowPath = path38.join(project.path, workflow.path);
         const workflowModule = await import(`${workflowPath}?t=${Date.now()}`);
         const workflowInstance = workflowModule.default || workflowModule[workflow.export];
         if (workflowInstance) {
@@ -8971,8 +9731,8 @@ declare module "@botpress/runtime/_types/state" {
           schedule: definition.schedule
         });
       }
-      const inputSchema = definition.input ? transforms3.fromJSONSchema(definition.input).naked().toTypescriptSchema() : "z.object({})";
-      const outputSchema = definition.output ? transforms3.fromJSONSchema(definition.output).naked().toTypescriptSchema() : "z.object({})";
+      const inputSchema = definition.input ? transforms4.fromJSONSchema(definition.input).naked().toTypescriptSchema() : "z.object({})";
+      const outputSchema = definition.output ? transforms4.fromJSONSchema(definition.output).naked().toTypescriptSchema() : "z.object({})";
       const parts = [];
       if (definition.description) {
         parts.push(`title: ${JSON.stringify(definition.name)}`);
@@ -9012,7 +9772,7 @@ declare module "@botpress/runtime/_types/state" {
       const schema = eventDef.schema;
       let schemaCode = "z.object({})";
       if (schema && typeof schema.toJSONSchema === "function") {
-        schemaCode = transforms3.fromJSONSchema(schema.toJSONSchema()).toTypescriptSchema();
+        schemaCode = transforms4.fromJSONSchema(schema.toJSONSchema()).toTypescriptSchema();
       }
       const parts = [`schema: ${schemaCode}`];
       if (eventDef.description) {
@@ -9024,7 +9784,7 @@ declare module "@botpress/runtime/_types/state" {
           }`);
     }
     const configSchema = project.config?.configuration?.schema;
-    const configSchemaCode = configSchema ? transforms3.fromJSONSchema(configSchema.toJSONSchema()).toTypescriptSchema() : undefined;
+    const configSchemaCode = configSchema ? transforms4.fromJSONSchema(configSchema.toJSONSchema()).toTypescriptSchema() : undefined;
     const content = dedent`
       import { BotDefinition, z } from "@botpress/sdk";
       import {
@@ -9096,8 +9856,8 @@ configuration: {
         parts.push(`description: ${JSON.stringify(def.description)}`);
       if (def.attributes)
         parts.push(`attributes: ${JSON.stringify(def.attributes)}`);
-      parts.push(`input: { schema: ${transforms3.fromJSONSchema(def.input).toTypescriptSchema()} }`);
-      parts.push(`output: { schema: ${transforms3.fromJSONSchema(def.output).toTypescriptSchema()} }`);
+      parts.push(`input: { schema: ${transforms4.fromJSONSchema(def.input).toTypescriptSchema()} }`);
+      parts.push(`output: { schema: ${transforms4.fromJSONSchema(def.output).toTypescriptSchema()} }`);
       return `"${name}": {
             ${parts.join(`,
             `)}
@@ -9199,10 +9959,13 @@ configuration: {
     const integrationsSection = addIntegrations.length > 0 ? `
 ` + addIntegrations.join(`
 `) : "";
-    const fullContent = content + integrationsSection + `
+    const pluginsSection = addPlugins.length > 0 ? `
+` + addPlugins.join(`
+`) : "";
+    const fullContent = content + integrationsSection + pluginsSection + `
 
 export default bot;`;
-    await createFile(path34.join(this.outputPath, "bot.definition.ts"), await formatCode(fullContent));
+    await createFile(path38.join(this.outputPath, "bot.definition.ts"), await formatCode(fullContent));
   }
   async generateBotIndex() {
     const content = dedent`
@@ -9241,7 +10004,7 @@ export default bot;`;
 
       export default bot
     `;
-    await createFile(path34.join(this.outputPath, "src", "index.ts"), await formatCode(content));
+    await createFile(path38.join(this.outputPath, "src", "index.ts"), await formatCode(content));
   }
   async generatePackageJson(project) {
     const packageJson = {
@@ -9255,7 +10018,7 @@ export default bot;`;
         typescript: "^5.9.3"
       }
     };
-    await createFile(path34.join(this.outputPath, "package.json"), JSON.stringify(packageJson, null, 2));
+    await createFile(path38.join(this.outputPath, "package.json"), JSON.stringify(packageJson, null, 2));
   }
   async generateTsConfig() {
     const tsConfig = {
@@ -9286,7 +10049,7 @@ export default bot;`;
       },
       include: [".botpress/**/*", "src/**/*", "bp_modules/**/*", "./*.ts", "./*.json", "../*.d.ts"]
     };
-    await createFile(path34.join(this.outputPath, "tsconfig.json"), JSON.stringify(tsConfig, null, 2));
+    await createFile(path38.join(this.outputPath, "tsconfig.json"), JSON.stringify(tsConfig, null, 2));
   }
   async generateGlobalTypes() {
     const content = dedent`
@@ -9309,42 +10072,42 @@ export default bot;`;
 
       export {};
     `;
-    await createFile(path34.join(this.outputPath, "global.d.ts"), await formatCode(content));
+    await createFile(path38.join(this.outputPath, "global.d.ts"), await formatCode(content));
   }
   async copyAssets() {
-    const assetsPath = path34.join(this.projectPath, "assets");
-    const targetPath = path34.join(this.outputPath, "assets");
-    if (existsSync7(assetsPath)) {
-      await fs16.mkdir(targetPath, { recursive: true });
+    const assetsPath = path38.join(this.projectPath, "assets");
+    const targetPath = path38.join(this.outputPath, "assets");
+    if (existsSync8(assetsPath)) {
+      await fs18.mkdir(targetPath, { recursive: true });
       await this.copyDirectory(assetsPath, targetPath);
     }
   }
   async copyDirectory(src, dest) {
-    const entries = await fs16.readdir(src, { withFileTypes: true });
+    const entries = await fs18.readdir(src, { withFileTypes: true });
     for (const entry of entries) {
-      const srcPath = path34.join(src, entry.name);
-      const destPath = path34.join(dest, entry.name);
+      const srcPath = path38.join(src, entry.name);
+      const destPath = path38.join(dest, entry.name);
       if (entry.isDirectory()) {
-        await fs16.mkdir(destPath, { recursive: true });
+        await fs18.mkdir(destPath, { recursive: true });
         await this.copyDirectory(srcPath, destPath);
       } else {
-        await fs16.copyFile(srcPath, destPath);
+        await fs18.copyFile(srcPath, destPath);
       }
     }
   }
   async generateAdkRuntime() {
     const project = new AgentProject(this.projectPath);
     await project.reload();
-    const srcDir = path34.join(this.outputPath, "src");
+    const srcDir = path38.join(this.outputPath, "src");
     {
-      const dest = path34.join(srcDir, "conversations.ts");
+      const dest = path38.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, path34.join(project.path, conversation.path));
+          const importPath = getImportPath(dest, path38.join(project.path, conversation.path));
           imports.set(conversation.path, {
             name,
             statement: `import * as ${name} from "${importPath}";`
@@ -9370,14 +10133,14 @@ export default bot;`;
       await createFile(dest, await formatCode(content2));
     }
     {
-      const dest = path34.join(srcDir, "knowledge.ts");
+      const dest = path38.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, path34.join(project.path, knowledge.path));
+          const importPath = getImportPath(dest, path38.join(project.path, knowledge.path));
           imports.set(knowledge.path, {
             name,
             statement: `import * as ${name} from "${importPath}";`
@@ -9403,8 +10166,8 @@ export default bot;`;
       await createFile(dest, await formatCode(content2));
     }
     {
-      const dest = path34.join(srcDir, "triggers.ts");
-      const { transforms: transforms4 } = await import("@botpress/sdk");
+      const dest = path38.join(srcDir, "triggers.ts");
+      const { transforms: transforms5 } = await import("@botpress/sdk");
       const imports = new Map;
       const exports = new Set;
       const payloadTypes = {};
@@ -9412,7 +10175,7 @@ export default bot;`;
       for (const trigger of project.triggers) {
         if (!imports.has(trigger.path)) {
           const name = `triggers_${index++}`;
-          const importPath = getImportPath(dest, path34.join(project.path, trigger.path));
+          const importPath = getImportPath(dest, path38.join(project.path, trigger.path));
           imports.set(trigger.path, {
             name,
             statement: `import * as ${name} from "${importPath}";`
@@ -9422,12 +10185,12 @@ export default bot;`;
       }
       for (const trigger of project.triggers) {
         try {
-          const absolutePath = path34.join(project.path, trigger.path);
+          const absolutePath = path38.join(project.path, trigger.path);
           const triggerModule = await import(`${absolutePath}?t=${Date.now()}`);
           const triggerInstance = triggerModule[trigger.export] || triggerModule.default;
           if (triggerInstance && triggerInstance.payload) {
-            const jsonSchema = transforms4.toJSONSchema(triggerInstance.payload);
-            const payloadType = transforms4.fromJSONSchema(jsonSchema).toTypescriptType();
+            const jsonSchema = transforms5.toJSONSchema(triggerInstance.payload);
+            const payloadType = transforms5.fromJSONSchema(jsonSchema).toTypescriptType();
             payloadTypes[trigger.definition.name] = payloadType;
           } else {
             payloadTypes[trigger.definition.name] = "{}";
@@ -9465,7 +10228,7 @@ export default bot;`;
       await createFile(dest, await formatCode(content2));
     }
     {
-      const dest = path34.join(srcDir, "workflows.ts");
+      const dest = path38.join(srcDir, "workflows.ts");
       const imports = new Map;
       const exports = new Set;
       let index = 1;
@@ -9475,7 +10238,7 @@ export default bot;`;
         }
         if (!imports.has(workflow.path)) {
           const name = `workflows_${index++}`;
-          const importPath = getImportPath(dest, path34.join(project.path, workflow.path));
+          const importPath = getImportPath(dest, path38.join(project.path, workflow.path));
           const statement = `import * as ${name} from "${importPath}";`;
           imports.set(workflow.path, {
             name,
@@ -9509,7 +10272,7 @@ export default bot;`;
       await createFile(dest, await formatCode(content2));
     }
     {
-      const dest = path34.join(srcDir, "actions.ts");
+      const dest = path38.join(srcDir, "actions.ts");
       const imports = new Map;
       const exports = new Set;
       let index = 1;
@@ -9519,7 +10282,7 @@ export default bot;`;
         }
         if (!imports.has(action.path)) {
           const name = `actions_${index++}`;
-          const importPath = getImportPath(dest, path34.join(project.path, action.path));
+          const importPath = getImportPath(dest, path38.join(project.path, action.path));
           imports.set(action.path, {
             name,
             statement: `import * as ${name} from "${importPath}";`
@@ -9545,14 +10308,14 @@ export default bot;`;
       await createFile(dest, await formatCode(content2));
     }
     {
-      const dest = path34.join(srcDir, "tables.ts");
+      const dest = path38.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, path34.join(project.path, table.path));
+          const importPath = getImportPath(dest, path38.join(project.path, table.path));
           imports.set(table.path, {
             name,
             statement: `import * as ${name} from "${importPath}";`
@@ -9578,8 +10341,8 @@ export default bot;`;
       await createFile(dest, await formatCode(content2));
     }
     {
-      const dest = path34.join(srcDir, "config.ts");
-      const importPath = getImportPath(dest, path34.join(project.path, "agent.config.ts"));
+      const dest = path38.join(srcDir, "config.ts");
+      const importPath = getImportPath(dest, path38.join(project.path, "agent.config.ts"));
       const content2 = `
       ////////////////////////////////////////////////////////
       // DO NOT EDIT THIS FILE DIRECTLY
@@ -9643,15 +10406,16 @@ export default bot;`;
         handlers.trigger.setup(bot);
         handlers.workflow.setup(bot);
         handlers.actions.setup(bot);
+        handlers.plugins.setup(bot);
       }
     `;
-    await createFile(path34.join(this.outputPath, "src", "adk-runtime.ts"), await formatCode(content));
+    await createFile(path38.join(this.outputPath, "src", "adk-runtime.ts"), await formatCode(content));
   }
   async copyAssetsRuntime() {
-    const assetsRuntimePath = path34.join(this.projectPath, ".adk", "assets-runtime.ts");
-    if (existsSync7(assetsRuntimePath)) {
-      const content = await fs16.readFile(assetsRuntimePath, "utf-8");
-      await createFile(path34.join(this.outputPath, "src", "assets-runtime.ts"), await formatCode(content));
+    const assetsRuntimePath = path38.join(this.projectPath, ".adk", "assets-runtime.ts");
+    if (existsSync8(assetsRuntimePath)) {
+      const content = await fs18.readFile(assetsRuntimePath, "utf-8");
+      await createFile(path38.join(this.outputPath, "src", "assets-runtime.ts"), await formatCode(content));
     }
   }
 }
@@ -9660,11 +10424,11 @@ async function generateBotProject(options) {
   await generator.generate();
   await generator.generateAdkRuntime();
   await generator.copyAssetsRuntime();
-  const botPath = options.outputPath || path34.join(options.projectPath, ".adk", "bot");
+  const botPath = options.outputPath || path38.join(options.projectPath, ".adk", "bot");
   await linkSdk(options.projectPath, botPath);
-  const devIdManager = new DevIdManager(options.projectPath, options.outputPath || path34.join(options.projectPath, ".adk", "bot"));
+  const devIdManager = new DevIdManager(options.projectPath, options.outputPath || path38.join(options.projectPath, ".adk", "bot"));
   await devIdManager.restoreDevId();
-  const integrationSync = new IntegrationSync(options.projectPath, options.outputPath || path34.join(options.projectPath, ".adk", "bot"));
+  const integrationSync = new IntegrationSync(options.projectPath, options.outputPath || path38.join(options.projectPath, ".adk", "bot"));
   const integrationSyncResult = await integrationSync.syncIntegrations();
   if (integrationSyncResult.errors.length > 0) {
     console.warn(`⚠️  Some integrations failed to sync:`);
@@ -9672,7 +10436,7 @@ async function generateBotProject(options) {
       console.warn(`  - ${alias}: ${error}`);
     });
   }
-  const interfaceSync = new InterfaceSync(options.projectPath, options.outputPath || path34.join(options.projectPath, ".adk", "bot"));
+  const interfaceSync = new InterfaceSync(options.projectPath, options.outputPath || path38.join(options.projectPath, ".adk", "bot"));
   const interfaceSyncResult = await interfaceSync.syncInterfaces();
   if (interfaceSyncResult.errors.length > 0) {
     console.warn(`⚠️  Some interfaces failed to sync:`);
@@ -9680,10 +10444,18 @@ async function generateBotProject(options) {
       console.warn(`  - ${alias}: ${error}`);
     });
   }
+  const pluginSync = new PluginSync(options.projectPath, options.outputPath || path38.join(options.projectPath, ".adk", "bot"));
+  const pluginSyncResult = await pluginSync.syncPlugins();
+  if (pluginSyncResult.errors.length > 0) {
+    console.warn(`⚠️  Some plugins failed to sync:`);
+    pluginSyncResult.errors.forEach(({ alias, error }) => {
+      console.warn(`  - ${alias}: ${error}`);
+    });
+  }
 }
 // src/tables/table-manager.ts
-import { Client as Client14 } from "@botpress/client";
-import { transforms as transforms4 } from "@botpress/sdk";
+import { Client as Client15 } from "@botpress/client";
+import { transforms as transforms5 } from "@botpress/sdk";
 class TableManager {
   client;
   botId;
@@ -9696,7 +10468,7 @@ class TableManager {
     if (!this.client) {
       const credentials = await auth.getActiveCredentials();
       this.assertBotId("initialize client");
-      this.client = new Client14({
+      this.client = new Client15({
         token: credentials.token,
         apiUrl: credentials.apiUrl,
         botId: this.botId,
@@ -10006,8 +10778,8 @@ class TableManager {
           const factorMatches = (local.factor || 1) === (remote.factor || 1);
           const keyColumnMatches = (local.keyColumn || "") === (remote.keyColumn || "");
           const tagsMatch = JSON.stringify(local.tags || {}) === JSON.stringify(remote.tags || {});
-          const localSchema = transforms4.fromJSONSchema(cleanedLocalSchema);
-          const remoteSchema = transforms4.fromJSONSchema(cleanedRemoteSchema);
+          const localSchema = transforms5.fromJSONSchema(cleanedLocalSchema);
+          const remoteSchema = transforms5.fromJSONSchema(cleanedRemoteSchema);
           const schemasEqual = localSchema.isEqual(remoteSchema);
           const hasMetadataChanges = differences.length > 0;
           if (!schemasEqual || !factorMatches || hasMetadataChanges || !keyColumnMatches || !tagsMatch) {
@@ -10180,11 +10952,11 @@ class TableManager {
   }
 }
 // src/knowledge/manager.ts
-import crypto5 from "crypto";
-import path35 from "path";
-import fs17 from "fs/promises";
+import crypto6 from "crypto";
+import path39 from "path";
+import fs19 from "fs/promises";
 import { glob } from "glob";
-import { Client as Client15 } from "@botpress/client";
+import { Client as Client16 } from "@botpress/client";
 import { DataSource } from "@botpress/runtime";
 
 // src/knowledge/types.ts
@@ -10229,7 +11001,7 @@ class KnowledgeManager {
     if (!this.client) {
       const credentials = await auth.getActiveCredentials();
       this.assertBotId("initialize client");
-      this.client = new Client15({
+      this.client = new Client16({
         token: credentials.token,
         apiUrl: credentials.apiUrl,
         botId: this.botId,
@@ -10271,7 +11043,7 @@ class KnowledgeManager {
     const sortedEntries = Object.entries(fileHashes).sort(([a], [b]) => a.localeCompare(b));
     const combined = sortedEntries.map(([filePath, hash]) => `${filePath}:${hash}`).join(`
 `);
-    return crypto5.createHash("sha256").update(combined).digest("hex");
+    return crypto6.createHash("sha256").update(combined).digest("hex");
   }
   async listRemoteKnowledgeBases() {
     const client = await this.getClient();
@@ -10386,7 +11158,7 @@ class KnowledgeManager {
   }
   computeConfigHash(config) {
     const sortedConfig = JSON.stringify(config, Object.keys(config).sort());
-    return crypto5.createHash("sha256").update(sortedConfig).digest("hex");
+    return crypto6.createHash("sha256").update(sortedConfig).digest("hex");
   }
   async syncWebsiteSource(kbName, kbId, force) {
     const client = await this.getClient();
@@ -10631,16 +11403,16 @@ class KnowledgeManager {
   }
   async scanLocalFileHashes(directoryPath, filterFn) {
     const projectDir = this.project.path;
-    const directory = path35.resolve(projectDir, directoryPath);
+    const directory = path39.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 = path35.relative(directory, file);
-      const content = await fs17.readFile(file);
-      hashes[relPath] = crypto5.createHash("sha256").update(content).digest("hex");
+      const relPath = path39.relative(directory, file);
+      const content = await fs19.readFile(file);
+      hashes[relPath] = crypto6.createHash("sha256").update(content).digest("hex");
     }
     this.fileHashCache.set(directory, hashes);
     return hashes;
@@ -10746,7 +11518,7 @@ class KnowledgeManager {
   }
   async syncDirectorySource(client, kbName, kbId, dsId, directoryPath, filterFn, force) {
     const projectDir = this.project.path;
-    const directory = path35.resolve(projectDir, directoryPath);
+    const directory = path39.resolve(projectDir, directoryPath);
     if (!directory.startsWith(projectDir)) {
       throw new Error("Directory path must be within the agent's directory");
     }
@@ -10768,8 +11540,8 @@ class KnowledgeManager {
       return true;
     }).map((f) => ({
       abs: f,
-      rel: path35.relative(directory, f),
-      name: path35.basename(f)
+      rel: path39.relative(directory, f),
+      name: path39.basename(f)
     }));
     console.log(`  Found ${allFiles.length} files in ${directoryPath}`);
     const cachedHashes = await this.scanLocalFileHashes(directoryPath, filterFn);
@@ -10843,15 +11615,15 @@ class KnowledgeManager {
   }
   async upsertFile(client, local, dsId, tags, force, cachedHash) {
     const key = `data_source://document/${dsId}/${local.rel}`;
-    const content = await fs17.readFile(local.abs);
-    const hash = cachedHash ?? crypto5.createHash("sha256").update(content).digest("hex");
+    const content = await fs19.readFile(local.abs);
+    const hash = cachedHash ?? crypto6.createHash("sha256").update(content).digest("hex");
     try {
       const { file } = await client.getFile({ id: key });
       if (!force && isFileMetadata(file.metadata) && file.metadata.hash === hash) {
         return null;
       }
     } catch {}
-    const title = path35.basename(local.name, path35.extname(local.name));
+    const title = path39.basename(local.name, path39.extname(local.name));
     const metadata = {
       hash,
       dsId,
@@ -10979,7 +11751,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 existsSync8 } from "fs";
+import { existsSync as existsSync9 } from "fs";
 
 class FileWatcher2 extends EventEmitter3 {
   projectPath;
@@ -10997,12 +11769,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 (existsSync8(filePath)) {
+      if (existsSync9(filePath)) {
         this.watchFile(filePath);
       }
     }
     const srcPath = join8(this.projectPath, "src");
-    if (existsSync8(srcPath)) {
+    if (existsSync9(srcPath)) {
       this.initializeDirectoryState(srcPath);
       this.watchDirectory(srcPath);
     }
@@ -11051,7 +11823,7 @@ class FileWatcher2 extends EventEmitter3 {
     }
   }
   handleFileChange(filePath) {
-    const fileExists = existsSync8(filePath);
+    const fileExists = existsSync9(filePath);
     const previousState = this.fileStates.get(filePath);
     let changeType;
     if (!fileExists && previousState !== undefined) {
@@ -11091,7 +11863,7 @@ class FileWatcher2 extends EventEmitter3 {
     this.emit("change", event);
   }
   updateFileState(filePath) {
-    if (existsSync8(filePath)) {
+    if (existsSync9(filePath)) {
       this.fileStates.set(filePath, Date.now());
     }
   }
@@ -11115,8 +11887,8 @@ class FileWatcher2 extends EventEmitter3 {
   }
 }
 // src/preflight/checker.ts
-import { Client as Client16 } from "@botpress/client";
-import path36 from "path";
+import { Client as Client17 } from "@botpress/client";
+import path40 from "path";
 
 // src/preflight/types.ts
 function hasIntegrationChanges(integrations) {
@@ -11330,7 +12102,7 @@ class PreflightChecker {
       if (!workspaceId) {
         throw new Error('No workspace ID found. Please login with "adk login"');
       }
-      this.client = new Client16({
+      this.client = new Client17({
         token: credentials.token,
         apiUrl: credentials.apiUrl,
         workspaceId,
@@ -11478,7 +12250,7 @@ class PreflightChecker {
     options?.onProgress?.("Regenerating bot project...");
     await generateBotProject({
       projectPath: this.projectPath,
-      outputPath: path36.join(this.projectPath, ".adk", "bot"),
+      outputPath: path40.join(this.projectPath, ".adk", "bot"),
       callbacks: options
     });
     options?.onSuccess?.("Bot project regenerated");
@@ -11486,21 +12258,21 @@ class PreflightChecker {
 }
 // src/runner/script-runner.ts
 import dedent2 from "dedent";
-import { existsSync as existsSync9 } from "fs";
-import fs18 from "fs/promises";
-import path37 from "path";
+import { existsSync as existsSync10 } from "fs";
+import fs20 from "fs/promises";
+import path41 from "path";
 import { spawn } from "child_process";
 init_utils();
 init_credentials();
 async function findAgentRoot(startPath) {
-  let currentPath = path37.resolve(startPath);
-  const root = path37.parse(currentPath).root;
+  let currentPath = path41.resolve(startPath);
+  const root = path41.parse(currentPath).root;
   while (currentPath !== root) {
     try {
-      await fs18.access(path37.join(currentPath, "agent.config.ts"));
+      await fs20.access(path41.join(currentPath, "agent.config.ts"));
       return currentPath;
     } catch {
-      currentPath = path37.dirname(currentPath);
+      currentPath = path41.dirname(currentPath);
     }
   }
   return null;
@@ -11512,7 +12284,7 @@ class ScriptRunner {
   prod;
   credentials;
   constructor(options) {
-    this.projectPath = path37.resolve(options.projectPath);
+    this.projectPath = path41.resolve(options.projectPath);
     this.forceRegenerate = options.forceRegenerate ?? false;
     this.prod = options.prod ?? false;
     this.credentials = options.credentials;
@@ -11521,10 +12293,10 @@ class ScriptRunner {
     const project = await AgentProject.load(this.projectPath, {
       adkCommand: "adk-build"
     });
-    const botPath = path37.join(this.projectPath, ".adk", "bot");
-    const runnerPath = path37.join(botPath, "src", "script-runner.ts");
-    const botpressTypesPath = path37.join(botPath, ".botpress", "implementation", "index.ts");
-    const needsRegenerate = this.forceRegenerate || !existsSync9(runnerPath) || !existsSync9(botpressTypesPath);
+    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);
     if (needsRegenerate) {
       try {
         await generateAssetsTypes(project.path);
@@ -11640,7 +12412,7 @@ class ScriptRunner {
 
       runScript()
     `;
-    await fs18.writeFile(path37.join(botPath, "src", "script-runner.ts"), await formatCode(content), "utf-8");
+    await fs20.writeFile(path41.join(botPath, "src", "script-runner.ts"), await formatCode(content), "utf-8");
   }
   async setupTestRuntime(options = {}) {
     const { botPath, project } = await this.prepare();
@@ -11671,7 +12443,7 @@ class ScriptRunner {
     for (const [key, value] of Object.entries(envVars)) {
       process.env[key] = value;
     }
-    const runtimePath = path37.join(botPath, "src", "index.ts");
+    const runtimePath = path41.join(botPath, "src", "index.ts");
     return {
       botPath,
       runtimePath,
@@ -11684,10 +12456,10 @@ class ScriptRunner {
         const runtimeModule = await import("@botpress/runtime/runtime");
         const { Autonomous } = await import("@botpress/runtime");
         const { context, agentRegistry } = runtimeModule;
-        const { Client: Client17 } = await import("@botpress/client");
+        const { Client: Client18 } = await import("@botpress/client");
         const { BotSpecificClient, BotLogger } = await import("@botpress/sdk");
         const { Cognitive } = await import("@botpress/cognitive");
-        const vanillaClient = new Client17({
+        const vanillaClient = new Client18({
           token: this.credentials.token,
           apiUrl: this.credentials.apiUrl,
           botId
@@ -11719,8 +12491,8 @@ class ScriptRunner {
   }
   async run(scriptPath, options = {}) {
     const { botPath, runnerPath, project } = await this.prepare();
-    const absoluteScriptPath = path37.isAbsolute(scriptPath) ? scriptPath : path37.resolve(this.projectPath, scriptPath);
-    if (!existsSync9(absoluteScriptPath)) {
+    const absoluteScriptPath = path41.isAbsolute(scriptPath) ? scriptPath : path41.resolve(this.projectPath, scriptPath);
+    if (!existsSync10(absoluteScriptPath)) {
       throw new Error(`Script not found: ${absoluteScriptPath}`);
     }
     const botId = this.prod ? project.agentInfo?.botId : project.agentInfo?.devId || project.agentInfo?.botId;
@@ -11834,6 +12606,7 @@ export {
   ProjectState,
   PreflightFormatter,
   PreflightChecker,
+  PluginParser,
   KnowledgeManager,
   KBSyncOperation,
   KBSyncFormatter,
@@ -11869,4 +12642,4 @@ export {
   AgentProject
 };
 
-//# debugId=AE3B528B2B7EDC6E64756E2164756E21
+//# debugId=A068F5974643B24F64756E2164756E21