@botpress/adk 1.7.7 → 1.7.8

package/dist/index.js

@@ -180,7 +180,7 @@ var createFile = async (path6, content) => {
 var init_fs = () => {};
 
 // src/generators/utils.ts
-import path13 from "path";
+import path9 from "path";
 import { format } from "prettier";
 function toMultilineComment(comment) {
   if (!comment || comment.trim() === "") {
@@ -217,9 +217,9 @@ var PRETTIER_CONFIG, formatCode = async (code, filepath) => {
 `));
     return code;
   }
-}, ADK_VERSION = "1.7.7", relative2 = (from, to) => {
-  const fromDir = path13.dirname(from);
-  const relative3 = path13.relative(fromDir, to);
+}, ADK_VERSION = "1.7.8", relative2 = (from, to) => {
+  const fromDir = path9.dirname(from);
+  const relative3 = path9.relative(fromDir, to);
   return relative3.startsWith(".") ? relative3 : `./${relative3}`;
 };
 var init_utils = __esm(() => {
@@ -1446,8 +1446,8 @@ function stringifyWithOrder(obj, keyOrder, space = 2) {
 }
 // src/agent-project/agent-project.ts
 import { BuiltInActions, BuiltInWorkflows, Errors as Errors2, Primitives as Primitives2, setAdkCommand } from "@botpress/runtime/internal";
-import fs10 from "fs/promises";
-import path11 from "path";
+import fs9 from "fs/promises";
+import path12 from "path";
 // src/assets/manager.ts
 import fs4 from "fs/promises";
 import path5 from "path";
@@ -2009,7 +2009,7 @@ class EnhancedIntegrationCache {
   }
 }
 
-// src/agent-project/dependencies-json.ts
+// src/agent-project/dependencies-parser.ts
 import { z as z2, ZodIssueCode } from "@botpress/sdk";
 
 // src/agent-project/types.ts
@@ -2153,10 +2153,10 @@ class ValidationErrors {
       $type: ValidationErrors.$type,
       code: "INVALID_DEPENDENCIES_SYNTAX" /* INVALID_DEPENDENCIES_SYNTAX */,
       severity: "error" /* ERROR */,
-      message: `Invalid JSON syntax in dependencies.json: ${error}`,
-      file: "dependencies.json",
+      message: `Invalid syntax in agent.config.ts dependencies: ${error}`,
+      file: "agent.config.ts",
       line,
-      hint: "Ensure dependencies.json contains valid JSON"
+      hint: "Ensure agent.config.ts exports a valid dependencies object"
     };
   }
   static invalidVersionFormat(integration, version) {
@@ -2165,7 +2165,7 @@ class ValidationErrors {
       code: "INVALID_VERSION_FORMAT" /* INVALID_VERSION_FORMAT */,
       severity: "error" /* ERROR */,
       message: `Invalid version format '${version}' for integration '${integration}'`,
-      file: "dependencies.json",
+      file: "agent.config.ts",
       hint: 'Use exact versioning (e.g., "1.2.3", "2.0.0", "1.5.0")',
       context: { integration, version }
     };
@@ -2176,7 +2176,7 @@ class ValidationErrors {
       code: "UNKNOWN_INTEGRATION" /* UNKNOWN_INTEGRATION */,
       severity: "error" /* ERROR */,
       message: detailedMessage || `Unknown integration '${integration}' from source '${source}'`,
-      file: "dependencies.json",
+      file: "agent.config.ts",
       hint: detailedMessage ? undefined : `Check if the integration name is correct or if it exists in ${source}`,
       context: { integration, source }
     };
@@ -2187,8 +2187,8 @@ class ValidationErrors {
       code: "UNKNOWN_INTEGRATION" /* UNKNOWN_INTEGRATION */,
       severity: "error" /* ERROR */,
       message: errorMessage,
-      file: "dependencies.json",
-      hint: `Update the version for "${integration}" in dependencies.json`
+      file: "agent.config.ts",
+      hint: `Update the version for "${integration}" in agent.config.ts dependencies`
     };
   }
   static unknownInterface(errorMessage) {
@@ -2197,7 +2197,7 @@ class ValidationErrors {
       code: "UNKNOWN_INTEGRATION" /* UNKNOWN_INTEGRATION */,
       severity: "error" /* ERROR */,
       message: errorMessage,
-      file: "dependencies.json"
+      file: "agent.config.ts"
     };
   }
   static incompatibleVersion(integration, required, available) {
@@ -2206,7 +2206,7 @@ class ValidationErrors {
       code: "INCOMPATIBLE_VERSION" /* INCOMPATIBLE_VERSION */,
       severity: "error" /* ERROR */,
       message: `Integration '${integration}' requires version ${required}, but only ${available} is available`,
-      file: "dependencies.json",
+      file: "agent.config.ts",
       hint: "Update the version requirement or check for compatible versions",
       context: { integration, required, available }
     };
@@ -2338,7 +2338,7 @@ function formatBytes(bytes) {
   return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + " " + sizes[i];
 }
 
-// src/agent-project/dependencies-json.ts
+// src/agent-project/dependencies-parser.ts
 var integrationRefSchema = z2.string().transform((val, ctx) => {
   const match = val.match(/^(?:([^/]+)\/)?([^@]+)@(.+)$/);
   if (!match) {
@@ -2408,7 +2408,7 @@ class IntegrationParser {
     }
     for (const [integration, aliases] of seen.entries()) {
       if (aliases.length > 1) {
-        errors.push(ValidationErrors.warning(`Integration '${integration}' is used with multiple aliases: ${aliases.join(", ")}. This is valid but ensure each has different configurations.`, "dependencies.json"));
+        errors.push(ValidationErrors.warning(`Integration '${integration}' is used with multiple aliases: ${aliases.join(", ")}. This is valid but ensure each has different configurations.`, "agent.config.ts"));
       }
     }
     return errors;
@@ -2463,7 +2463,7 @@ class IntegrationManager {
         }
         if (validation.warnings.length > 0) {
           validation.warnings.forEach((warn) => {
-            warnings.push(ValidationErrors.warning(warn, "dependencies.json"));
+            warnings.push(ValidationErrors.warning(warn, "agent.config.ts"));
           });
         }
       } catch (error) {
@@ -2478,7 +2478,7 @@ class IntegrationManager {
     await Promise.all(fetchPromises);
     const hasChannels = integrations.some((i) => i.definition?.channels && Object.keys(i.definition.channels).length > 0);
     if (!hasChannels && integrations.length > 0) {
-      warnings.push(ValidationErrors.warning("No integrations with channels found. Your agent may not be able to receive messages.", "dependencies.json", "Add an integration with channels (e.g., slack, webchat) to enable conversations"));
+      warnings.push(ValidationErrors.warning("No integrations with channels found. Your agent may not be able to receive messages.", "agent.config.ts", "Add an integration with channels (e.g., slack, webchat) to enable conversations"));
     }
     return { integrations, errors, warnings };
   }
@@ -2585,7 +2585,7 @@ class IntegrationManager {
         requiresConfig = schema?.required && schema.required.length > 0;
       }
       if (requiresConfig) {
-        warnings.push(`Integration '${integration.alias}' requires configuration. Add a connection in dependencies.json`);
+        warnings.push(`Integration '${integration.alias}' requires configuration. Add a connection in agent.config.ts dependencies`);
       }
     }
     return {
@@ -2689,8 +2689,6 @@ class IntegrationCache {
 }
 // src/integrations/operations.ts
 import { Client as Client6 } from "@botpress/client";
-import * as fs8 from "fs";
-import * as path9 from "path";
 import * as process2 from "process";
 
 // src/integrations/hub-cache.ts
@@ -2843,6 +2841,51 @@ class HubCache {
   }
 }
 
+// src/agent-project/config-writer.ts
+init_utils();
+import { Project, SyntaxKind } from "ts-morph";
+import * as path10 from "path";
+
+class ConfigWriter {
+  configPath;
+  constructor(projectPath) {
+    this.configPath = path10.join(projectPath, "agent.config.ts");
+  }
+  async updateDependencies(dependencies) {
+    const project = new Project;
+    const sourceFile = project.addSourceFileAtPath(this.configPath);
+    const defineConfigCall = sourceFile.getDescendantsOfKind(SyntaxKind.CallExpression).find((call) => {
+      const expression = call.getExpression();
+      return expression.getText() === "defineConfig";
+    });
+    if (!defineConfigCall) {
+      throw new Error("Could not find defineConfig() call in agent.config.ts");
+    }
+    const configArg = defineConfigCall.getArguments()[0];
+    if (!configArg || !configArg.isKind(SyntaxKind.ObjectLiteralExpression)) {
+      throw new Error("defineConfig() must have an object literal as its first argument");
+    }
+    const configObject = configArg.asKind(SyntaxKind.ObjectLiteralExpression);
+    if (!configObject) {
+      throw new Error("Could not find dependencies property in agent.config.ts");
+    }
+    let dependenciesProperty = configObject.getProperty("dependencies");
+    if (dependenciesProperty) {
+      dependenciesProperty.setInitializer(JSON.stringify(dependencies));
+    } else {
+      dependenciesProperty = configObject.addPropertyAssignment({
+        name: "dependencies",
+        initializer: JSON.stringify(dependencies)
+      });
+    }
+    sourceFile.formatText();
+    const content = sourceFile.getFullText();
+    const formatted = await formatCode(content, this.configPath);
+    sourceFile.replaceWithText(formatted);
+    await sourceFile.save();
+  }
+}
+
 // src/integrations/operations.ts
 class IntegrationOperations {
   hubCache;
@@ -2932,8 +2975,7 @@ class IntegrationOperations {
     const { name, version = "latest" } = options;
     const ref = this.parseIntegrationRef(`${name}@${version}`);
     const alias = options.alias || ref.name;
-    const depsPath = path9.join(project.path, "dependencies.json");
-    const dependencies = JSON.parse(fs8.readFileSync(depsPath, "utf-8"));
+    const dependencies = project.dependencies || { integrations: {} };
     if (!dependencies.integrations) {
       dependencies.integrations = {};
     }
@@ -2983,52 +3025,79 @@ class IntegrationOperations {
       throw new Error(`Failed to add integration: ${error instanceof Error ? error.message : String(error)}`);
     }
     let requiresConfiguration = false;
-    if (integrationDefinition.configurations) {
-      requiresConfiguration = Object.values(integrationDefinition.configurations).some((config) => config.identifier?.required === true);
-    }
+    requiresConfiguration = Object.values(integrationDefinition.configurations).some((config2) => config2.identifier?.required === true);
     if (!requiresConfiguration && integrationDefinition.configuration) {
-      const config = integrationDefinition.configuration;
-      const schema = config.schema;
+      const config2 = integrationDefinition.configuration;
+      const schema = config2.schema;
       requiresConfiguration = schema?.required && schema.required.length > 0;
     }
     const actualVersion = integrationDefinition.version;
     const integrationVersion = `${ref.fullName}@${actualVersion}`;
     const existingEntry = dependencies.integrations[alias];
+    const existingConfig = existingEntry && typeof existingEntry === "object" ? existingEntry.config : undefined;
+    const config = requiresConfiguration && !existingConfig ? this.getPlaceholderConfig(integrationDefinition) : existingConfig;
     if (existingEntry && typeof existingEntry === "object" && "version" in existingEntry) {
       dependencies.integrations[alias] = {
         ...existingEntry,
         version: integrationVersion
       };
     } else {
-      dependencies.integrations[alias] = {
+      const newEntry = {
         version: integrationVersion,
-        enabled: !requiresConfiguration
+        enabled: !requiresConfiguration,
+        config
       };
+      dependencies.integrations[alias] = newEntry;
     }
-    fs8.writeFileSync(depsPath, stringifyWithOrder(dependencies, dependenciesKeyOrder) + `
-`);
+    const configWriter = new ConfigWriter(project.path);
+    await configWriter.updateDependencies(dependencies);
     return {
       success: true,
       requiresConfiguration,
       newVersion: actualVersion
     };
   }
+  getPlaceholderConfig(integrationDefinition) {
+    const configPlaceholder = {};
+    if (integrationDefinition.configuration) {
+      const config = integrationDefinition.configuration;
+      const schema = config.schema;
+      if (schema?.required && schema.required.length > 0) {
+        const properties = schema.properties || {};
+        for (const fieldName of schema.required) {
+          const fieldDef = properties[fieldName];
+          if (fieldDef?.type === "string") {
+            configPlaceholder[fieldName] = `YOUR_${fieldName.toUpperCase()}_HERE`;
+          } else if (fieldDef?.type === "number" || fieldDef?.type === "integer") {
+            configPlaceholder[fieldName] = 0;
+          } else if (fieldDef?.type === "boolean") {
+            configPlaceholder[fieldName] = false;
+          } else {
+            configPlaceholder[fieldName] = null;
+          }
+        }
+        if (Object.keys(configPlaceholder).length > 0) {
+          console.log("Generated config placeholders:", configPlaceholder);
+          return configPlaceholder;
+        }
+      }
+    }
+    return;
+  }
   async removeIntegration(name) {
     const project = await AgentProject.load(this.projectPath || process2.cwd());
-    const depsPath = path9.join(project.path, "dependencies.json");
-    const dependencies = JSON.parse(fs8.readFileSync(depsPath, "utf-8"));
-    if (!dependencies.integrations || !dependencies.integrations[name]) {
+    const dependencies = project.dependencies;
+    if (!dependencies || !dependencies.integrations || !dependencies.integrations[name]) {
       throw new Error(`Integration "${name}" not found in dependencies`);
     }
     delete dependencies.integrations[name];
-    fs8.writeFileSync(depsPath, stringifyWithOrder(dependencies, dependenciesKeyOrder) + `
-`);
+    const configWriter = new ConfigWriter(project.path);
+    await configWriter.updateDependencies(dependencies);
   }
   async upgradeIntegration(name) {
     const project = await AgentProject.load(this.projectPath || process2.cwd());
-    const depsPath = path9.join(project.path, "dependencies.json");
-    const dependencies = JSON.parse(fs8.readFileSync(depsPath, "utf-8"));
-    if (!dependencies.integrations) {
+    const dependencies = project.dependencies;
+    if (!dependencies || !dependencies.integrations) {
       throw new Error("No integrations found in dependencies");
     }
     const upgraded = [];
@@ -3064,16 +3133,15 @@ class IntegrationOperations {
       }
     }
     if (upgraded.length > 0) {
-      fs8.writeFileSync(depsPath, stringifyWithOrder(dependencies, dependenciesKeyOrder) + `
-`);
+      const configWriter = new ConfigWriter(project.path);
+      await configWriter.updateDependencies(dependencies);
     }
     return { upgraded, failed };
   }
   async listIntegrations() {
     const project = await AgentProject.load(this.projectPath || process2.cwd());
-    const depsPath = path9.join(project.path, "dependencies.json");
-    const dependencies = JSON.parse(fs8.readFileSync(depsPath, "utf-8"));
-    if (!dependencies.integrations) {
+    const dependencies = project.dependencies;
+    if (!dependencies || !dependencies.integrations) {
       return [];
     }
     const integrations = [];
@@ -3303,8 +3371,8 @@ class IntegrationChecker {
 import { Client as Client8 } from "@botpress/client";
 
 // src/interfaces/enhanced-cache.ts
-import fs9 from "fs/promises";
-import path10 from "path";
+import fs8 from "fs/promises";
+import path11 from "path";
 import os6 from "os";
 
 class EnhancedInterfaceCache {
@@ -3314,21 +3382,21 @@ class EnhancedInterfaceCache {
   noCache;
   constructor(noCache = false) {
     this.noCache = noCache;
-    this.cacheDir = path10.join(os6.homedir(), ".adk", "cache", "interfaces");
-    this.resolutionsDir = path10.join(this.cacheDir, "resolutions");
-    this.definitionsDir = path10.join(this.cacheDir, "definitions");
+    this.cacheDir = path11.join(os6.homedir(), ".adk", "cache", "interfaces");
+    this.resolutionsDir = path11.join(this.cacheDir, "resolutions");
+    this.definitionsDir = path11.join(this.cacheDir, "definitions");
   }
   async ensureCacheDirs() {
-    await fs9.mkdir(this.resolutionsDir, { recursive: true });
-    await fs9.mkdir(this.definitionsDir, { recursive: true });
+    await fs8.mkdir(this.resolutionsDir, { recursive: true });
+    await fs8.mkdir(this.definitionsDir, { recursive: true });
   }
   async getResolution(name, version, workspace) {
     if (this.noCache)
       return null;
     try {
       const key = this.getResolutionKey(name, version, workspace);
-      const cachePath = path10.join(this.resolutionsDir, `${key}.json`);
-      const data = await fs9.readFile(cachePath, "utf-8");
+      const cachePath = path11.join(this.resolutionsDir, `${key}.json`);
+      const data = await fs8.readFile(cachePath, "utf-8");
       const resolution = JSON.parse(data);
       const cachedAt = new Date(resolution.cachedAt);
       const ageMinutes = (Date.now() - cachedAt.getTime()) / (1000 * 60);
@@ -3342,21 +3410,21 @@ class EnhancedInterfaceCache {
   async setResolution(name, version, workspace, interfaceId, updatedAt) {
     await this.ensureCacheDirs();
     const key = this.getResolutionKey(name, version, workspace);
-    const cachePath = path10.join(this.resolutionsDir, `${key}.json`);
+    const cachePath = path11.join(this.resolutionsDir, `${key}.json`);
     const resolution = {
       interfaceId,
       updatedAt,
       cachedAt: new Date().toISOString()
     };
-    await fs9.writeFile(cachePath, JSON.stringify(resolution, null, 2));
+    await fs8.writeFile(cachePath, JSON.stringify(resolution, null, 2));
   }
   async getDefinition(interfaceId, updatedAt) {
     if (this.noCache)
       return null;
     try {
       const key = this.getDefinitionKey(interfaceId, updatedAt);
-      const cachePath = path10.join(this.definitionsDir, `${key}.json`);
-      const data = await fs9.readFile(cachePath, "utf-8");
+      const cachePath = path11.join(this.definitionsDir, `${key}.json`);
+      const data = await fs8.readFile(cachePath, "utf-8");
       const cached = JSON.parse(data);
       return cached.definition;
     } catch {
@@ -3366,28 +3434,28 @@ class EnhancedInterfaceCache {
   async setDefinition(interfaceId, updatedAt, definition) {
     await this.ensureCacheDirs();
     const key = this.getDefinitionKey(interfaceId, updatedAt);
-    const cachePath = path10.join(this.definitionsDir, `${key}.json`);
+    const cachePath = path11.join(this.definitionsDir, `${key}.json`);
     const cached = {
       definition,
       cachedAt: new Date().toISOString()
     };
-    await fs9.writeFile(cachePath, JSON.stringify(cached, null, 2));
+    await fs8.writeFile(cachePath, JSON.stringify(cached, null, 2));
   }
   async clear() {
     try {
-      const resolutionFiles = await fs9.readdir(this.resolutionsDir);
-      await Promise.all(resolutionFiles.map((f) => fs9.unlink(path10.join(this.resolutionsDir, f))));
-      const definitionFiles = await fs9.readdir(this.definitionsDir);
-      await Promise.all(definitionFiles.map((f) => fs9.unlink(path10.join(this.definitionsDir, f))));
+      const resolutionFiles = await fs8.readdir(this.resolutionsDir);
+      await Promise.all(resolutionFiles.map((f) => fs8.unlink(path11.join(this.resolutionsDir, f))));
+      const definitionFiles = await fs8.readdir(this.definitionsDir);
+      await Promise.all(definitionFiles.map((f) => fs8.unlink(path11.join(this.definitionsDir, f))));
     } catch {}
   }
   async getStats() {
     const getDirectoryStats = async (dir) => {
       try {
-        const files = await fs9.readdir(dir);
+        const files = await fs8.readdir(dir);
         let totalSize = 0;
         for (const file of files) {
-          const stats = await fs9.stat(path10.join(dir, file));
+          const stats = await fs8.stat(path11.join(dir, file));
           totalSize += stats.size;
         }
         return { count: files.length, sizeBytes: totalSize };
@@ -3498,7 +3566,7 @@ class InterfaceManager {
         intf.validationResult = validation;
         if (!validation.valid) {
           validation.errors.forEach((msg) => {
-            errors.push(ValidationErrors.warning(msg, "dependencies.json"));
+            errors.push(ValidationErrors.warning(msg, "agent.config.ts"));
           });
         }
       } catch (error) {
@@ -3748,7 +3816,7 @@ class AgentProject {
   _tables = [];
   constructor(projectPath, options = {}) {
     this._options = options;
-    this._path = path11.resolve(projectPath);
+    this._path = path12.resolve(projectPath);
     this._integrationManager = new IntegrationManager({
       noCache: options.noCache
     });
@@ -3760,7 +3828,7 @@ class AgentProject {
     });
   }
   static async load(projectPath, options = {}) {
-    const resolvedPath = path11.resolve(projectPath);
+    const resolvedPath = path12.resolve(projectPath);
     if (!options.noCache) {
       const cached = AgentProject._projectCache.get(resolvedPath);
       if (cached) {
@@ -3778,7 +3846,7 @@ class AgentProject {
     AgentProject._projectCache.clear();
   }
   static clearCacheForPath(projectPath) {
-    const resolvedPath = path11.resolve(projectPath);
+    const resolvedPath = path12.resolve(projectPath);
     AgentProject._projectCache.delete(resolvedPath);
   }
   get path() {
@@ -3864,7 +3932,6 @@ class AgentProject {
         workspaceId: this._agentInfo?.workspaceId,
         botId: this._agentInfo?.botId
       });
-      await this.loadDependencies();
       await this.loadBuiltInWorkflows();
       await this.loadBuiltInActions();
       await this.loadAgentPrimitives();
@@ -3890,17 +3957,17 @@ class AgentProject {
     const warnings = [];
     const info = [];
     try {
-      await fs10.access(this._path);
-      const requiredFiles = ["agent.config.ts", "dependencies.json"];
+      await fs9.access(this._path);
+      const requiredFiles = ["agent.config.ts"];
       for (const file of requiredFiles) {
         try {
-          await fs10.access(path11.join(this._path, file));
+          await fs9.access(path12.join(this._path, file));
         } catch {
           errors.push(ValidationErrors.requiredFileMissing(file));
         }
       }
       try {
-        await fs10.access(path11.join(this._path, "agent.json"));
+        await fs9.access(path12.join(this._path, "agent.json"));
       } catch {
         info.push({
           $type: "ValidationError",
@@ -3914,7 +3981,7 @@ class AgentProject {
       const expectedDirs = ["actions", "workflows", "conversations", "assets"];
       for (const dir of expectedDirs) {
         try {
-          const stats = await fs10.stat(path11.join(this._path, dir));
+          const stats = await fs9.stat(path12.join(this._path, dir));
           if (!stats.isDirectory()) {
             warnings.push(ValidationErrors.invalidStructure(dir, "directory"));
           }
@@ -3987,9 +4054,9 @@ class AgentProject {
     return this._assetsManager;
   }
   async createAgentInfo(info) {
-    const agentPath = path11.join(this._path, "agent.json");
+    const agentPath = path12.join(this._path, "agent.json");
     const agentContent = stringifyWithOrder(info, agentInfoKeyOrder);
-    await fs10.writeFile(agentPath, agentContent);
+    await fs9.writeFile(agentPath, agentContent);
     this._agentInfo = info;
   }
   async updateAgentInfo(updates) {
@@ -3997,9 +4064,9 @@ class AgentProject {
       throw new Error("No agent.json found. Use createAgentInfo() first.");
     }
     const updatedInfo = { ...this._agentInfo, ...updates };
-    const agentPath = path11.join(this._path, "agent.json");
+    const agentPath = path12.join(this._path, "agent.json");
     const agentContent = stringifyWithOrder(updatedInfo, agentInfoKeyOrder);
-    await fs10.writeFile(agentPath, agentContent);
+    await fs9.writeFile(agentPath, agentContent);
     this._agentInfo = updatedInfo;
   }
   requiresAgentInfo(operation) {
@@ -4009,7 +4076,7 @@ class AgentProject {
   }
   async loadConfig() {
     try {
-      const configPath = path11.join(this._path, "agent.config.ts");
+      const configPath = path12.join(this._path, "agent.config.ts");
       const configModule = await import(`${configPath}?t=${Date.now()}`);
       if (!configModule || !configModule.default) {
         this._errors.push({
@@ -4034,81 +4101,64 @@ class AgentProject {
         return;
       }
       this._config = configModule.default;
-    } catch (error) {
-      this._errors.push({
-        $type: "ValidationError",
-        code: "INVALID_CONFIG_SYNTAX" /* INVALID_CONFIG_SYNTAX */,
-        severity: "error" /* ERROR */,
-        message: `Failed to load agent.config.ts: ${error.message}`,
-        file: "agent.config.ts"
-      });
-    }
-  }
-  async loadDependencies() {
-    try {
-      const depsPath = path11.join(this._path, "dependencies.json");
-      const depsContent = await fs10.readFile(depsPath, "utf-8");
-      let depsData;
-      try {
-        depsData = JSON.parse(depsContent);
-      } catch (parseError) {
+      const config = configModule.default;
+      if (config.dependencies) {
+        const validationResult = dependenciesSchema.safeParse(config.dependencies);
+        if (!validationResult.success) {
+          const errors = validationResult.error.errors;
+          for (const error of errors) {
+            this._errors.push({
+              $type: "ValidationError",
+              code: "INVALID_DEPENDENCIES_SCHEMA" /* INVALID_DEPENDENCIES_SCHEMA */,
+              severity: "error" /* ERROR */,
+              message: `Invalid dependencies in agent.config.ts: ${error.path.join(".")} - ${error.message}`,
+              file: "agent.config.ts",
+              hint: error.code === "invalid_type" ? `Expected ${error.expected}, but got ${error.received}` : undefined
+            });
+          }
+          this._dependencies = { integrations: {} };
+          this._integrations = [];
+          this._interfaces = [];
+          return;
+        }
+        this._dependencies = validationResult.data;
+        if (this._dependencies) {
+          const [intRes, ifRes] = await Promise.all([
+            this._integrationManager.loadIntegrations(this._dependencies),
+            this._interfaceManager.loadInterfaces(this._dependencies)
+          ]);
+          this._integrations = intRes.integrations;
+          this._interfaces = ifRes.interfaces;
+          this._errors.push(...intRes.errors, ...ifRes.errors);
+          this._warnings.push(...intRes.warnings, ...ifRes.warnings);
+        }
+      } else {
         this._errors.push({
           $type: "ValidationError",
-          code: "INVALID_DEPENDENCIES_SYNTAX" /* INVALID_DEPENDENCIES_SYNTAX */,
+          code: "MISSING_REQUIRED_FIELD" /* MISSING_REQUIRED_FIELD */,
           severity: "error" /* ERROR */,
-          message: `Invalid JSON syntax in dependencies.json: ${parseError.message}`,
-          file: "dependencies.json"
+          message: "agent.config.ts must include a dependencies field",
+          file: "agent.config.ts",
+          hint: "Add dependencies: { integrations: {} } to your defineConfig() call"
         });
         this._dependencies = { integrations: {} };
         this._integrations = [];
         this._interfaces = [];
-        return;
-      }
-      const validationResult = dependenciesSchema.safeParse(depsData);
-      if (!validationResult.success) {
-        const errors = validationResult.error.errors;
-        for (const error of errors) {
-          this._errors.push({
-            $type: "ValidationError",
-            code: "INVALID_DEPENDENCIES_SCHEMA" /* INVALID_DEPENDENCIES_SCHEMA */,
-            severity: "error" /* ERROR */,
-            message: `Invalid dependencies.json: ${error.path.join(".")} - ${JSON.stringify(error, null, 2)}`,
-            file: "dependencies.json",
-            hint: error.code === "invalid_type" ? `Expected ${error.expected}, but got ${error.received}` : undefined
-          });
-        }
-        this._dependencies = { integrations: {} };
-        this._integrations = [];
-        this._interfaces = [];
-        return;
-      }
-      this._dependencies = validationResult.data;
-      if (this._dependencies) {
-        const [intRes, ifRes] = await Promise.all([
-          this._integrationManager.loadIntegrations(this._dependencies),
-          this._interfaceManager.loadInterfaces(this._dependencies)
-        ]);
-        this._integrations = intRes.integrations;
-        this._interfaces = ifRes.interfaces;
-        this._errors.push(...intRes.errors, ...ifRes.errors);
-        this._warnings.push(...intRes.warnings, ...ifRes.warnings);
       }
     } catch (error) {
-      if (error.code === "ENOENT") {
-        this._dependencies = {
-          integrations: {}
-        };
-        this._integrations = [];
-        this._interfaces = [];
-      } else {
-        throw error;
-      }
+      this._errors.push({
+        $type: "ValidationError",
+        code: "INVALID_CONFIG_SYNTAX" /* INVALID_CONFIG_SYNTAX */,
+        severity: "error" /* ERROR */,
+        message: `Failed to load agent.config.ts: ${error.message}`,
+        file: "agent.config.ts"
+      });
     }
   }
   async loadAgentInfo() {
     try {
-      const agentPath = path11.join(this._path, "agent.json");
-      const agentContent = await fs10.readFile(agentPath, "utf-8");
+      const agentPath = path12.join(this._path, "agent.json");
+      const agentContent = await fs9.readFile(agentPath, "utf-8");
       let agentData;
       try {
         agentData = JSON.parse(agentContent);
@@ -4205,8 +4255,8 @@ class AgentProject {
       setAdkCommand(this._options.adkCommand);
     }
     try {
-      const src = path11.join(this._path, "src");
-      if (!await fs10.stat(src).catch(() => false)) {
+      const src = path12.join(this._path, "src");
+      if (!await fs9.stat(src).catch(() => false)) {
         this._errors.push({
           $type: "ValidationError",
           code: "INVALID_STRUCTURE" /* INVALID_STRUCTURE */,
@@ -4215,14 +4265,14 @@ class AgentProject {
         });
         return;
       }
-      const allFiles = await fs10.readdir(src, {
+      const allFiles = await fs9.readdir(src, {
         withFileTypes: true,
         recursive: true
       });
       for (const file of allFiles.filter((x) => x.isFile())) {
         const filename = file.name;
-        const absolutePath = path11.join(file.parentPath, file.name);
-        const relPath = path11.relative(this.path, absolutePath);
+        const absolutePath = path12.join(file.parentPath, file.name);
+        const relPath = path12.relative(this.path, absolutePath);
         if (filename.toLowerCase().endsWith(".d.ts")) {
           continue;
         }
@@ -4398,7 +4448,7 @@ class AgentProject {
 // src/agent-project/file-watcher.ts
 import { watch } from "fs";
 import { EventEmitter as EventEmitter2 } from "events";
-import path12 from "path";
+import path13 from "path";
 class FileWatcher extends EventEmitter2 {
   basePath;
   watcher;
@@ -4421,7 +4471,7 @@ class FileWatcher extends EventEmitter2 {
     this.watcher = watch(this.basePath, { recursive: true }, (eventType, filename) => {
       if (!filename)
         return;
-      const fullPath = path12.join(this.basePath, filename);
+      const fullPath = path13.join(this.basePath, filename);
       const relativePath = filename;
       if (this.shouldIgnore(relativePath)) {
         return;
@@ -4470,7 +4520,7 @@ class FileWatcher extends EventEmitter2 {
 }
 // src/agent-init/agent-project-generator.ts
 init_utils();
-import * as fs11 from "fs";
+import * as fs10 from "fs";
 import * as path14 from "path";
 
 class AgentProjectGenerator {
@@ -4487,7 +4537,6 @@ class AgentProjectGenerator {
   async generate() {
     this.ensureEmptyDirectory();
     this.createPackageJson();
-    this.createDependenciesJson();
     await this.createAgentConfig();
     this.createTsConfig();
     this.createAgentJson();
@@ -4496,10 +4545,10 @@ class AgentProjectGenerator {
     await this.createSourceStructure();
   }
   ensureEmptyDirectory() {
-    if (!fs11.existsSync(this.projectPath)) {
-      fs11.mkdirSync(this.projectPath, { recursive: true });
+    if (!fs10.existsSync(this.projectPath)) {
+      fs10.mkdirSync(this.projectPath, { recursive: true });
     }
-    const files = fs11.readdirSync(this.projectPath);
+    const files = fs10.readdirSync(this.projectPath);
     if (files.length > 0) {
       throw new Error(`Directory ${this.projectPath} is not empty. Please use an empty directory.`);
     }
@@ -4517,7 +4566,7 @@ class AgentProjectGenerator {
         deploy: "adk deploy"
       },
       dependencies: {
-        "@botpress/runtime": `^${"1.7.7"}`
+        "@botpress/runtime": `^${"1.7.8"}`
       },
       devDependencies: {
         typescript: "^5.9.3"
@@ -4528,12 +4577,12 @@ class AgentProjectGenerator {
     }
     this.writeJsonFile("package.json", packageJson);
   }
-  createDependenciesJson() {
-    const dependenciesJson = {
+  getDefaultDependencies() {
+    const dependencies = {
       integrations: {}
     };
     if (this.template === "hello-world") {
-      dependenciesJson.integrations = {
+      dependencies.integrations = {
         chat: {
           version: "chat@latest",
           enabled: true
@@ -4544,9 +4593,12 @@ class AgentProjectGenerator {
         }
       };
     }
-    this.writeJsonFile("dependencies.json", dependenciesJson);
+    return dependencies;
   }
   async createAgentConfig() {
+    const dependencies = this.getDefaultDependencies();
+    const integrationsJson = JSON.stringify(dependencies.integrations, null, 4).replace(/\n/g, `
+    `);
     const defaultModels = this.template === "hello-world" ? `
   defaultModels: {
     autonomous: "cerebras:gpt-oss-120b",
@@ -4566,6 +4618,10 @@ ${defaultModels}
   user: {
     state: z.object({}),
   },
+
+  dependencies: {
+    integrations: ${integrationsJson},
+  },
 });
 `;
     await this.writeFormattedFile("agent.config.ts", agentConfig);
@@ -4675,11 +4731,11 @@ A Botpress Agent built with the ADK.
   }
   async createSourceStructure() {
     const srcPath = path14.join(this.projectPath, "src");
-    fs11.mkdirSync(srcPath);
+    fs10.mkdirSync(srcPath);
     const subdirectories = ["actions", "conversations", "knowledge", "tables", "triggers", "workflows"];
     for (const subdir of subdirectories) {
       const subdirPath = path14.join(srcPath, subdir);
-      fs11.mkdirSync(subdirPath);
+      fs10.mkdirSync(subdirPath);
       if (subdir === "conversations" && this.template === "hello-world") {
         const conversationContent = `import { Conversation } from "@botpress/runtime";
 
@@ -4709,7 +4765,7 @@ export default {};
   }
   writeFile(relativePath, content) {
     const filePath = path14.join(this.projectPath, relativePath);
-    fs11.writeFileSync(filePath, content);
+    fs10.writeFileSync(filePath, content);
   }
   async writeFormattedFile(relativePath, content) {
     const formatted = await formatCode(content, relativePath);
@@ -4857,14 +4913,16 @@ var getIntegrationNames = (integration) => ({
     actions: `Integration_Actions_${getPascalAlias(integration)}`,
     channels: `Integration_Channels_${getPascalAlias(integration)}`,
     events: `Integration_Events_${getPascalAlias(integration)}`,
-    users: `Integration_Users_${getPascalAlias(integration)}`
+    users: `Integration_Users_${getPascalAlias(integration)}`,
+    config: `Integration_Config_${getPascalAlias(integration)}`
   },
   paths: {
     index: path16.join(snakeCase(getPascalAlias(integration)), `index.ts`),
     actions: path16.join(snakeCase(getPascalAlias(integration)), `actions.ts`),
     channels: path16.join(snakeCase(getPascalAlias(integration)), `channels.ts`),
     events: path16.join(snakeCase(getPascalAlias(integration)), `events.ts`),
-    users: path16.join(snakeCase(getPascalAlias(integration)), `users.ts`)
+    users: path16.join(snakeCase(getPascalAlias(integration)), `users.ts`),
+    config: path16.join(snakeCase(getPascalAlias(integration)), `config.ts`)
   }
 });
 async function generateIntegrationTypes(integration) {
@@ -4890,17 +4948,20 @@ async function generateIntegrationTypes(integration) {
   import { Integration_Channels_${getPascalAlias(integration)} } from "${rel(names.paths.channels)}";
   import { Integration_Events_${getPascalAlias(integration)} } from "${rel(names.paths.events)}";
   import { Integration_Users_${getPascalAlias(integration)} } from "${rel(names.paths.users)}";
+  import { Integration_Config_${getPascalAlias(integration)} } from "${rel(names.paths.config)}";
 
   export * from "${rel(names.paths.actions)}";
   export * from "${rel(names.paths.channels)}";
   export * from "${rel(names.paths.events)}";
   export * from "${rel(names.paths.users)}";
+  export * from "${rel(names.paths.config)}";
 
   export type Integration_All_${getPascalAlias(integration)} = {
     actions: Integration_Actions_${getPascalAlias(integration)};
     channels: Integration_Channels_${getPascalAlias(integration)};
     events: Integration_Events_${getPascalAlias(integration)};
     users: Integration_Users_${getPascalAlias(integration)};
+    config: Integration_Config_${getPascalAlias(integration)};
   };
   `;
   let tActions = `
@@ -5039,6 +5100,34 @@ Description: ${tag?.description}`);
     tags: ${userTagsUnion};
   };
   `;
+  let tConfig = `
+  ////////////////////////////////////////////////////////
+  // DO NOT EDIT THIS FILE DIRECTLY
+  // This file is auto-generated from the Botpress ADK
+  // ADK Version: ${ADK_VERSION}
+  // Integration: ${integration.definition?.name}
+  // Version: ${integration.definition?.version}
+  // File: ${names.paths.config}
+  // Hash: ${hash}
+  // Updated at: ${integration.definition?.updatedAt}
+  ////////////////////////////////////////////////////////
+
+  export type Integration_Config_${getPascalAlias(integration)} = `;
+  const configurationType = integration.configurationType || "default";
+  let configType = "{}";
+  if (integration.definition?.configurations && integration.definition.configurations[configurationType]) {
+    const configSchema = integration.definition.configurations[configurationType].schema;
+    if (configSchema) {
+      configType = transforms.fromJSONSchema(configSchema).toTypescriptType();
+    }
+  } else if (integration.definition?.configuration) {
+    const configSchema = integration.definition.configuration.schema;
+    if (configSchema) {
+      configType = transforms.fromJSONSchema(configSchema).toTypescriptType();
+    }
+  }
+  tConfig += `${configType};
+  `;
   return {
     names,
     files: {
@@ -5046,14 +5135,15 @@ Description: ${tag?.description}`);
       [names.paths.actions]: await formatCode(tActions),
       [names.paths.channels]: await formatCode(tChannels),
       [names.paths.events]: await formatCode(tEvents),
-      [names.paths.users]: await formatCode(tUsers)
+      [names.paths.users]: await formatCode(tUsers),
+      [names.paths.config]: await formatCode(tConfig)
     }
   };
 }
 // src/bot-generator/generator.ts
 import dedent from "dedent";
 import { existsSync as existsSync5 } from "fs";
-import fs15 from "fs/promises";
+import fs14 from "fs/promises";
 import path29 from "path";
 
 // src/generators/interface-types.ts
@@ -5552,7 +5642,7 @@ init_fs();
 
 // src/bot-generator/dev-id-manager.ts
 import path24 from "path";
-import fs12 from "fs/promises";
+import fs11 from "fs/promises";
 import { existsSync as existsSync2 } from "fs";
 import { Client as Client9 } from "@botpress/client";
 class DevIdManager {
@@ -5590,7 +5680,7 @@ class DevIdManager {
   async readProjectCache() {
     try {
       if (existsSync2(this.projectCachePath)) {
-        const content = await fs12.readFile(this.projectCachePath, "utf-8");
+        const content = await fs11.readFile(this.projectCachePath, "utf-8");
         return JSON.parse(content);
       }
     } catch (error) {
@@ -5600,8 +5690,8 @@ class DevIdManager {
   }
   async saveProjectCache(cache2) {
     try {
-      await fs12.mkdir(path24.dirname(this.projectCachePath), { recursive: true });
-      await fs12.writeFile(this.projectCachePath, JSON.stringify(cache2, null, 2));
+      await fs11.mkdir(path24.dirname(this.projectCachePath), { recursive: true });
+      await fs11.writeFile(this.projectCachePath, JSON.stringify(cache2, null, 2));
     } catch (error) {
       console.error("Error saving project.cache.json:", error);
     }
@@ -5655,7 +5745,7 @@ class DevIdManager {
 
 // src/bot-generator/integration-sync.ts
 import path25 from "path";
-import fs13 from "fs/promises";
+import fs12 from "fs/promises";
 import { existsSync as existsSync3 } from "fs";
 class IntegrationSync {
   projectPath;
@@ -5704,7 +5794,7 @@ class IntegrationSync {
       if (!existsSync3(indexPath)) {
         return false;
       }
-      const indexContent = await fs13.readFile(indexPath, "utf-8");
+      const indexContent = await fs12.readFile(indexPath, "utf-8");
       const versionMatch = indexContent.match(/version:\s*["']([^"']+)["']/);
       if (!versionMatch) {
         return false;
@@ -5739,14 +5829,14 @@ class IntegrationSync {
       throw new Error(`Integration folder not found: ${sourceFolder}`);
     }
     if (existsSync3(targetFolder)) {
-      await fs13.rm(targetFolder, { recursive: true, force: true });
+      await fs12.rm(targetFolder, { recursive: true, force: true });
     }
-    await fs13.rename(sourceFolder, targetFolder);
+    await fs12.rename(sourceFolder, targetFolder);
   }
   async removeIntegrationFolder(alias) {
     const targetFolder = path25.join(this.bpModulesPath, `integration_${alias}`);
     if (existsSync3(targetFolder)) {
-      await fs13.rm(targetFolder, { recursive: true, force: true });
+      await fs12.rm(targetFolder, { recursive: true, force: true });
     }
   }
   async syncIntegrations() {
@@ -5756,7 +5846,7 @@ class IntegrationSync {
     if (integrations.length === 0) {
       return { synced, errors };
     }
-    await fs13.mkdir(this.bpModulesPath, { recursive: true });
+    await fs12.mkdir(this.bpModulesPath, { recursive: true });
     for (const integration of integrations) {
       try {
         const isAlreadySynced = await this.isIntegrationSynced(integration);
@@ -5779,7 +5869,7 @@ class IntegrationSync {
 
 // src/bot-generator/interface-sync.ts
 import path26 from "path";
-import fs14 from "fs/promises";
+import fs13 from "fs/promises";
 import { existsSync as existsSync4 } from "fs";
 import { spawn } from "child_process";
 class InterfaceSync {
@@ -5816,7 +5906,7 @@ class InterfaceSync {
       if (!existsSync4(indexPath)) {
         return false;
       }
-      const indexContent = await fs14.readFile(indexPath, "utf-8");
+      const indexContent = await fs13.readFile(indexPath, "utf-8");
       const versionMatch = indexContent.match(/version:\s*["']([^"']+)["']/);
       if (!versionMatch) {
         return false;
@@ -5884,14 +5974,14 @@ class InterfaceSync {
       throw new Error(`Interface folder not found: ${sourceFolder}`);
     }
     if (existsSync4(targetFolder)) {
-      await fs14.rm(targetFolder, { recursive: true, force: true });
+      await fs13.rm(targetFolder, { recursive: true, force: true });
     }
-    await fs14.rename(sourceFolder, targetFolder);
+    await fs13.rename(sourceFolder, targetFolder);
   }
   async removeInterfaceFolder(alias) {
     const targetFolder = path26.join(this.bpModulesPath, `interface_${pascalCase(alias)}`);
     if (existsSync4(targetFolder)) {
-      await fs14.rm(targetFolder, { recursive: true, force: true });
+      await fs13.rm(targetFolder, { recursive: true, force: true });
     }
   }
   async syncInterfaces() {
@@ -5901,7 +5991,7 @@ class InterfaceSync {
     if (interfaces.length === 0) {
       return { synced, errors };
     }
-    await fs14.mkdir(this.bpModulesPath, { recursive: true });
+    await fs13.mkdir(this.bpModulesPath, { recursive: true });
     for (const interfaceInfo of interfaces) {
       try {
         const isAlreadySynced = await this.isInterfaceSynced(interfaceInfo);
@@ -5949,7 +6039,7 @@ class BotGenerator {
         return [];
       const result = [];
       const walk = async (dir, relativeBase) => {
-        const entries = await fs15.readdir(dir, { withFileTypes: true });
+        const entries = await fs14.readdir(dir, { withFileTypes: true });
         for (const entry of entries) {
           const abs = path29.join(dir, entry.name);
           const rel = path29.join(relativeBase, entry.name);
@@ -5970,17 +6060,17 @@ class BotGenerator {
     if (!existsSync5(rootDir))
       return;
     const removeIfEmpty = async (dir) => {
-      const entries = await fs15.readdir(dir, { withFileTypes: true });
+      const entries = await fs14.readdir(dir, { withFileTypes: true });
       for (const entry of entries) {
         if (entry.isDirectory()) {
           const subdir = path29.join(dir, entry.name);
           await removeIfEmpty(subdir);
         }
       }
-      const after = await fs15.readdir(dir);
+      const after = await fs14.readdir(dir);
       if (after.length === 0 && dir !== rootDir) {
         try {
-          await fs15.rmdir(dir, { recursive: false });
+          await fs14.rmdir(dir, { recursive: false });
         } catch {}
       }
     };
@@ -5988,7 +6078,7 @@ class BotGenerator {
   }
   async generate() {
     const project = await AgentProject.load(this.projectPath);
-    await fs15.mkdir(this.outputPath, { recursive: true });
+    await fs14.mkdir(this.outputPath, { recursive: true });
     await this.generateBotDefinition();
     await this.generateIntegrationsDefinition();
     await this.generateInterfacesDefinition();
@@ -6027,7 +6117,7 @@ class BotGenerator {
         for (const [filePath, content] of Object.entries(types6.files)) {
           const fullPath = path29.join(this.projectPath, ".adk", "integrations", filePath);
           const dir = path29.dirname(fullPath);
-          await fs15.mkdir(dir, { recursive: true });
+          await fs14.mkdir(dir, { recursive: true });
           await createFile(fullPath, content);
           files.add(filePath);
         }
@@ -6037,7 +6127,8 @@ class BotGenerator {
       ////////////////////////////////////////////////////////
       // DO NOT EDIT THIS FILE DIRECTLY
       // This file is auto-generated from the Botpress ADK
-      // File: integrations.ts
+      // ADK Version: ${ADK_VERSION}
+      // Generated at: ${new Date().toISOString()}
       ////////////////////////////////////////////////////////
 
       declare module "@botpress/runtime/_types/integrations" {
@@ -6046,13 +6137,13 @@ class BotGenerator {
         };
       }
       `;
-    await createFile(path29.join(this.projectPath, ".adk", "integrations.d.ts"), await formatCode(types5));
+    await createFile(path29.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 = path29.join(integrationsDir, rel);
         try {
-          await fs15.rm(abs, { force: true });
+          await fs14.rm(abs, { force: true });
         } catch {}
       }
     }
@@ -6169,7 +6260,7 @@ declare module "@botpress/runtime/_types/state" {
       for (const [filePath, content] of Object.entries(types6.files)) {
         const fullPath = path29.join(this.projectPath, ".adk", "interfaces", filePath);
         const dir = path29.dirname(fullPath);
-        await fs15.mkdir(dir, { recursive: true });
+        await fs14.mkdir(dir, { recursive: true });
         await createFile(fullPath, content);
         files.add(filePath);
       }
@@ -6212,7 +6303,7 @@ declare module "@botpress/runtime/_types/state" {
       for (const rel of staleInterfaceFiles) {
         const abs = path29.join(interfacesDir, rel);
         try {
-          await fs15.rm(abs, { force: true });
+          await fs14.rm(abs, { force: true });
         } catch {}
       }
     }
@@ -6584,7 +6675,7 @@ declare module "@botpress/runtime/_types/state" {
         noPropertyAccessFromIndexSignature: false,
         noUnusedLocals: false
       },
-      include: [".botpress/**/*", "src/**/*", "bp_modules/**/*", "./*.ts", "./*.json"]
+      include: [".botpress/**/*", "src/**/*", "bp_modules/**/*", "./*.ts", "./*.json", "../*.d.ts"]
     };
     await createFile(path29.join(this.outputPath, "tsconfig.json"), JSON.stringify(tsConfig, null, 2));
   }
@@ -6615,20 +6706,20 @@ declare module "@botpress/runtime/_types/state" {
     const assetsPath = path29.join(this.projectPath, "assets");
     const targetPath = path29.join(this.outputPath, "assets");
     if (existsSync5(assetsPath)) {
-      await fs15.mkdir(targetPath, { recursive: true });
+      await fs14.mkdir(targetPath, { recursive: true });
       await this.copyDirectory(assetsPath, targetPath);
     }
   }
   async copyDirectory(src, dest) {
-    const entries = await fs15.readdir(src, { withFileTypes: true });
+    const entries = await fs14.readdir(src, { withFileTypes: true });
     for (const entry of entries) {
       const srcPath = path29.join(src, entry.name);
       const destPath = path29.join(dest, entry.name);
       if (entry.isDirectory()) {
-        await fs15.mkdir(destPath, { recursive: true });
+        await fs14.mkdir(destPath, { recursive: true });
         await this.copyDirectory(srcPath, destPath);
       } else {
-        await fs15.copyFile(srcPath, destPath);
+        await fs14.copyFile(srcPath, destPath);
       }
     }
   }
@@ -6950,7 +7041,7 @@ declare module "@botpress/runtime/_types/state" {
   async copyAssetsRuntime() {
     const assetsRuntimePath = path29.join(this.projectPath, ".adk", "assets-runtime.ts");
     if (existsSync5(assetsRuntimePath)) {
-      const content = await fs15.readFile(assetsRuntimePath, "utf-8");
+      const content = await fs14.readFile(assetsRuntimePath, "utf-8");
       await createFile(path29.join(this.outputPath, "src", "assets-runtime.ts"), await formatCode(content));
     }
   }
@@ -7198,7 +7289,7 @@ class FileWatcher2 extends EventEmitter3 {
     this.debounceMs = options.debounceMs ?? 100;
   }
   start() {
-    const rootFiles = ["dependencies.json", "package.json", "agent.json", "agent.config.ts"];
+    const rootFiles = ["package.json", "agent.json", "agent.config.ts"];
     for (const file of rootFiles) {
       const filePath = join7(this.projectPath, file);
       if (existsSync6(filePath)) {
@@ -7363,5 +7454,5 @@ export {
   AgentProject
 };
 
-//# debugId=D326A7034ACA98B664756E2164756E21
+//# debugId=AB6CC084B3E80E8D64756E2164756E21
 //# sourceMappingURL=index.js.map