@botpress/adk 1.12.2 → 1.12.3

package/dist/index.js

@@ -654,7 +654,7 @@ var PRETTIER_CONFIG, formatCode = async (code, filepath) => {
 `));
     return code;
   }
-}, ADK_VERSION = "1.12.2", relative2 = (from, to) => {
+}, ADK_VERSION = "1.12.3", relative2 = (from, to) => {
   const fromDir = path10.dirname(from);
   const relative3 = path10.relative(fromDir, to);
   return relative3.startsWith(".") ? relative3 : `./${relative3}`;
@@ -678,7 +678,7 @@ var exports_action_types = {};
 __export(exports_action_types, {
   generateActionTypes: () => generateActionTypes
 });
-import path30 from "path";
+import path31 from "path";
 async function generateActionTypes(project) {
   const actionDefs = [];
   for (const action of project.actions) {
@@ -693,7 +693,7 @@ async function generateActionTypes(project) {
     };`);
         continue;
       }
-      const absolutePath = path30.join(project.path, action.path);
+      const absolutePath = path31.join(project.path, action.path);
       const actionModule = await import(`${absolutePath}?t=${Date.now()}`);
       const actionInstance = actionModule[action.export] || actionModule.default;
       if (actionInstance && actionInstance.input && actionInstance.output) {
@@ -738,7 +738,7 @@ ${actionDefs.join(`
   };
 }
 `;
-  const actionTypesPath = path30.join(project.path, ".adk", "action-types.d.ts");
+  const actionTypesPath = path31.join(project.path, ".adk", "action-types.d.ts");
   await createFile(actionTypesPath, await formatCode(content));
 }
 var init_action_types = __esm(() => {
@@ -751,7 +751,7 @@ var exports_integration_action_types = {};
 __export(exports_integration_action_types, {
   generateIntegrationActionTypes: () => generateIntegrationActionTypes
 });
-import path31 from "path";
+import path32 from "path";
 async function generateIntegrationActionTypes(project) {
   const content = `
 ////////////////////////////////////////////////////////
@@ -785,7 +785,7 @@ type IntegrationsMap<T> = {
 export type IntegrationActions = IntegrationsMap<Integrations>;
 }
 `;
-  const integrationActionTypesPath = path31.join(project.path, ".adk", "integration-action-types.d.ts");
+  const integrationActionTypesPath = path32.join(project.path, ".adk", "integration-action-types.d.ts");
   await createFile(integrationActionTypesPath, await formatCode(content));
 }
 var init_integration_action_types = __esm(() => {
@@ -797,7 +797,7 @@ var init_integration_action_types = __esm(() => {
 var require_package = __commonJS((exports, module) => {
   module.exports = {
     name: "@botpress/adk",
-    version: "1.12.2",
+    version: "1.12.3",
     description: "Core ADK library for building AI agents on Botpress",
     type: "module",
     main: "dist/index.js",
@@ -844,7 +844,7 @@ var require_package = __commonJS((exports, module) => {
       "@botpress/cli": "^4.27.3",
       "@botpress/client": "^1.28.0",
       "@botpress/cognitive": "^0.2.0",
-      "@botpress/runtime": "^1.12.2",
+      "@botpress/runtime": "^1.12.3",
       "@botpress/sdk": "^4.18.1",
       "@bpinternal/jex": "^1.2.4",
       "@bpinternal/yargs-extra": "^0.0.21",
@@ -6163,7 +6163,7 @@ class AgentProjectGenerator {
         deploy: "adk deploy"
       },
       dependencies: {
-        "@botpress/runtime": `^${"1.12.2"}`
+        "@botpress/runtime": `^${"1.12.3"}`
       },
       devDependencies: {
         typescript: "^5.9.3"
@@ -6775,9 +6775,9 @@ Description: ${tag?.description}`);
 }
 // src/bot-generator/generator.ts
 import dedent from "dedent";
-import { existsSync as existsSync6 } from "fs";
-import fs15 from "fs/promises";
-import path32 from "path";
+import { existsSync as existsSync7 } from "fs";
+import fs16 from "fs/promises";
+import path33 from "path";
 
 // src/generators/interface-types.ts
 import { transforms as transforms2 } from "@botpress/sdk";
@@ -7516,10 +7516,51 @@ ${integrationEvents.join(`
 // src/bot-generator/generator.ts
 init_fs();
 
-// src/bot-generator/dev-id-manager.ts
-import path27 from "path";
+// src/utils/link-sdk.ts
+import { existsSync as existsSync3, realpathSync } from "fs";
 import fs12 from "fs/promises";
-import { existsSync as existsSync3 } from "fs";
+import path27 from "path";
+function findPackage(name, startDir) {
+  let current;
+  try {
+    current = realpathSync(startDir);
+  } catch {
+    current = startDir;
+  }
+  while (current !== path27.dirname(current)) {
+    const pkgPath = path27.join(current, "node_modules", name);
+    if (existsSync3(pkgPath)) {
+      return pkgPath;
+    }
+    current = path27.dirname(current);
+  }
+  return null;
+}
+async function linkSdk(agentDir, botDir) {
+  const targetSdkPath = path27.join(botDir, "node_modules", "@botpress", "sdk");
+  if (existsSync3(targetSdkPath)) {
+    return;
+  }
+  const runtimePath = findPackage("@botpress/runtime", agentDir);
+  if (!runtimePath) {
+    console.warn("Warning: Could not find @botpress/runtime in agent directory");
+    return;
+  }
+  let sdkPath = findPackage("@botpress/sdk", runtimePath);
+  if (!sdkPath) {
+    console.warn(`Warning: Could not find @botpress/sdk from @botpress/runtime location (${runtimePath})`);
+    return;
+  }
+  const targetBotpressDir = path27.join(botDir, "node_modules", "@botpress");
+  await fs12.mkdir(targetBotpressDir, { recursive: true });
+  const symlinkType = process.platform === "win32" ? "junction" : undefined;
+  await fs12.symlink(sdkPath, targetSdkPath, symlinkType);
+}
+
+// src/bot-generator/dev-id-manager.ts
+import path28 from "path";
+import fs13 from "fs/promises";
+import { existsSync as existsSync4 } from "fs";
 import { Client as Client12 } from "@botpress/client";
 class DevIdManager {
   projectPath;
@@ -7529,7 +7570,7 @@ class DevIdManager {
   constructor(projectPath, botProjectPath) {
     this.projectPath = projectPath;
     this.botProjectPath = botProjectPath;
-    this.projectCachePath = path27.join(botProjectPath, ".botpress", "project.cache.json");
+    this.projectCachePath = path28.join(botProjectPath, ".botpress", "project.cache.json");
   }
   async getClient() {
     if (!this.client) {
@@ -7555,8 +7596,8 @@ class DevIdManager {
   }
   async readProjectCache() {
     try {
-      if (existsSync3(this.projectCachePath)) {
-        const content = await fs12.readFile(this.projectCachePath, "utf-8");
+      if (existsSync4(this.projectCachePath)) {
+        const content = await fs13.readFile(this.projectCachePath, "utf-8");
         return JSON.parse(content);
       }
     } catch (error) {
@@ -7566,8 +7607,8 @@ class DevIdManager {
   }
   async saveProjectCache(cache2) {
     try {
-      await fs12.mkdir(path27.dirname(this.projectCachePath), { recursive: true });
-      await fs12.writeFile(this.projectCachePath, JSON.stringify(cache2, null, 2));
+      await fs13.mkdir(path28.dirname(this.projectCachePath), { recursive: true });
+      await fs13.writeFile(this.projectCachePath, JSON.stringify(cache2, null, 2));
     } catch (error) {
       console.error("Error saving project.cache.json:", error);
     }
@@ -7615,9 +7656,9 @@ class DevIdManager {
 }
 
 // src/bot-generator/integration-sync.ts
-import path28 from "path";
-import fs13 from "fs/promises";
-import { existsSync as existsSync4 } from "fs";
+import path29 from "path";
+import fs14 from "fs/promises";
+import { existsSync as existsSync5 } from "fs";
 class IntegrationSync {
   projectPath;
   botProjectPath;
@@ -7625,7 +7666,7 @@ class IntegrationSync {
   constructor(projectPath, botProjectPath) {
     this.projectPath = projectPath;
     this.botProjectPath = botProjectPath;
-    this.bpModulesPath = path28.join(botProjectPath, "bp_modules");
+    this.bpModulesPath = path29.join(botProjectPath, "bp_modules");
   }
   async parseIntegrations() {
     const project = await AgentProject.load(this.projectPath);
@@ -7656,16 +7697,16 @@ class IntegrationSync {
     return integrations;
   }
   async isIntegrationSynced(integration) {
-    const targetFolder = path28.join(this.bpModulesPath, `integration_${integration.alias}`);
-    if (!existsSync4(targetFolder)) {
+    const targetFolder = path29.join(this.bpModulesPath, `integration_${integration.alias}`);
+    if (!existsSync5(targetFolder)) {
       return false;
     }
     try {
-      const indexPath = path28.join(targetFolder, "index.ts");
-      if (!existsSync4(indexPath)) {
+      const indexPath = path29.join(targetFolder, "index.ts");
+      if (!existsSync5(indexPath)) {
         return false;
       }
-      const indexContent = await fs13.readFile(indexPath, "utf-8");
+      const indexContent = await fs14.readFile(indexPath, "utf-8");
       const versionMatch = indexContent.match(/version:\s*["']([^"']+)["']/);
       if (!versionMatch) {
         return false;
@@ -7693,20 +7734,20 @@ class IntegrationSync {
     await command.output();
   }
   async renameIntegrationFolder(integration) {
-    const sourceFolder = path28.join(this.bpModulesPath, integration.name.replace("/", "-"));
-    const targetFolder = path28.join(this.bpModulesPath, `integration_${integration.alias}`);
-    if (!existsSync4(sourceFolder)) {
+    const sourceFolder = path29.join(this.bpModulesPath, integration.name.replace("/", "-"));
+    const targetFolder = path29.join(this.bpModulesPath, `integration_${integration.alias}`);
+    if (!existsSync5(sourceFolder)) {
       throw new Error(`Integration folder not found: ${sourceFolder}`);
     }
-    if (existsSync4(targetFolder)) {
-      await fs13.rm(targetFolder, { recursive: true, force: true });
+    if (existsSync5(targetFolder)) {
+      await fs14.rm(targetFolder, { recursive: true, force: true });
     }
-    await fs13.rename(sourceFolder, targetFolder);
+    await fs14.rename(sourceFolder, targetFolder);
   }
   async removeIntegrationFolder(alias) {
-    const targetFolder = path28.join(this.bpModulesPath, `integration_${alias}`);
-    if (existsSync4(targetFolder)) {
-      await fs13.rm(targetFolder, { recursive: true, force: true });
+    const targetFolder = path29.join(this.bpModulesPath, `integration_${alias}`);
+    if (existsSync5(targetFolder)) {
+      await fs14.rm(targetFolder, { recursive: true, force: true });
     }
   }
   async syncIntegrations() {
@@ -7716,7 +7757,7 @@ class IntegrationSync {
     if (integrations.length === 0) {
       return { synced, errors };
     }
-    await fs13.mkdir(this.bpModulesPath, { recursive: true });
+    await fs14.mkdir(this.bpModulesPath, { recursive: true });
     for (const integration of integrations) {
       try {
         const isAlreadySynced = await this.isIntegrationSynced(integration);
@@ -7738,9 +7779,9 @@ class IntegrationSync {
 }
 
 // src/bot-generator/interface-sync.ts
-import path29 from "path";
-import fs14 from "fs/promises";
-import { existsSync as existsSync5 } from "fs";
+import path30 from "path";
+import fs15 from "fs/promises";
+import { existsSync as existsSync6 } from "fs";
 init_constants();
 class InterfaceSync {
   projectPath;
@@ -7749,7 +7790,7 @@ class InterfaceSync {
   constructor(projectPath, botProjectPath) {
     this.projectPath = projectPath;
     this.botProjectPath = botProjectPath;
-    this.bpModulesPath = path29.join(botProjectPath, "bp_modules");
+    this.bpModulesPath = path30.join(botProjectPath, "bp_modules");
   }
   async parseInterfaces() {
     const interfaces = [];
@@ -7767,16 +7808,16 @@ class InterfaceSync {
     return interfaces;
   }
   async isInterfaceSynced(interfaceInfo) {
-    const targetFolder = path29.join(this.bpModulesPath, `interface_${pascalCase(interfaceInfo.alias)}`);
-    if (!existsSync5(targetFolder)) {
+    const targetFolder = path30.join(this.bpModulesPath, `interface_${pascalCase(interfaceInfo.alias)}`);
+    if (!existsSync6(targetFolder)) {
       return false;
     }
     try {
-      const indexPath = path29.join(targetFolder, "index.ts");
-      if (!existsSync5(indexPath)) {
+      const indexPath = path30.join(targetFolder, "index.ts");
+      if (!existsSync6(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;
@@ -7818,20 +7859,20 @@ class InterfaceSync {
     });
   }
   async renameInterfaceFolder(interfaceInfo) {
-    const sourceFolder = path29.join(this.bpModulesPath, interfaceInfo.name);
-    const targetFolder = path29.join(this.bpModulesPath, `interface_${pascalCase(interfaceInfo.alias)}`);
-    if (!existsSync5(sourceFolder)) {
+    const sourceFolder = path30.join(this.bpModulesPath, interfaceInfo.name);
+    const targetFolder = path30.join(this.bpModulesPath, `interface_${pascalCase(interfaceInfo.alias)}`);
+    if (!existsSync6(sourceFolder)) {
       throw new Error(`Interface folder not found: ${sourceFolder}`);
     }
-    if (existsSync5(targetFolder)) {
-      await fs14.rm(targetFolder, { recursive: true, force: true });
+    if (existsSync6(targetFolder)) {
+      await fs15.rm(targetFolder, { recursive: true, force: true });
     }
-    await fs14.rename(sourceFolder, targetFolder);
+    await fs15.rename(sourceFolder, targetFolder);
   }
   async removeInterfaceFolder(alias) {
-    const targetFolder = path29.join(this.bpModulesPath, `interface_${pascalCase(alias)}`);
-    if (existsSync5(targetFolder)) {
-      await fs14.rm(targetFolder, { recursive: true, force: true });
+    const targetFolder = path30.join(this.bpModulesPath, `interface_${pascalCase(alias)}`);
+    if (existsSync6(targetFolder)) {
+      await fs15.rm(targetFolder, { recursive: true, force: true });
     }
   }
   async syncInterfaces() {
@@ -7841,7 +7882,7 @@ class InterfaceSync {
     if (interfaces.length === 0) {
       return { synced, errors };
     }
-    await fs14.mkdir(this.bpModulesPath, { recursive: true });
+    await fs15.mkdir(this.bpModulesPath, { recursive: true });
     for (const interfaceInfo of interfaces) {
       try {
         const isAlreadySynced = await this.isInterfaceSynced(interfaceInfo);
@@ -7874,26 +7915,26 @@ function isBuiltinAction(name) {
   return !!Object.values(BuiltInActions2).find((x) => x.name === name);
 }
 function getImportPath(from, to) {
-  return path32.relative(path32.dirname(from), to).replace(/\.ts$/, "").replace(/\\/g, "/");
+  return path33.relative(path33.dirname(from), to).replace(/\.ts$/, "").replace(/\\/g, "/");
 }
 
 class BotGenerator {
   projectPath;
   outputPath;
   constructor(options) {
-    this.projectPath = path32.resolve(options.projectPath);
-    this.outputPath = path32.resolve(options.outputPath || path32.join(this.projectPath, ".adk"));
+    this.projectPath = path33.resolve(options.projectPath);
+    this.outputPath = path33.resolve(options.outputPath || path33.join(this.projectPath, ".adk"));
   }
   async listFilesRecursive(rootDir) {
     try {
-      if (!existsSync6(rootDir))
+      if (!existsSync7(rootDir))
         return [];
       const result = [];
       const walk = async (dir, relativeBase) => {
-        const entries = await fs15.readdir(dir, { withFileTypes: true });
+        const entries = await fs16.readdir(dir, { withFileTypes: true });
         for (const entry of entries) {
-          const abs = path32.join(dir, entry.name);
-          const rel = path32.join(relativeBase, entry.name);
+          const abs = path33.join(dir, entry.name);
+          const rel = path33.join(relativeBase, entry.name);
           if (entry.isDirectory()) {
             await walk(abs, rel);
           } else {
@@ -7908,20 +7949,20 @@ class BotGenerator {
     }
   }
   async removeEmptyDirectories(rootDir) {
-    if (!existsSync6(rootDir))
+    if (!existsSync7(rootDir))
       return;
     const removeIfEmpty = async (dir) => {
-      const entries = await fs15.readdir(dir, { withFileTypes: true });
+      const entries = await fs16.readdir(dir, { withFileTypes: true });
       for (const entry of entries) {
         if (entry.isDirectory()) {
-          const subdir = path32.join(dir, entry.name);
+          const subdir = path33.join(dir, entry.name);
           await removeIfEmpty(subdir);
         }
       }
-      const after = await fs15.readdir(dir);
+      const after = await fs16.readdir(dir);
       if (after.length === 0 && dir !== rootDir) {
         try {
-          await fs15.rmdir(dir, { recursive: false });
+          await fs16.rmdir(dir, { recursive: false });
         } catch {}
       }
     };
@@ -7929,7 +7970,7 @@ class BotGenerator {
   }
   async generate() {
     const project = await AgentProject.load(this.projectPath);
-    await fs15.mkdir(this.outputPath, { recursive: true });
+    await fs16.mkdir(this.outputPath, { recursive: true });
     await this.generateBotDefinition();
     await this.generateIntegrationsDefinition();
     await this.generateInterfacesDefinition();
@@ -7958,19 +7999,19 @@ class BotGenerator {
       workspaceId: project.agentInfo?.workspaceId
     });
     const integrations = await manager3.loadIntegrations(project.dependencies || {});
-    const integrationsDir = path32.join(this.projectPath, ".adk", "integrations");
+    const integrationsDir = path33.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 = `./${path32.join("integrations", types6.names.paths.index).replace(/\\/g, "/")}`;
+        const importPath = `./${path33.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 = path32.join(this.projectPath, ".adk", "integrations", filePath);
-          const dir = path32.dirname(fullPath);
-          await fs15.mkdir(dir, { recursive: true });
+          const fullPath = path33.join(this.projectPath, ".adk", "integrations", filePath);
+          const dir = path33.dirname(fullPath);
+          await fs16.mkdir(dir, { recursive: true });
           await createFile(fullPath, content);
           files.add(filePath);
         }
@@ -7990,13 +8031,13 @@ class BotGenerator {
         };
       }
       `;
-    await createFile(path32.join(this.projectPath, ".adk", "integrations-types.d.ts"), await formatCode(types5));
+    await createFile(path33.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 = path32.join(integrationsDir, rel);
+        const abs = path33.join(integrationsDir, rel);
         try {
-          await fs15.rm(abs, { force: true });
+          await fs16.rm(abs, { force: true });
         } catch {}
       }
     }
@@ -8063,7 +8104,7 @@ class BotGenerator {
     let botStateType = "{}";
     let userStateType = "{}";
     try {
-      const configPath = path32.join(project.path, "agent.config.ts");
+      const configPath = path33.join(project.path, "agent.config.ts");
       const configModule = await import(`${configPath}?t=${Date.now()}`);
       const config = configModule.default;
       if (config?.bot?.state) {
@@ -8099,7 +8140,7 @@ declare module "@botpress/runtime/_types/state" {
   export type UserState = ${userStateType};
 }
 `;
-    await createFile(path32.join(this.projectPath, ".adk", "runtime.d.ts"), await formatCode(types5));
+    await createFile(path33.join(this.projectPath, ".adk", "runtime.d.ts"), await formatCode(types5));
   }
   async generateInterfacesTypes() {
     const project = await AgentProject.load(this.projectPath);
@@ -8107,7 +8148,7 @@ declare module "@botpress/runtime/_types/state" {
       workspaceId: project.agentInfo?.workspaceId
     });
     const manager3 = new InterfaceManager;
-    const interfacesDir = path32.join(this.projectPath, ".adk", "interfaces");
+    const interfacesDir = path33.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 integrations = await integrationManager.loadIntegrations(project.dependencies || {}).then((result) => result.integrations.filter((int) => int.enabled && int.definition).map((x) => x.definition));
@@ -8116,12 +8157,12 @@ declare module "@botpress/runtime/_types/state" {
     let files = new Set;
     for (const int of interfaces) {
       const types6 = await generateInterfaceTypes(int, integrations);
-      imports.add(`import { ${types6.names.typings.index} } from "./${path32.join("interfaces", types6.names.paths.index).replace(/\\/g, "/")}";`);
+      imports.add(`import { ${types6.names.typings.index} } from "./${path33.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 = path32.join(this.projectPath, ".adk", "interfaces", filePath);
-        const dir = path32.dirname(fullPath);
-        await fs15.mkdir(dir, { recursive: true });
+        const fullPath = path33.join(this.projectPath, ".adk", "interfaces", filePath);
+        const dir = path33.dirname(fullPath);
+        await fs16.mkdir(dir, { recursive: true });
         await createFile(fullPath, content);
         files.add(filePath);
       }
@@ -8157,14 +8198,14 @@ declare module "@botpress/runtime/_types/state" {
 `)}
       };
       `;
-    await createFile(path32.join(this.projectPath, ".adk", "interfaces.d.ts"), await formatCode(types5));
-    await createFile(path32.join(this.projectPath, ".adk", "interfaces.ts"), await formatCode(consts));
+    await createFile(path33.join(this.projectPath, ".adk", "interfaces.d.ts"), await formatCode(types5));
+    await createFile(path33.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 = path32.join(interfacesDir, rel);
+        const abs = path33.join(interfacesDir, rel);
         try {
-          await fs15.rm(abs, { force: true });
+          await fs16.rm(abs, { force: true });
         } catch {}
       }
     }
@@ -8195,7 +8236,7 @@ declare module "@botpress/runtime/_types/state" {
 `) : ""}
       } as Record<string, IntegrationPackage>;
     `;
-    await createFile(path32.join(this.outputPath, "src", "integrations.ts"), content);
+    await createFile(path33.join(this.outputPath, "src", "integrations.ts"), content);
   }
   async generateInterfacesDefinition() {
     const interfaces = BUILTIN_INTERFACES;
@@ -8218,7 +8259,7 @@ declare module "@botpress/runtime/_types/state" {
 `) : ""}
       } as Record<string, InterfacePackage>;
     `;
-    await createFile(path32.join(this.outputPath, "src", "interfaces.ts"), await formatCode(content));
+    await createFile(path33.join(this.outputPath, "src", "interfaces.ts"), await formatCode(content));
   }
   async generateBotDefinition() {
     const project = await AgentProject.load(this.projectPath);
@@ -8273,7 +8314,7 @@ declare module "@botpress/runtime/_types/state" {
         if (isBuiltinWorkflow2(workflow.definition.name)) {
           continue;
         }
-        const workflowPath = path32.join(project.path, workflow.path);
+        const workflowPath = path33.join(project.path, workflow.path);
         const workflowModule = await import(`${workflowPath}?t=${Date.now()}`);
         const workflowInstance = workflowModule.default || workflowModule[workflow.export];
         if (workflowInstance) {
@@ -8511,7 +8552,7 @@ configuration: {
     const fullContent = content + integrationsSection + `
 
 export default bot;`;
-    await createFile(path32.join(this.outputPath, "bot.definition.ts"), await formatCode(fullContent));
+    await createFile(path33.join(this.outputPath, "bot.definition.ts"), await formatCode(fullContent));
   }
   async generateBotIndex() {
     const content = dedent`
@@ -8545,7 +8586,7 @@ export default bot;`;
 
       export default bot
     `;
-    await createFile(path32.join(this.outputPath, "src", "index.ts"), await formatCode(content));
+    await createFile(path33.join(this.outputPath, "src", "index.ts"), await formatCode(content));
   }
   async generatePackageJson(project) {
     const packageJson = {
@@ -8559,7 +8600,7 @@ export default bot;`;
         typescript: "^5.9.3"
       }
     };
-    await createFile(path32.join(this.outputPath, "package.json"), JSON.stringify(packageJson, null, 2));
+    await createFile(path33.join(this.outputPath, "package.json"), JSON.stringify(packageJson, null, 2));
   }
   async generateTsConfig() {
     const tsConfig = {
@@ -8590,7 +8631,7 @@ export default bot;`;
       },
       include: [".botpress/**/*", "src/**/*", "bp_modules/**/*", "./*.ts", "./*.json", "../*.d.ts"]
     };
-    await createFile(path32.join(this.outputPath, "tsconfig.json"), JSON.stringify(tsConfig, null, 2));
+    await createFile(path33.join(this.outputPath, "tsconfig.json"), JSON.stringify(tsConfig, null, 2));
   }
   async generateGlobalTypes() {
     const content = dedent`
@@ -8613,42 +8654,42 @@ export default bot;`;
 
       export {};
     `;
-    await createFile(path32.join(this.outputPath, "global.d.ts"), await formatCode(content));
+    await createFile(path33.join(this.outputPath, "global.d.ts"), await formatCode(content));
   }
   async copyAssets() {
-    const assetsPath = path32.join(this.projectPath, "assets");
-    const targetPath = path32.join(this.outputPath, "assets");
-    if (existsSync6(assetsPath)) {
-      await fs15.mkdir(targetPath, { recursive: true });
+    const assetsPath = path33.join(this.projectPath, "assets");
+    const targetPath = path33.join(this.outputPath, "assets");
+    if (existsSync7(assetsPath)) {
+      await fs16.mkdir(targetPath, { recursive: true });
       await this.copyDirectory(assetsPath, targetPath);
     }
   }
   async copyDirectory(src, dest) {
-    const entries = await fs15.readdir(src, { withFileTypes: true });
+    const entries = await fs16.readdir(src, { withFileTypes: true });
     for (const entry of entries) {
-      const srcPath = path32.join(src, entry.name);
-      const destPath = path32.join(dest, entry.name);
+      const srcPath = path33.join(src, entry.name);
+      const destPath = path33.join(dest, entry.name);
       if (entry.isDirectory()) {
-        await fs15.mkdir(destPath, { recursive: true });
+        await fs16.mkdir(destPath, { recursive: true });
         await this.copyDirectory(srcPath, destPath);
       } else {
-        await fs15.copyFile(srcPath, destPath);
+        await fs16.copyFile(srcPath, destPath);
       }
     }
   }
   async generateAdkRuntime() {
     const project = new AgentProject(this.projectPath);
     await project.reload();
-    const srcDir = path32.join(this.outputPath, "src");
+    const srcDir = path33.join(this.outputPath, "src");
     {
-      const dest = path32.join(srcDir, "conversations.ts");
+      const dest = path33.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, path32.join(project.path, conversation.path));
+          const importPath = getImportPath(dest, path33.join(project.path, conversation.path));
           imports.set(conversation.path, {
             name,
             statement: `import * as ${name} from "${importPath}";`
@@ -8674,14 +8715,14 @@ export default bot;`;
       await createFile(dest, await formatCode(content2));
     }
     {
-      const dest = path32.join(srcDir, "knowledge.ts");
+      const dest = path33.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, path32.join(project.path, knowledge.path));
+          const importPath = getImportPath(dest, path33.join(project.path, knowledge.path));
           imports.set(knowledge.path, {
             name,
             statement: `import * as ${name} from "${importPath}";`
@@ -8707,7 +8748,7 @@ export default bot;`;
       await createFile(dest, await formatCode(content2));
     }
     {
-      const dest = path32.join(srcDir, "triggers.ts");
+      const dest = path33.join(srcDir, "triggers.ts");
       const { transforms: transforms4 } = await import("@botpress/sdk");
       const imports = new Map;
       const exports = new Set;
@@ -8716,7 +8757,7 @@ export default bot;`;
       for (const trigger of project.triggers) {
         if (!imports.has(trigger.path)) {
           const name = `triggers_${index++}`;
-          const importPath = getImportPath(dest, path32.join(project.path, trigger.path));
+          const importPath = getImportPath(dest, path33.join(project.path, trigger.path));
           imports.set(trigger.path, {
             name,
             statement: `import * as ${name} from "${importPath}";`
@@ -8726,7 +8767,7 @@ export default bot;`;
       }
       for (const trigger of project.triggers) {
         try {
-          const absolutePath = path32.join(project.path, trigger.path);
+          const absolutePath = path33.join(project.path, trigger.path);
           const triggerModule = await import(`${absolutePath}?t=${Date.now()}`);
           const triggerInstance = triggerModule[trigger.export] || triggerModule.default;
           if (triggerInstance && triggerInstance.payload) {
@@ -8769,7 +8810,7 @@ export default bot;`;
       await createFile(dest, await formatCode(content2));
     }
     {
-      const dest = path32.join(srcDir, "workflows.ts");
+      const dest = path33.join(srcDir, "workflows.ts");
       const imports = new Map;
       const exports = new Set;
       let index = 1;
@@ -8779,7 +8820,7 @@ export default bot;`;
         }
         if (!imports.has(workflow.path)) {
           const name = `workflows_${index++}`;
-          const importPath = getImportPath(dest, path32.join(project.path, workflow.path));
+          const importPath = getImportPath(dest, path33.join(project.path, workflow.path));
           const statement = `import * as ${name} from "${importPath}";`;
           imports.set(workflow.path, {
             name,
@@ -8813,7 +8854,7 @@ export default bot;`;
       await createFile(dest, await formatCode(content2));
     }
     {
-      const dest = path32.join(srcDir, "actions.ts");
+      const dest = path33.join(srcDir, "actions.ts");
       const imports = new Map;
       const exports = new Set;
       let index = 1;
@@ -8823,7 +8864,7 @@ export default bot;`;
         }
         if (!imports.has(action.path)) {
           const name = `actions_${index++}`;
-          const importPath = getImportPath(dest, path32.join(project.path, action.path));
+          const importPath = getImportPath(dest, path33.join(project.path, action.path));
           imports.set(action.path, {
             name,
             statement: `import * as ${name} from "${importPath}";`
@@ -8849,14 +8890,14 @@ export default bot;`;
       await createFile(dest, await formatCode(content2));
     }
     {
-      const dest = path32.join(srcDir, "tables.ts");
+      const dest = path33.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, path32.join(project.path, table.path));
+          const importPath = getImportPath(dest, path33.join(project.path, table.path));
           imports.set(table.path, {
             name,
             statement: `import * as ${name} from "${importPath}";`
@@ -8882,8 +8923,8 @@ export default bot;`;
       await createFile(dest, await formatCode(content2));
     }
     {
-      const dest = path32.join(srcDir, "config.ts");
-      const importPath = getImportPath(dest, path32.join(project.path, "agent.config.ts"));
+      const dest = path33.join(srcDir, "config.ts");
+      const importPath = getImportPath(dest, path33.join(project.path, "agent.config.ts"));
       const content2 = `
       ////////////////////////////////////////////////////////
       // DO NOT EDIT THIS FILE DIRECTLY
@@ -8949,13 +8990,13 @@ export default bot;`;
         handlers.actions.setup(bot);
       }
     `;
-    await createFile(path32.join(this.outputPath, "src", "adk-runtime.ts"), await formatCode(content));
+    await createFile(path33.join(this.outputPath, "src", "adk-runtime.ts"), await formatCode(content));
   }
   async copyAssetsRuntime() {
-    const assetsRuntimePath = path32.join(this.projectPath, ".adk", "assets-runtime.ts");
-    if (existsSync6(assetsRuntimePath)) {
-      const content = await fs15.readFile(assetsRuntimePath, "utf-8");
-      await createFile(path32.join(this.outputPath, "src", "assets-runtime.ts"), await formatCode(content));
+    const assetsRuntimePath = path33.join(this.projectPath, ".adk", "assets-runtime.ts");
+    if (existsSync7(assetsRuntimePath)) {
+      const content = await fs16.readFile(assetsRuntimePath, "utf-8");
+      await createFile(path33.join(this.outputPath, "src", "assets-runtime.ts"), await formatCode(content));
     }
   }
 }
@@ -8964,9 +9005,11 @@ async function generateBotProject(options) {
   await generator.generate();
   await generator.generateAdkRuntime();
   await generator.copyAssetsRuntime();
-  const devIdManager = new DevIdManager(options.projectPath, options.outputPath || path32.join(options.projectPath, ".adk", "bot"));
+  const botPath = options.outputPath || path33.join(options.projectPath, ".adk", "bot");
+  await linkSdk(options.projectPath, botPath);
+  const devIdManager = new DevIdManager(options.projectPath, options.outputPath || path33.join(options.projectPath, ".adk", "bot"));
   await devIdManager.restoreDevId();
-  const integrationSync = new IntegrationSync(options.projectPath, options.outputPath || path32.join(options.projectPath, ".adk", "bot"));
+  const integrationSync = new IntegrationSync(options.projectPath, options.outputPath || path33.join(options.projectPath, ".adk", "bot"));
   const integrationSyncResult = await integrationSync.syncIntegrations();
   if (integrationSyncResult.errors.length > 0) {
     console.warn(`⚠️  Some integrations failed to sync:`);
@@ -8974,7 +9017,7 @@ async function generateBotProject(options) {
       console.warn(`  - ${alias}: ${error}`);
     });
   }
-  const interfaceSync = new InterfaceSync(options.projectPath, options.outputPath || path32.join(options.projectPath, ".adk", "bot"));
+  const interfaceSync = new InterfaceSync(options.projectPath, options.outputPath || path33.join(options.projectPath, ".adk", "bot"));
   const interfaceSyncResult = await interfaceSync.syncInterfaces();
   if (interfaceSyncResult.errors.length > 0) {
     console.warn(`⚠️  Some interfaces failed to sync:`);
@@ -9483,8 +9526,8 @@ class TableManager {
 }
 // src/knowledge/manager.ts
 import crypto4 from "crypto";
-import path33 from "path";
-import fs16 from "fs/promises";
+import path34 from "path";
+import fs17 from "fs/promises";
 import { glob } from "glob";
 import { Client as Client14 } from "@botpress/client";
 import { DataSource } from "@botpress/runtime";
@@ -9933,15 +9976,15 @@ class KnowledgeManager {
   }
   async scanLocalFileHashes(directoryPath, filterFn) {
     const projectDir = this.project.path;
-    const directory = path33.resolve(projectDir, directoryPath);
+    const directory = path34.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 = path33.relative(directory, file);
-      const content = await fs16.readFile(file);
+      const relPath = path34.relative(directory, file);
+      const content = await fs17.readFile(file);
       hashes[relPath] = crypto4.createHash("sha256").update(content).digest("hex");
     }
     this.fileHashCache.set(directory, hashes);
@@ -10048,7 +10091,7 @@ class KnowledgeManager {
   }
   async syncDirectorySource(client, kbName, kbId, dsId, directoryPath, filterFn, force) {
     const projectDir = this.project.path;
-    const directory = path33.resolve(projectDir, directoryPath);
+    const directory = path34.resolve(projectDir, directoryPath);
     if (!directory.startsWith(projectDir)) {
       throw new Error("Directory path must be within the agent's directory");
     }
@@ -10070,8 +10113,8 @@ class KnowledgeManager {
       return true;
     }).map((f) => ({
       abs: f,
-      rel: path33.relative(directory, f),
-      name: path33.basename(f)
+      rel: path34.relative(directory, f),
+      name: path34.basename(f)
     }));
     console.log(`  Found ${allFiles.length} files in ${directoryPath}`);
     const cachedHashes = await this.scanLocalFileHashes(directoryPath, filterFn);
@@ -10145,7 +10188,7 @@ class KnowledgeManager {
   }
   async upsertFile(client, local, dsId, tags, force, cachedHash) {
     const key = `data_source://document/${dsId}/${local.rel}`;
-    const content = await fs16.readFile(local.abs);
+    const content = await fs17.readFile(local.abs);
     const hash = cachedHash ?? crypto4.createHash("sha256").update(content).digest("hex");
     try {
       const { file } = await client.getFile({ id: key });
@@ -10153,7 +10196,7 @@ class KnowledgeManager {
         return null;
       }
     } catch {}
-    const title = path33.basename(local.name, path33.extname(local.name));
+    const title = path34.basename(local.name, path34.extname(local.name));
     const metadata = {
       hash,
       dsId,
@@ -10281,7 +10324,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 existsSync7 } from "fs";
+import { existsSync as existsSync8 } from "fs";
 
 class FileWatcher2 extends EventEmitter3 {
   projectPath;
@@ -10299,12 +10342,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 (existsSync7(filePath)) {
+      if (existsSync8(filePath)) {
         this.watchFile(filePath);
       }
     }
     const srcPath = join8(this.projectPath, "src");
-    if (existsSync7(srcPath)) {
+    if (existsSync8(srcPath)) {
       this.initializeDirectoryState(srcPath);
       this.watchDirectory(srcPath);
     }
@@ -10353,7 +10396,7 @@ class FileWatcher2 extends EventEmitter3 {
     }
   }
   handleFileChange(filePath) {
-    const fileExists = existsSync7(filePath);
+    const fileExists = existsSync8(filePath);
     const previousState = this.fileStates.get(filePath);
     let changeType;
     if (!fileExists && previousState !== undefined) {
@@ -10393,7 +10436,7 @@ class FileWatcher2 extends EventEmitter3 {
     this.emit("change", event);
   }
   updateFileState(filePath) {
-    if (existsSync7(filePath)) {
+    if (existsSync8(filePath)) {
       this.fileStates.set(filePath, Date.now());
     }
   }
@@ -10418,7 +10461,7 @@ class FileWatcher2 extends EventEmitter3 {
 }
 // src/preflight/checker.ts
 import { Client as Client15 } from "@botpress/client";
-import path34 from "path";
+import path35 from "path";
 
 // src/preflight/types.ts
 function hasIntegrationChanges(integrations) {
@@ -10780,16 +10823,16 @@ class PreflightChecker {
     options?.onProgress?.("Regenerating bot project...");
     await generateBotProject({
       projectPath: this.projectPath,
-      outputPath: path34.join(this.projectPath, ".adk", "bot")
+      outputPath: path35.join(this.projectPath, ".adk", "bot")
     });
     options?.onSuccess?.("Bot project regenerated");
   }
 }
 // src/runner/script-runner.ts
 import dedent2 from "dedent";
-import { existsSync as existsSync8 } from "fs";
-import fs17 from "fs/promises";
-import path35 from "path";
+import { existsSync as existsSync9 } from "fs";
+import fs18 from "fs/promises";
+import path36 from "path";
 import { spawn } from "child_process";
 init_utils();
 class ScriptRunner {
@@ -10798,7 +10841,7 @@ class ScriptRunner {
   prod;
   credentials;
   constructor(options) {
-    this.projectPath = path35.resolve(options.projectPath);
+    this.projectPath = path36.resolve(options.projectPath);
     this.forceRegenerate = options.forceRegenerate ?? false;
     this.prod = options.prod ?? false;
     this.credentials = options.credentials;
@@ -10807,10 +10850,10 @@ class ScriptRunner {
     const project = await AgentProject.load(this.projectPath, {
       adkCommand: "adk-build"
     });
-    const botPath = path35.join(this.projectPath, ".adk", "bot");
-    const runnerPath = path35.join(botPath, "src", "script-runner.ts");
-    const botpressTypesPath = path35.join(botPath, ".botpress", "implementation", "index.ts");
-    const needsRegenerate = this.forceRegenerate || !existsSync8(runnerPath) || !existsSync8(botpressTypesPath);
+    const botPath = path36.join(this.projectPath, ".adk", "bot");
+    const runnerPath = path36.join(botPath, "src", "script-runner.ts");
+    const botpressTypesPath = path36.join(botPath, ".botpress", "implementation", "index.ts");
+    const needsRegenerate = this.forceRegenerate || !existsSync9(runnerPath) || !existsSync9(botpressTypesPath);
     if (needsRegenerate) {
       try {
         await generateAssetsTypes(project.path);
@@ -10894,12 +10937,12 @@ class ScriptRunner {
 
       runScript()
     `;
-    await fs17.writeFile(path35.join(botPath, "src", "script-runner.ts"), await formatCode(content), "utf-8");
+    await fs18.writeFile(path36.join(botPath, "src", "script-runner.ts"), await formatCode(content), "utf-8");
   }
   async run(scriptPath, options = {}) {
     const { botPath, runnerPath, project } = await this.prepare();
-    const absoluteScriptPath = path35.isAbsolute(scriptPath) ? scriptPath : path35.resolve(this.projectPath, scriptPath);
-    if (!existsSync8(absoluteScriptPath)) {
+    const absoluteScriptPath = path36.isAbsolute(scriptPath) ? scriptPath : path36.resolve(this.projectPath, scriptPath);
+    if (!existsSync9(absoluteScriptPath)) {
       throw new Error(`Script not found: ${absoluteScriptPath}`);
     }
     const botId = this.prod ? project.agentInfo?.botId : project.agentInfo?.devId || project.agentInfo?.botId;
@@ -11010,5 +11053,5 @@ export {
   AgentProject
 };
 
-//# debugId=4A3ECF72EBA6C21464756E2164756E21
+//# debugId=1A3563A12165E75864756E2164756E21
 //# sourceMappingURL=index.js.map