@botpress/adk 1.2.3 → 1.2.5

package/dist/index.js

@@ -241,7 +241,7 @@ var exports_action_types = {};
 __export(exports_action_types, {
   generateActionTypes: () => generateActionTypes
 });
-import path26 from "path";
+import path27 from "path";
 async function generateActionTypes(project) {
   const actionDefs = [];
   for (const action of project.actions) {
@@ -249,7 +249,7 @@ async function generateActionTypes(project) {
       continue;
     }
     try {
-      const absolutePath = path26.join(project.path, action.path);
+      const absolutePath = path27.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) {
@@ -294,7 +294,7 @@ ${actionDefs.join(`
   };
 }
 `;
-  const actionTypesPath = path26.join(project.path, ".adk", "action-types.d.ts");
+  const actionTypesPath = path27.join(project.path, ".adk", "action-types.d.ts");
   await createFile(actionTypesPath, await formatCode(content));
 }
 var init_action_types = __esm(() => {
@@ -307,7 +307,7 @@ var exports_integration_action_types = {};
 __export(exports_integration_action_types, {
   generateIntegrationActionTypes: () => generateIntegrationActionTypes
 });
-import path27 from "path";
+import path28 from "path";
 async function generateIntegrationActionTypes(project) {
   const content = `
 ////////////////////////////////////////////////////////
@@ -317,6 +317,8 @@ async function generateIntegrationActionTypes(project) {
 // Generated at: ${new Date().toISOString()}
 ////////////////////////////////////////////////////////
 
+type Integrations = import("@botpress/runtime/_types/integrations").Integrations;
+
 declare module "@botpress/runtime/_types/integration-actions" {
 
 export interface CallableAction<I, O> {
@@ -339,7 +341,7 @@ type IntegrationsMap<T> = {
 export type IntegrationActions = IntegrationsMap<Integrations>;
 }
 `;
-  const integrationActionTypesPath = path27.join(project.path, ".adk", "integration-action-types.d.ts");
+  const integrationActionTypesPath = path28.join(project.path, ".adk", "integration-action-types.d.ts");
   await createFile(integrationActionTypesPath, await formatCode(content));
 }
 var init_integration_action_types = __esm(() => {
@@ -4136,6 +4138,15 @@ class AgentProject {
       console.warn(`Failed to register data source workflows for ${kbPath}:`, error);
     }
   }
+  getChannelsList(channelSpec) {
+    if (channelSpec === "*") {
+      return ["*"];
+    } else if (Array.isArray(channelSpec)) {
+      return channelSpec;
+    } else {
+      return [channelSpec];
+    }
+  }
   async loadAgentPrimitives() {
     if (this._options.adkCommand) {
       setAdkCommand(this._options.adkCommand);
@@ -4201,13 +4212,17 @@ class AgentProject {
               throw error;
             }
             if (Primitives2.Definitions.isConversationDefinition(definition)) {
-              const existing = this._conversations.find((p) => p.definition.channel === definition.channel);
-              if (existing) {
+              const overlapping = this._conversations.find((p) => {
+                const existingChannels = this.getChannelsList(p.definition.channel);
+                const newChannels = this.getChannelsList(definition.channel);
+                return existingChannels.some((ch) => newChannels.includes(ch));
+              });
+              if (overlapping) {
                 this._warnings.push({
                   $type: "ValidationError",
                   code: "DUPLICATE_PRIMITIVE" /* DUPLICATE_PRIMITIVE */,
                   severity: "warning" /* WARNING */,
-                  message: `Duplicate conversation definition found: ${filename} -> ${key} (already defined in ${existing.path} -> ${existing.export})`,
+                  message: `Overlapping conversation channels found: ${filename} -> ${key} overlaps with ${overlapping.path} -> ${overlapping.export}`,
                   file: relPath
                 });
                 continue;
@@ -4961,7 +4976,7 @@ Description: ${tag?.description}`);
 import dedent from "dedent";
 import { existsSync as existsSync5 } from "fs";
 import fs15 from "fs/promises";
-import path28 from "path";
+import path29 from "path";
 
 // src/generators/interface-types.ts
 import { transforms as transforms2 } from "@botpress/sdk";
@@ -5297,7 +5312,6 @@ async function generateWorkflowTypes(project) {
       const workflowModule = await import(`${workflowPath}?t=${Date.now()}`);
       const workflowInstance = workflowModule[workflowRef.export] || workflowModule.default;
       if (!workflowInstance) {
-        console.warn(`No default export found in workflow file: ${workflowRef.path}`);
         continue;
       }
       const inputType = workflowInstance.inputSchema ? workflowInstance.inputSchema.toTypescriptType?.() || "any" : "{}";
@@ -5342,10 +5356,78 @@ ${typeDefinitions || "    // No workflows defined yet"}
   await createFile(workflowTypesPath, await formatCode(content));
 }
 
-// src/generators/event-types.ts
+// src/generators/conversation-types.ts
 init_utils();
 init_fs();
 import path22 from "path";
+async function generateConversationTypes(project) {
+  const conversationTypes = {};
+  for (const conversationRef of project.conversations) {
+    console.log(`[ConversationTypes] Processing conversation: ${conversationRef.export}`);
+    try {
+      const conversationPath = path22.join(project.path, conversationRef.path);
+      const conversationModule = await import(`${conversationPath}?t=${Date.now()}`);
+      const conversationInstance = conversationModule[conversationRef.export] || conversationModule.default;
+      if (!conversationInstance) {
+        continue;
+      }
+      const channel = conversationInstance.channel;
+      const stateType = conversationInstance.schema ? conversationInstance.schema.toTypescriptType?.() || "any" : "{}";
+      let channels;
+      if (channel === "*") {
+        channels = ["*"];
+      } else if (Array.isArray(channel)) {
+        channels = channel;
+      } else {
+        channels = [channel];
+      }
+      for (const ch of channels) {
+        conversationTypes[ch] = {
+          channel: ch,
+          state: stateType
+        };
+      }
+    } catch (error) {
+      console.error(`Failed to process conversation ${conversationRef.export}:`, error);
+    }
+  }
+  const channelDefinitions = Object.entries(conversationTypes).filter(([channel]) => channel !== "*").map(([channel, info]) => {
+    const [integration, channelName] = channel.split(".");
+    return `    "${channel}": {
+      channel: "${channel}";
+      integration: "${integration}";
+      state: ${info.state};
+      tags: Integrations["${integration}"]["channels"]["${channelName}"]["conversation"]["tags"];
+      messageTags: Integrations["${integration}"]["channels"]["${channelName}"]["message"]["tags"];
+      messages: Integrations["${integration}"]["channels"]["${channelName}"]["messages"];
+      events: Integrations["${integration}"]["events"];
+    };`;
+  }).join(`
+`);
+  const content = `
+////////////////////////////////////////////////////////
+// DO NOT EDIT THIS FILE DIRECTLY
+// This file is auto-generated from the Botpress ADK
+// ADK Version: ${ADK_VERSION}
+// Generated at: ${new Date().toISOString()}
+////////////////////////////////////////////////////////
+
+type Integrations = import("@botpress/runtime/_types/integrations").Integrations;
+
+declare module "@botpress/runtime/_types/conversations" {
+  export type ConversationDefinitions = {
+${channelDefinitions || "    // No conversations defined yet"}
+  };
+}
+`;
+  const conversationTypesPath = path22.join(project.path, ".adk", "conversation-types.d.ts");
+  await createFile(conversationTypesPath, await formatCode(content));
+}
+
+// src/generators/event-types.ts
+init_utils();
+init_fs();
+import path23 from "path";
 async function generateEventTypes(project) {
   const integrationEvents = [];
   for (const int of project.integrations) {
@@ -5361,6 +5443,8 @@ async function generateEventTypes(project) {
 // Generated at: ${new Date().toISOString()}
 ////////////////////////////////////////////////////////
 
+type Integrations = import("@botpress/runtime/_types/integrations").Integrations;
+
 declare module "@botpress/runtime/_types/events" {
   /**
    * Global Events type that includes all integration events.
@@ -5382,7 +5466,7 @@ ${integrationEvents.join(`
   export type EventPayload<T extends EventName> = Events[T];
 }
 `;
-  const eventTypesPath = path22.join(project.path, ".adk", "event-types.d.ts");
+  const eventTypesPath = path23.join(project.path, ".adk", "event-types.d.ts");
   await createFile(eventTypesPath, await formatCode(content));
 }
 
@@ -5390,7 +5474,7 @@ ${integrationEvents.join(`
 init_fs();
 
 // src/bot-generator/dev-id-manager.ts
-import path23 from "path";
+import path24 from "path";
 import fs12 from "fs/promises";
 import { existsSync as existsSync2 } from "fs";
 import { Client as Client9 } from "@botpress/client";
@@ -5402,7 +5486,7 @@ class DevIdManager {
   constructor(projectPath, botProjectPath) {
     this.projectPath = projectPath;
     this.botProjectPath = botProjectPath;
-    this.projectCachePath = path23.join(botProjectPath, ".botpress", "project.cache.json");
+    this.projectCachePath = path24.join(botProjectPath, ".botpress", "project.cache.json");
   }
   async getClient() {
     if (!this.client) {
@@ -5436,7 +5520,7 @@ class DevIdManager {
   }
   async saveProjectCache(cache2) {
     try {
-      await fs12.mkdir(path23.dirname(this.projectCachePath), { recursive: true });
+      await fs12.mkdir(path24.dirname(this.projectCachePath), { recursive: true });
       await fs12.writeFile(this.projectCachePath, JSON.stringify(cache2, null, 2));
     } catch (error) {
       console.error("Error saving project.cache.json:", error);
@@ -5490,7 +5574,7 @@ class DevIdManager {
 }
 
 // src/bot-generator/integration-sync.ts
-import path24 from "path";
+import path25 from "path";
 import fs13 from "fs/promises";
 import { existsSync as existsSync3 } from "fs";
 class IntegrationSync {
@@ -5500,7 +5584,7 @@ class IntegrationSync {
   constructor(projectPath, botProjectPath) {
     this.projectPath = projectPath;
     this.botProjectPath = botProjectPath;
-    this.bpModulesPath = path24.join(botProjectPath, "bp_modules");
+    this.bpModulesPath = path25.join(botProjectPath, "bp_modules");
   }
   async parseIntegrations() {
     const project = await AgentProject.load(this.projectPath);
@@ -5531,12 +5615,12 @@ class IntegrationSync {
     return integrations;
   }
   async isIntegrationSynced(integration) {
-    const targetFolder = path24.join(this.bpModulesPath, `integration_${integration.alias}`);
+    const targetFolder = path25.join(this.bpModulesPath, `integration_${integration.alias}`);
     if (!existsSync3(targetFolder)) {
       return false;
     }
     try {
-      const indexPath = path24.join(targetFolder, "index.ts");
+      const indexPath = path25.join(targetFolder, "index.ts");
       if (!existsSync3(indexPath)) {
         return false;
       }
@@ -5569,8 +5653,8 @@ class IntegrationSync {
   }
   async renameIntegrationFolder(integration) {
     console.log(integration.name, integration.alias);
-    const sourceFolder = path24.join(this.bpModulesPath, integration.name.replace("/", "-"));
-    const targetFolder = path24.join(this.bpModulesPath, `integration_${integration.alias}`);
+    const sourceFolder = path25.join(this.bpModulesPath, integration.name.replace("/", "-"));
+    const targetFolder = path25.join(this.bpModulesPath, `integration_${integration.alias}`);
     if (!existsSync3(sourceFolder)) {
       throw new Error(`Integration folder not found: ${sourceFolder}`);
     }
@@ -5580,7 +5664,7 @@ class IntegrationSync {
     await fs13.rename(sourceFolder, targetFolder);
   }
   async removeIntegrationFolder(alias) {
-    const targetFolder = path24.join(this.bpModulesPath, `integration_${alias}`);
+    const targetFolder = path25.join(this.bpModulesPath, `integration_${alias}`);
     if (existsSync3(targetFolder)) {
       await fs13.rm(targetFolder, { recursive: true, force: true });
     }
@@ -5614,7 +5698,7 @@ class IntegrationSync {
 }
 
 // src/bot-generator/interface-sync.ts
-import path25 from "path";
+import path26 from "path";
 import fs14 from "fs/promises";
 import { existsSync as existsSync4 } from "fs";
 import { spawn } from "child_process";
@@ -5625,7 +5709,7 @@ class InterfaceSync {
   constructor(projectPath, botProjectPath) {
     this.projectPath = projectPath;
     this.botProjectPath = botProjectPath;
-    this.bpModulesPath = path25.join(botProjectPath, "bp_modules");
+    this.bpModulesPath = path26.join(botProjectPath, "bp_modules");
   }
   async parseInterfaces() {
     const interfaces = [];
@@ -5643,12 +5727,12 @@ class InterfaceSync {
     return interfaces;
   }
   async isInterfaceSynced(interfaceInfo) {
-    const targetFolder = path25.join(this.bpModulesPath, `interface_${pascalCase(interfaceInfo.alias)}`);
+    const targetFolder = path26.join(this.bpModulesPath, `interface_${pascalCase(interfaceInfo.alias)}`);
     if (!existsSync4(targetFolder)) {
       return false;
     }
     try {
-      const indexPath = path25.join(targetFolder, "index.ts");
+      const indexPath = path26.join(targetFolder, "index.ts");
       if (!existsSync4(indexPath)) {
         return false;
       }
@@ -5711,8 +5795,8 @@ class InterfaceSync {
     });
   }
   async renameInterfaceFolder(interfaceInfo) {
-    const sourceFolder = path25.join(this.bpModulesPath, interfaceInfo.name);
-    const targetFolder = path25.join(this.bpModulesPath, `interface_${pascalCase(interfaceInfo.alias)}`);
+    const sourceFolder = path26.join(this.bpModulesPath, interfaceInfo.name);
+    const targetFolder = path26.join(this.bpModulesPath, `interface_${pascalCase(interfaceInfo.alias)}`);
     if (!existsSync4(sourceFolder)) {
       throw new Error(`Interface folder not found: ${sourceFolder}`);
     }
@@ -5722,7 +5806,7 @@ class InterfaceSync {
     await fs14.rename(sourceFolder, targetFolder);
   }
   async removeInterfaceFolder(alias) {
-    const targetFolder = path25.join(this.bpModulesPath, `interface_${pascalCase(alias)}`);
+    const targetFolder = path26.join(this.bpModulesPath, `interface_${pascalCase(alias)}`);
     if (existsSync4(targetFolder)) {
       await fs14.rm(targetFolder, { recursive: true, force: true });
     }
@@ -5770,8 +5854,8 @@ class BotGenerator {
   projectPath;
   outputPath;
   constructor(options) {
-    this.projectPath = path28.resolve(options.projectPath);
-    this.outputPath = path28.resolve(options.outputPath || path28.join(this.projectPath, ".adk"));
+    this.projectPath = path29.resolve(options.projectPath);
+    this.outputPath = path29.resolve(options.outputPath || path29.join(this.projectPath, ".adk"));
   }
   async listFilesRecursive(rootDir) {
     try {
@@ -5781,8 +5865,8 @@ class BotGenerator {
       const walk = async (dir, relativeBase) => {
         const entries = await fs15.readdir(dir, { withFileTypes: true });
         for (const entry of entries) {
-          const abs = path28.join(dir, entry.name);
-          const rel = path28.join(relativeBase, entry.name);
+          const abs = path29.join(dir, entry.name);
+          const rel = path29.join(relativeBase, entry.name);
           if (entry.isDirectory()) {
             await walk(abs, rel);
           } else {
@@ -5803,7 +5887,7 @@ class BotGenerator {
       const entries = await fs15.readdir(dir, { withFileTypes: true });
       for (const entry of entries) {
         if (entry.isDirectory()) {
-          const subdir = path28.join(dir, entry.name);
+          const subdir = path29.join(dir, entry.name);
           await removeIfEmpty(subdir);
         }
       }
@@ -5828,6 +5912,7 @@ class BotGenerator {
     await this.generateTriggerTypes();
     await this.generateStateTypes();
     await this.generateWorkflowTypes();
+    await this.generateConversationTypes();
     await this.generateActionTypes();
     await this.generateEventTypes();
     await this.generateIntegrationActionTypes();
@@ -5842,19 +5927,18 @@ class BotGenerator {
     const project = await AgentProject.load(this.projectPath);
     const manager2 = new IntegrationManager;
     const integrations = await manager2.loadIntegrations(project.dependencies || {});
-    const integrationsDir = path28.join(this.projectPath, ".adk", "integrations");
+    const integrationsDir = path29.join(this.projectPath, ".adk", "integrations");
     const existingIntegrationFiles = await this.listFilesRecursive(integrationsDir);
-    let imports = new Set;
     let aliases = new Set;
     let files = new Set;
     for (const integration of integrations.integrations) {
       if (integration.enabled && integration.definition) {
         const types6 = await generateIntegrationTypes(integration);
-        imports.add(`import { ${types6.names.typings.index} } from "./${path28.join("integrations", types6.names.paths.index)}";`);
-        aliases.add(`"${integration.alias}": ${types6.names.typings.index}`);
+        const importPath = `./${path29.join("integrations", types6.names.paths.index)}`;
+        aliases.add(`"${integration.alias}": import("${importPath}").${types6.names.typings.index}`);
         for (const [filePath, content] of Object.entries(types6.files)) {
-          const fullPath = path28.join(this.projectPath, ".adk", "integrations", filePath);
-          const dir = path28.dirname(fullPath);
+          const fullPath = path29.join(this.projectPath, ".adk", "integrations", filePath);
+          const dir = path29.dirname(fullPath);
           await fs15.mkdir(dir, { recursive: true });
           await createFile(fullPath, content);
           files.add(filePath);
@@ -5868,20 +5952,17 @@ class BotGenerator {
       // File: integrations.ts
       ////////////////////////////////////////////////////////
 
-      ${Array.from(imports).join(`
-`)}
-
-      declare global {
+      declare module "@botpress/runtime/_types/integrations" {
         export type Integrations = {
           ${Array.from(aliases).join(`, `)}
         };
       }
       `;
-    await createFile(path28.join(this.projectPath, ".adk", "integrations.d.ts"), await formatCode(types5));
+    await createFile(path29.join(this.projectPath, ".adk", "integrations.d.ts"), await formatCode(types5));
     const staleIntegrationFiles = existingIntegrationFiles.filter((f) => !files.has(f));
     if (staleIntegrationFiles.length > 0) {
       for (const rel of staleIntegrationFiles) {
-        const abs = path28.join(integrationsDir, rel);
+        const abs = path29.join(integrationsDir, rel);
         try {
           await fs15.rm(abs, { force: true });
         } catch {}
@@ -5909,6 +5990,10 @@ class BotGenerator {
     const project = await AgentProject.load(this.projectPath);
     await generateWorkflowTypes(project);
   }
+  async generateConversationTypes() {
+    const project = await AgentProject.load(this.projectPath);
+    await generateConversationTypes(project);
+  }
   async generateActionTypes() {
     const project = await AgentProject.load(this.projectPath);
     const { generateActionTypes: generateActionTypes2 } = await Promise.resolve().then(() => (init_action_types(), exports_action_types));
@@ -5921,10 +6006,22 @@ class BotGenerator {
   }
   async generateRuntimeTypes() {
     const project = await AgentProject.load(this.projectPath);
+    const manager2 = new IntegrationManager;
+    const integrations = await manager2.loadIntegrations(project.dependencies || {});
+    const channels = [];
+    for (const integration of integrations.integrations) {
+      if (integration.enabled && integration.definition) {
+        const alias = integration.alias;
+        for (const channelName of Object.keys(integration.definition.channels || {})) {
+          channels.push(`"${alias}.${channelName}"`);
+        }
+      }
+    }
+    const channelsType = channels.length > 0 ? channels.join(" | ") : "never";
     let botStateType = "{}";
     let userStateType = "{}";
     try {
-      const configPath = path28.join(project.path, "agent.config.ts");
+      const configPath = path29.join(project.path, "agent.config.ts");
       const configModule = await import(`${configPath}?t=${Date.now()}`);
       const config = configModule.default;
       if (config?.bot?.state) {
@@ -5950,38 +6047,23 @@ class BotGenerator {
 // Generated at: ${new Date().toISOString()}
 ////////////////////////////////////////////////////////
 
-import { Primitives, ZuiType } from "@botpress/runtime";
-
-declare module "@botpress/runtime" {
-  export type Channels = {
-    [K in keyof Integrations]: {
-      [C in keyof Integrations[K]["channels"]]: C extends string
-        ? \`\${K}.\${C}\`
-        : never;
-    }[keyof Integrations[K]["channels"]];
-  }[keyof Integrations];
-
-  export class Conversation<
-    T extends Channels = Channels,
-    Schema extends ZuiType = ZuiType,
-  > extends Primitives.BaseConversation<Integrations, T, Schema> {}
-
+declare module "@botpress/runtime/_types/channels" {
+  export type Channels = ${channelsType};
+  export type ChannelSpec = Channels | readonly Channels[] | '*';
 }
 
 declare module "@botpress/runtime/_types/state" {
   export type BotState = ${botStateType};
   export type UserState = ${userStateType};
 }
-
-export {};
 `;
-    await createFile(path28.join(this.projectPath, ".adk", "runtime.d.ts"), await formatCode(types5));
+    await createFile(path29.join(this.projectPath, ".adk", "runtime.d.ts"), await formatCode(types5));
   }
   async generateInterfacesTypes() {
     const project = await AgentProject.load(this.projectPath);
     const integrationManager = new IntegrationManager;
     const manager2 = new InterfaceManager;
-    const interfacesDir = path28.join(this.projectPath, ".adk", "interfaces");
+    const interfacesDir = path29.join(this.projectPath, ".adk", "interfaces");
     const existingInterfaceFiles = await this.listFilesRecursive(interfacesDir);
     const interfaces = await manager2.loadInterfaces(project.dependencies || {}).then((result) => result.interfaces.filter((int) => int.definition).map((x) => x.definition));
     const integrations = await integrationManager.loadIntegrations(project.dependencies || {}).then((result) => result.integrations.filter((int) => int.enabled && int.definition).map((x) => x.definition));
@@ -5990,11 +6072,11 @@ export {};
     let files = new Set;
     for (const int of interfaces) {
       const types6 = await generateInterfaceTypes(int, integrations);
-      imports.add(`import { ${types6.names.typings.index} } from "./${path28.join("interfaces", types6.names.paths.index)}";`);
+      imports.add(`import { ${types6.names.typings.index} } from "./${path29.join("interfaces", types6.names.paths.index)}";`);
       aliases.add(`"${types6.names.name}": ${types6.names.typings.index}`);
       for (const [filePath, content] of Object.entries(types6.files)) {
-        const fullPath = path28.join(this.projectPath, ".adk", "interfaces", filePath);
-        const dir = path28.dirname(fullPath);
+        const fullPath = path29.join(this.projectPath, ".adk", "interfaces", filePath);
+        const dir = path29.dirname(fullPath);
         await fs15.mkdir(dir, { recursive: true });
         await createFile(fullPath, content);
         files.add(filePath);
@@ -6031,12 +6113,12 @@ export {};
 `)}
       };
       `;
-    await createFile(path28.join(this.projectPath, ".adk", "interfaces.d.ts"), await formatCode(types5));
-    await createFile(path28.join(this.projectPath, ".adk", "interfaces.ts"), await formatCode(consts));
+    await createFile(path29.join(this.projectPath, ".adk", "interfaces.d.ts"), await formatCode(types5));
+    await createFile(path29.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 = path28.join(interfacesDir, rel);
+        const abs = path29.join(interfacesDir, rel);
         try {
           await fs15.rm(abs, { force: true });
         } catch {}
@@ -6065,7 +6147,7 @@ export {};
 `) : ""}
       } as Record<string, IntegrationPackage>;
     `;
-    await createFile(path28.join(this.outputPath, "src", "integrations.ts"), content);
+    await createFile(path29.join(this.outputPath, "src", "integrations.ts"), content);
   }
   async generateInterfacesDefinition() {
     const interfaces = BUILTIN_INTERFACES;
@@ -6088,7 +6170,7 @@ export {};
 `) : ""}
       } as Record<string, InterfacePackage>;
     `;
-    await createFile(path28.join(this.outputPath, "src", "interfaces.ts"), await formatCode(content));
+    await createFile(path29.join(this.outputPath, "src", "interfaces.ts"), await formatCode(content));
   }
   async generateBotDefinition() {
     const project = await AgentProject.load(this.projectPath);
@@ -6122,7 +6204,7 @@ export {};
         if (isBuiltinWorkflow2(workflow.definition.name)) {
           continue;
         }
-        const workflowPath = path28.join(project.path, workflow.path);
+        const workflowPath = path29.join(project.path, workflow.path);
         const workflowModule = await import(`${workflowPath}?t=${Date.now()}`);
         const workflowInstance = workflowModule.default || workflowModule[workflow.export];
         if (workflowInstance) {
@@ -6181,6 +6263,7 @@ export {};
     const content = dedent`
       import { BotDefinition, z } from "@botpress/sdk";
       import {
+      BUILT_IN_STATES,
       TranscriptSchema,
       TrackedStateSchema,
       WorkflowCallbackEvent,
@@ -6274,7 +6357,7 @@ export {};
            * This is defined by the users at build-time when they define conversations.
            * Because each conversation can have its own state schema, we use \`z.any()\`
           */
-          state: {
+          [BUILT_IN_STATES.conversation]: {
             type: "conversation",
             schema: TrackedStateSchema,
           },
@@ -6282,7 +6365,7 @@ export {};
           /**
            * Bot-wide global state that persists across all conversations
            */
-          botState: {
+          [BUILT_IN_STATES.bot]: {
             type: "bot",
             schema: TrackedStateSchema,
           },
@@ -6290,7 +6373,7 @@ export {};
           /**
            * User-specific state that persists across conversations for each user
            */
-          userState: {
+          [BUILT_IN_STATES.user]: {
             type: "user",
             schema: TrackedStateSchema,
           },
@@ -6298,7 +6381,7 @@ export {};
           /**
            * Workflow-specific state that persists across workflow executions
            */
-          workflowState: {
+          [BUILT_IN_STATES.workflowState]: {
             type: "workflow",
             schema: TrackedStateSchema,
           },
@@ -6306,7 +6389,7 @@ export {};
           /**
            * Workflow cached steps executions
            */
-          workflowSteps: {
+          [BUILT_IN_STATES.workflowSteps]: {
             type: "workflow",
             schema: TrackedStateSchema,
           },
@@ -6320,7 +6403,7 @@ export {};
 
       export default bot;
     `;
-    await createFile(path28.join(this.outputPath, "bot.definition.ts"), await formatCode(content));
+    await createFile(path29.join(this.outputPath, "bot.definition.ts"), await formatCode(content));
   }
   async generateBotIndex() {
     const project = await AgentProject.load(this.projectPath);
@@ -6348,22 +6431,22 @@ export {};
 
       if (isWorkerMode() && isMainThread) {
         // Branch 1: Main thread in worker mode - initialize parent with pool
-        console.log("[Main] Initializing parent worker with pool...");
+        if (process.env.BP_DEBUG) console.log("[Main] Initializing parent worker with pool...");
         initializeParentWorker(bot);
       } else if (isWorkerMode() && process.env.IS_DEV_WORKER === "true") {
         // Branch 2: Worker thread - run child worker
-        console.log("[Worker] Initializing child worker...");
+        if (process.env.BP_DEBUG) console.log("[Worker] Initializing child worker...");
         runWorker(bot);
         setupAdkRuntime(bot);
       } else {
         // Branch 3: Worker mode disabled - single-thread mode
-        console.log("[Bot] Running in single-thread mode");
+        if (process.env.BP_DEBUG) console.log("[Bot] Running in single-thread mode");
         setupAdkRuntime(bot);
       }
 
       export default bot
     `;
-    await createFile(path28.join(this.outputPath, "src", "index.ts"), await formatCode(content));
+    await createFile(path29.join(this.outputPath, "src", "index.ts"), await formatCode(content));
   }
   async generatePackageJson(project) {
     const packageJson = {
@@ -6382,7 +6465,7 @@ export {};
         typescript: "^5.6.3"
       }
     };
-    await createFile(path28.join(this.outputPath, "package.json"), JSON.stringify(packageJson, null, 2));
+    await createFile(path29.join(this.outputPath, "package.json"), JSON.stringify(packageJson, null, 2));
   }
   async generateTsConfig() {
     const tsConfig = {
@@ -6419,7 +6502,7 @@ export {};
         "./*.json"
       ]
     };
-    await createFile(path28.join(this.outputPath, "tsconfig.json"), JSON.stringify(tsConfig, null, 2));
+    await createFile(path29.join(this.outputPath, "tsconfig.json"), JSON.stringify(tsConfig, null, 2));
   }
   async generateGlobalTypes() {
     const content = dedent`
@@ -6442,11 +6525,11 @@ export {};
 
       export {};
     `;
-    await createFile(path28.join(this.outputPath, "global.d.ts"), await formatCode(content));
+    await createFile(path29.join(this.outputPath, "global.d.ts"), await formatCode(content));
   }
   async copyAssets() {
-    const assetsPath = path28.join(this.projectPath, "assets");
-    const targetPath = path28.join(this.outputPath, "assets");
+    const assetsPath = path29.join(this.projectPath, "assets");
+    const targetPath = path29.join(this.outputPath, "assets");
     if (existsSync5(assetsPath)) {
       await fs15.mkdir(targetPath, { recursive: true });
       await this.copyDirectory(assetsPath, targetPath);
@@ -6455,8 +6538,8 @@ export {};
   async copyDirectory(src, dest) {
     const entries = await fs15.readdir(src, { withFileTypes: true });
     for (const entry of entries) {
-      const srcPath = path28.join(src, entry.name);
-      const destPath = path28.join(dest, entry.name);
+      const srcPath = path29.join(src, entry.name);
+      const destPath = path29.join(dest, entry.name);
       if (entry.isDirectory()) {
         await fs15.mkdir(destPath, { recursive: true });
         await this.copyDirectory(srcPath, destPath);
@@ -6468,16 +6551,16 @@ export {};
   async generateAdkRuntime() {
     const project = new AgentProject(this.projectPath);
     await project.reload();
-    const srcDir = path28.join(this.outputPath, "src");
+    const srcDir = path29.join(this.outputPath, "src");
     {
-      const dest = path28.join(srcDir, "conversations.ts");
+      const dest = path29.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 = path28.relative(path28.dirname(dest), path28.join(project.path, conversation.path)).replace(/\.ts$/, "");
+          const importPath = path29.relative(path29.dirname(dest), path29.join(project.path, conversation.path)).replace(/\.ts$/, "");
           imports.set(conversation.path, {
             name,
             statement: `import * as ${name} from "${importPath}";`
@@ -6503,14 +6586,14 @@ export {};
       await createFile(dest, await formatCode(content2));
     }
     {
-      const dest = path28.join(srcDir, "knowledge.ts");
+      const dest = path29.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 = path28.relative(path28.dirname(dest), path28.join(project.path, knowledge.path)).replace(/\.ts$/, "");
+          const importPath = path29.relative(path29.dirname(dest), path29.join(project.path, knowledge.path)).replace(/\.ts$/, "");
           imports.set(knowledge.path, {
             name,
             statement: `import * as ${name} from "${importPath}";`
@@ -6536,7 +6619,7 @@ export {};
       await createFile(dest, await formatCode(content2));
     }
     {
-      const dest = path28.join(srcDir, "triggers.ts");
+      const dest = path29.join(srcDir, "triggers.ts");
       const { transforms: transforms4 } = await import("@botpress/sdk");
       const imports = new Map;
       const exports = new Set;
@@ -6545,7 +6628,7 @@ export {};
       for (const trigger of project.triggers) {
         if (!imports.has(trigger.path)) {
           const name = `triggers_${index++}`;
-          const importPath = path28.relative(path28.dirname(dest), path28.join(project.path, trigger.path)).replace(/\.ts$/, "");
+          const importPath = path29.relative(path29.dirname(dest), path29.join(project.path, trigger.path)).replace(/\.ts$/, "");
           imports.set(trigger.path, {
             name,
             statement: `import * as ${name} from "${importPath}";`
@@ -6555,7 +6638,7 @@ export {};
       }
       for (const trigger of project.triggers) {
         try {
-          const absolutePath = path28.join(project.path, trigger.path);
+          const absolutePath = path29.join(project.path, trigger.path);
           const triggerModule = await import(`${absolutePath}?t=${Date.now()}`);
           const triggerInstance = triggerModule[trigger.export] || triggerModule.default;
           if (triggerInstance && triggerInstance.payload) {
@@ -6598,7 +6681,7 @@ export {};
       await createFile(dest, await formatCode(content2));
     }
     {
-      const dest = path28.join(srcDir, "workflows.ts");
+      const dest = path29.join(srcDir, "workflows.ts");
       const imports = new Map;
       const exports = new Set;
       let index = 1;
@@ -6608,7 +6691,7 @@ export {};
         }
         if (!imports.has(workflow.path)) {
           const name = `workflows_${index++}`;
-          const importPath = path28.relative(path28.dirname(dest), path28.join(project.path, workflow.path)).replace(/\.ts$/, "");
+          const importPath = path29.relative(path29.dirname(dest), path29.join(project.path, workflow.path)).replace(/\.ts$/, "");
           const statement = `import * as ${name} from "${importPath}";`;
           imports.set(workflow.path, {
             name,
@@ -6642,14 +6725,14 @@ export {};
       await createFile(dest, await formatCode(content2));
     }
     {
-      const dest = path28.join(srcDir, "actions.ts");
+      const dest = path29.join(srcDir, "actions.ts");
       const imports = new Map;
       const exports = new Set;
       let index = 1;
       for (const action of project.actions) {
         if (!imports.has(action.path)) {
           const name = `actions_${index++}`;
-          const importPath = path28.relative(path28.dirname(dest), path28.join(project.path, action.path)).replace(/\.ts$/, "");
+          const importPath = path29.relative(path29.dirname(dest), path29.join(project.path, action.path)).replace(/\.ts$/, "");
           imports.set(action.path, {
             name,
             statement: `import * as ${name} from "${importPath}";`
@@ -6675,14 +6758,14 @@ export {};
       await createFile(dest, await formatCode(content2));
     }
     {
-      const dest = path28.join(srcDir, "tables.ts");
+      const dest = path29.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 = path28.relative(path28.dirname(dest), path28.join(project.path, table.path)).replace(/\.ts$/, "");
+          const importPath = path29.relative(path29.dirname(dest), path29.join(project.path, table.path)).replace(/\.ts$/, "");
           imports.set(table.path, {
             name,
             statement: `import * as ${name} from "${importPath}";`
@@ -6708,8 +6791,8 @@ export {};
       await createFile(dest, await formatCode(content2));
     }
     {
-      const dest = path28.join(srcDir, "config.ts");
-      const importPath = path28.relative(path28.dirname(dest), path28.join(project.path, "agent.config.ts")).replace(/\.ts$/, "");
+      const dest = path29.join(srcDir, "config.ts");
+      const importPath = path29.relative(path29.dirname(dest), path29.join(project.path, "agent.config.ts")).replace(/\.ts$/, "");
       const content2 = `
       ////////////////////////////////////////////////////////
       // DO NOT EDIT THIS FILE DIRECTLY
@@ -6774,13 +6857,13 @@ export {};
         handlers.workflow.setup(bot);
       }
     `;
-    await createFile(path28.join(this.outputPath, "src", "adk-runtime.ts"), await formatCode(content));
+    await createFile(path29.join(this.outputPath, "src", "adk-runtime.ts"), await formatCode(content));
   }
   async copyAssetsRuntime() {
-    const assetsRuntimePath = path28.join(this.projectPath, ".adk", "assets-runtime.ts");
+    const assetsRuntimePath = path29.join(this.projectPath, ".adk", "assets-runtime.ts");
     if (existsSync5(assetsRuntimePath)) {
       const content = await fs15.readFile(assetsRuntimePath, "utf-8");
-      await createFile(path28.join(this.outputPath, "src", "assets-runtime.ts"), await formatCode(content));
+      await createFile(path29.join(this.outputPath, "src", "assets-runtime.ts"), await formatCode(content));
     }
   }
 }
@@ -6789,9 +6872,9 @@ async function generateBotProject(options) {
   await generator.generate();
   await generator.generateAdkRuntime();
   await generator.copyAssetsRuntime();
-  const devIdManager = new DevIdManager(options.projectPath, options.outputPath || path28.join(options.projectPath, ".adk", "bot"));
+  const devIdManager = new DevIdManager(options.projectPath, options.outputPath || path29.join(options.projectPath, ".adk", "bot"));
   await devIdManager.restoreDevId();
-  const integrationSync = new IntegrationSync(options.projectPath, options.outputPath || path28.join(options.projectPath, ".adk", "bot"));
+  const integrationSync = new IntegrationSync(options.projectPath, options.outputPath || path29.join(options.projectPath, ".adk", "bot"));
   const integrationSyncResult = await integrationSync.syncIntegrations();
   if (integrationSyncResult.errors.length > 0) {
     console.warn(`⚠️  Some integrations failed to sync:`);
@@ -6799,7 +6882,7 @@ async function generateBotProject(options) {
       console.warn(`  - ${alias}: ${error}`);
     });
   }
-  const interfaceSync = new InterfaceSync(options.projectPath, options.outputPath || path28.join(options.projectPath, ".adk", "bot"));
+  const interfaceSync = new InterfaceSync(options.projectPath, options.outputPath || path29.join(options.projectPath, ".adk", "bot"));
   const interfaceSyncResult = await interfaceSync.syncInterfaces();
   if (interfaceSyncResult.errors.length > 0) {
     console.warn(`⚠️  Some interfaces failed to sync:`);
@@ -7194,5 +7277,5 @@ export {
   AgentProject
 };
 
-//# debugId=CEE7EB582E73320264756E2164756E21
+//# debugId=457481A453B1622564756E2164756E21
 //# sourceMappingURL=index.js.map