@botpress/adk 1.13.19 → 1.14.1

package/dist/index.js

@@ -1,20 +1,5 @@
 import { createRequire } from "node:module";
-var __create = Object.create;
-var __getProtoOf = Object.getPrototypeOf;
 var __defProp = Object.defineProperty;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __toESM = (mod, isNodeMode, target) => {
-  target = mod != null ? __create(__getProtoOf(mod)) : {};
-  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
-  for (let key of __getOwnPropNames(mod))
-    if (!__hasOwnProp.call(to, key))
-      __defProp(to, key, {
-        get: () => mod[key],
-        enumerable: true
-      });
-  return to;
-};
 var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
 var __export = (target, all) => {
   for (var name in all)
@@ -666,7 +651,7 @@ var PRETTIER_CONFIG, formatCode = async (code, filepath) => {
 `));
     return code;
   }
-}, ADK_VERSION = "1.13.19", relative2 = (from, to) => {
+}, ADK_VERSION = "1.14.1", relative2 = (from, to) => {
   const fromDir = path10.dirname(from);
   const relative3 = path10.relative(fromDir, to);
   return relative3.startsWith(".") ? relative3 : `./${relative3}`;
@@ -690,7 +675,7 @@ var exports_action_types = {};
 __export(exports_action_types, {
   generateActionTypes: () => generateActionTypes
 });
-import path31 from "path";
+import path32 from "path";
 async function generateActionTypes(project) {
   const actionDefs = [];
   for (const action of project.actions) {
@@ -705,7 +690,7 @@ async function generateActionTypes(project) {
     };`);
         continue;
       }
-      const absolutePath = path31.join(project.path, action.path);
+      const absolutePath = path32.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) {
@@ -750,7 +735,7 @@ ${actionDefs.join(`
   };
 }
 `;
-  const actionTypesPath = path31.join(project.path, ".adk", "action-types.d.ts");
+  const actionTypesPath = path32.join(project.path, ".adk", "action-types.d.ts");
   await createFile(actionTypesPath, await formatCode(content));
 }
 var init_action_types = __esm(() => {
@@ -763,7 +748,7 @@ var exports_integration_action_types = {};
 __export(exports_integration_action_types, {
   generateIntegrationActionTypes: () => generateIntegrationActionTypes
 });
-import path32 from "path";
+import path33 from "path";
 async function generateIntegrationActionTypes(project) {
   const content = `
 ////////////////////////////////////////////////////////
@@ -797,7 +782,7 @@ type IntegrationsMap<T> = {
 export type IntegrationActions = IntegrationsMap<Integrations>;
 }
 `;
-  const integrationActionTypesPath = path32.join(project.path, ".adk", "integration-action-types.d.ts");
+  const integrationActionTypesPath = path33.join(project.path, ".adk", "integration-action-types.d.ts");
   await createFile(integrationActionTypesPath, await formatCode(content));
 }
 var init_integration_action_types = __esm(() => {
@@ -809,7 +794,7 @@ var init_integration_action_types = __esm(() => {
 var require_package = __commonJS((exports, module) => {
   module.exports = {
     name: "@botpress/adk",
-    version: "1.13.19",
+    version: "1.14.1",
     description: "Core ADK library for building AI agents on Botpress",
     type: "module",
     main: "dist/index.js",
@@ -856,7 +841,7 @@ var require_package = __commonJS((exports, module) => {
       "@botpress/cli": "^5.2.0",
       "@botpress/client": "^1.28.0",
       "@botpress/cognitive": "^0.3.3",
-      "@botpress/runtime": "^1.13.19",
+      "@botpress/runtime": "^1.14.1",
       "@botpress/sdk": "^5.1.0",
       "@bpinternal/jex": "^1.2.4",
       "@bpinternal/yargs-extra": "^0.0.21",
@@ -3455,9 +3440,9 @@ function configsMatch(current, desired, schemaDefaults = {}) {
     return JSON.stringify(currentValue) === JSON.stringify(desiredValue);
   });
 }
-async function fetchServerIntegrationConfigs(project) {
+async function fetchServerIntegrationConfigs(project, targetBotId) {
   const { devId, botId } = project.agentInfo ?? {};
-  const targetId = devId || botId;
+  const targetId = targetBotId || devId || botId;
   if (!targetId) {
     return { configs: {}, fetched: false, skipped: true };
   }
@@ -3472,6 +3457,9 @@ async function fetchServerIntegrationConfigs(project) {
     try {
       return await fetchBotConfigs(client, targetId);
     } catch (err) {
+      if (targetBotId) {
+        throw err;
+      }
       if (devId && botId && devId !== botId) {
         return await fetchBotConfigs(client, botId);
       }
@@ -6405,7 +6393,7 @@ class AgentProjectGenerator {
         deploy: "adk deploy"
       },
       dependencies: {
-        "@botpress/runtime": `^${"1.13.19"}`
+        "@botpress/runtime": `^${"1.14.1"}`
       },
       devDependencies: {
         typescript: "^5.9.3"
@@ -7015,16 +7003,419 @@ Description: ${tag?.description}`);
     }
   };
 }
+// src/generators/client-wrapper.ts
+init_utils();
+init_fs();
+import path18 from "path";
+import crypto3 from "crypto";
+import { readFile as readFile3 } from "fs/promises";
+import { BuiltInWorkflows as BuiltInWorkflows2 } from "@botpress/runtime/internal";
+function isBuiltinWorkflow(name) {
+  return !!Object.values(BuiltInWorkflows2).find((x) => x.name === name);
+}
+async function generateClientWrapper(project) {
+  const actionTypes = [];
+  for (const action of project.actions) {
+    if (action.definition.attributes?.visibility === "hidden") {
+      continue;
+    }
+    if (action.path === "<adk:builtin>") {
+      actionTypes.push({
+        name: action.definition.name,
+        path: "",
+        export: "",
+        isBuiltin: true
+      });
+      continue;
+    }
+    actionTypes.push({
+      name: action.definition.name,
+      path: action.path,
+      export: action.export,
+      isBuiltin: false
+    });
+  }
+  const workflowTypes = [];
+  for (const workflow of project.workflows) {
+    if (isBuiltinWorkflow(workflow.definition.name)) {
+      continue;
+    }
+    workflowTypes.push({
+      name: workflow.definition.name,
+      path: workflow.path,
+      export: workflow.export
+    });
+  }
+  const tableTypes = [];
+  for (const table of project.tables) {
+    try {
+      const tablePath = path18.join(project.path, table.path);
+      const tableModule = await import(`${tablePath}?t=${Date.now()}`);
+      const tableInstance = tableModule.default || tableModule[table.export];
+      if (tableInstance && tableInstance.columns) {
+        const inputColumns = [];
+        const outputColumns = ["id: number", "createdAt: string", "updatedAt: string"];
+        for (const [colName, colDef] of Object.entries(tableInstance.columns)) {
+          let schema;
+          let computed = false;
+          if (typeof colDef === "object" && colDef !== null && "schema" in colDef) {
+            schema = colDef.schema;
+            computed = colDef.computed || false;
+          } else {
+            schema = colDef;
+          }
+          const tsType = schema.toTypescriptType ? schema.toTypescriptType() : "any";
+          if (!computed) {
+            inputColumns.push(`${colName}: ${tsType}`);
+          }
+          outputColumns.push(`${colName}: ${tsType}`);
+        }
+        tableTypes.push({
+          name: table.definition.name,
+          inputType: `{ ${inputColumns.join("; ")} }`,
+          outputType: `{ ${outputColumns.join("; ")} }`
+        });
+      }
+    } catch (error) {
+      console.warn(`Warning: Could not process table ${table.definition.name}:`, error);
+    }
+  }
+  const actionImportMap = new Map;
+  let actionImportIndex = 0;
+  const actionImports = actionTypes.filter((action) => !action.isBuiltin).map((action) => {
+    const importPath = action.path.replace(/\.ts$/, ".js");
+    actionImportMap.set(action.name, actionImportIndex);
+    const importStatement = `import type * as Action${actionImportIndex} from '../${importPath}'`;
+    actionImportIndex++;
+    return importStatement;
+  }).join(`
+`);
+  const workflowImports = workflowTypes.map((workflow, index) => {
+    const importPath = workflow.path.replace(/\.ts$/, ".js");
+    return `import type * as Workflow${index} from '../${importPath}'`;
+  }).join(`
+`);
+  const content = `
+// @ts-nocheck
+////////////////////////////////////////////////////////
+// DO NOT EDIT THIS FILE DIRECTLY
+// This file is auto-generated from the Botpress ADK
+// ADK Version: ${ADK_VERSION}
+// Generated at: ${new Date().toISOString()}
+////////////////////////////////////////////////////////
+
+import type { Client, Workflow } from '@botpress/client'
+import type { z } from '@botpress/sdk'
+
+${actionImports}
+${workflowImports}
+
+// Utility type to simplify complex types
+type Simplify<T> = T extends (...args: infer A) => infer R
+  ? (...args: SimplifyTuple<A>) => Simplify<R>
+  : T extends Array<infer E>
+    ? Array<Simplify<E>>
+    : T extends ReadonlyArray<infer E>
+      ? ReadonlyArray<Simplify<E>>
+      : T extends Promise<infer R>
+        ? Promise<Simplify<R>>
+        : T extends Buffer
+          ? Buffer
+          : T extends object
+            ? SimplifyObject<T>
+            : T
+
+type SimplifyTuple<T> = T extends [...infer A] ? { [K in keyof A]: Simplify<A[K]> } : never
+type SimplifyObject<T extends object> = T extends infer O ? { [K in keyof O]: Simplify<O[K]> } : never
+
+type GenericWorkflowInput = Record<string, any>
+type GenericWorkflowOutput = Record<string, any>
+
+type TypedWorkflow<TInput = GenericWorkflowInput, TOutput = GenericWorkflowOutput> = Simplify<
+  Omit<Workflow, 'input' | 'output'> & {
+    input: TInput
+    output: TOutput
+  }
+>
+
+// Extract response types from Client methods
+type CreateWorkflowResponse = Simplify<Awaited<ReturnType<Client['createWorkflow']>>>
+type GetWorkflowResponse = Simplify<Awaited<ReturnType<Client['getWorkflow']>>>
+type UpdateWorkflowResponse = Simplify<Awaited<ReturnType<Client['updateWorkflow']>>>
+type DeleteWorkflowResponse = Simplify<Awaited<ReturnType<Client['deleteWorkflow']>>>
+type GetOrCreateWorkflowResponse = Simplify<Awaited<ReturnType<Client['getOrCreateWorkflow']>>>
+
+type CreateTableRowsResponse = Simplify<Awaited<ReturnType<Client['createTableRows']>>>
+type UpdateTableRowsResponse = Simplify<Awaited<ReturnType<Client['updateTableRows']>>>
+type UpsertTableRowsResponse = Simplify<Awaited<ReturnType<Client['upsertTableRows']>>>
+type DeleteTableRowsResponse = Simplify<Awaited<ReturnType<Client['deleteTableRows']>>>
+type FindTableRowsResponse = Simplify<Awaited<ReturnType<Client['findTableRows']>>>
+type GetTableRowResponse = Simplify<Awaited<ReturnType<Client['getTableRow']>>>
+
+// Extract parameter types from Client methods
+type ParamCreateWorkflow = Simplify<Parameters<Client['createWorkflow']>[0]>
+type ParamGetWorkflow = Simplify<Parameters<Client['getWorkflow']>[0]>
+type ParamUpdateWorkflow = Simplify<Parameters<Client['updateWorkflow']>[0]>
+type ParamDeleteWorkflow = Simplify<Parameters<Client['deleteWorkflow']>[0]>
+type ParamGetOrCreateWorkflow = Simplify<Parameters<Client['getOrCreateWorkflow']>[0]>
+
+type ParamCreateTableRows = Simplify<Parameters<Client['createTableRows']>[0]>
+type ParamUpdateTableRows = Simplify<Parameters<Client['updateTableRows']>[0]>
+type ParamUpsertTableRows = Simplify<Parameters<Client['upsertTableRows']>[0]>
+type ParamDeleteTableRows = Simplify<Parameters<Client['deleteTableRows']>[0]>
+type ParamFindTableRows = Simplify<Parameters<Client['findTableRows']>[0]>
+type ParamGetTableRow = Simplify<Parameters<Client['getTableRow']>[0]>
+
+/**
+ * Typed ADK Client
+ *
+ * Provides strongly-typed wrappers around the Botpress Client for actions, workflows, and tables.
+ */
+export interface AdkClient {
+  /**
+   * Typed action calls
+   */
+  actions: {
+    ${actionTypes.map((action) => {
+    if (action.isBuiltin) {
+      return `
+    /**
+     * Call action: ${action.name}
+     */
+    '${action.name}': (input: any) => Promise<any>
+    `;
+    }
+    const importIndex = actionImportMap.get(action.name);
+    return `
+    /**
+     * Call action: ${action.name}
+     */
+    '${action.name}': (input: z.input<typeof Action${importIndex}.default.input>) => Promise<z.infer<typeof Action${importIndex}.default.output>>
+    `;
+  }).join(`
+`)}
+  }
+
+  /**
+   * Typed workflow operations
+   */
+  workflows: {
+    ${workflowTypes.map((workflow, index) => {
+    const inputType = `z.input<typeof Workflow${index}.default.inputSchema>`;
+    const outputType = `z.infer<typeof Workflow${index}.default.outputSchema>`;
+    return `
+    '${workflow.name}': {
+      /**
+       * Create workflow: ${workflow.name}
+       */
+      createWorkflow: (params: Omit<ParamCreateWorkflow, 'name' | 'input'> & { input?: ${inputType} }) => Promise<Omit<CreateWorkflowResponse, 'workflow'> & { workflow: TypedWorkflow<${inputType}, ${outputType}> }>
+      /**
+       * Get workflow by ID
+       */
+      getWorkflow: (params: ParamGetWorkflow) => Promise<Omit<GetWorkflowResponse, 'workflow'> & { workflow: TypedWorkflow<${inputType}, ${outputType}> }>
+      /**
+       * Update workflow
+       */
+      updateWorkflow: (params: Omit<ParamUpdateWorkflow, 'output'> & { output?: ${outputType} }) => Promise<Omit<UpdateWorkflowResponse, 'workflow'> & { workflow: TypedWorkflow<${inputType}, ${outputType}> }>
+      /**
+       * Delete workflow
+       */
+      deleteWorkflow: (params: ParamDeleteWorkflow) => Promise<DeleteWorkflowResponse>
+      /**
+       * Get or create workflow with deduplication key
+       */
+      getOrCreateWorkflow: (params: Omit<ParamGetOrCreateWorkflow, 'name' | 'input'> & { input?: ${inputType} }) => Promise<Omit<GetOrCreateWorkflowResponse, 'workflow'> & { workflow: TypedWorkflow<${inputType}, ${outputType}> }>
+    }
+    `;
+  }).join(`
+`)}
+  }
+
+  /**
+   * Typed table operations
+   */
+  tables: {
+    ${tableTypes.map((table) => `
+    '${table.name}': {
+      /**
+       * Find rows in table: ${table.name}
+       */
+      findTableRows: (params?: Omit<ParamFindTableRows, 'table'>) => Promise<Omit<FindTableRowsResponse, 'rows'> & { rows: Array<${table.outputType}> }>
+      /**
+       * Get a single row by ID
+       */
+      getTableRow: (params: Omit<ParamGetTableRow, 'table'>) => Promise<Omit<GetTableRowResponse, 'row'> & { row: ${table.outputType} }>
+      /**
+       * Create rows in table: ${table.name}
+       */
+      createTableRows: (params: Omit<ParamCreateTableRows, 'table'>) => Promise<Omit<CreateTableRowsResponse, 'rows'> & { rows: Array<${table.outputType}> }>
+      /**
+       * Update rows in table: ${table.name}
+       */
+      updateTableRows: (params: Omit<ParamUpdateTableRows, 'table'>) => Promise<Omit<UpdateTableRowsResponse, 'rows'> & { rows: Array<${table.outputType}> }>
+      /**
+       * Upsert rows in table: ${table.name}
+       */
+      upsertTableRows: (params: Omit<ParamUpsertTableRows, 'table'>) => Promise<Omit<UpsertTableRowsResponse, 'rows'> & { rows: Array<${table.outputType}> }>
+      /**
+       * Delete rows by IDs
+       */
+      deleteTableRows: (params: Omit<ParamDeleteTableRows, 'table'>) => Promise<Omit<DeleteTableRowsResponse, 'rows'> & { rows: Array<${table.outputType}> }>
+    }
+    `).join(`
+`)}
+  }
+
+  /**
+   * Raw Botpress client (no additional typing)
+   */
+  client: Client
+}
+
+/**
+ * Create a typed ADK client wrapper around a Botpress Client
+ *
+ * @example
+ * \`\`\`typescript
+ * import { Client } from '@botpress/client'
+ * import { createAdkClient } from './.adk/client'
+ *
+ * const client = new Client({ token: 'xxx', botId: 'yyy' })
+ * const adk = createAdkClient(client)
+ *
+ * // Typed action calls
+ * const result = await adk.actions.myAction({ foo: 'bar' })
+ *
+ * // Typed workflow operations
+ * const wf = await adk.workflows.myWorkflow.createWorkflow({ input: { data: 'value' } })
+ * const workflow = await adk.workflows.myWorkflow.getWorkflow({ id: wf.workflow.id })
+ * await adk.workflows.myWorkflow.updateWorkflow({ id: wf.workflow.id, status: 'completed' })
+ * await adk.workflows.myWorkflow.deleteWorkflow({ id: wf.workflow.id })
+ * await adk.workflows.myWorkflow.getOrCreateWorkflow({ key: 'unique-key', input: { data: 'value' } })
+ *
+ * // Typed table operations
+ * const rows = await adk.tables.myTable.findTableRows({ filter: { name: 'John' } })
+ * const row = await adk.tables.myTable.getTableRow({ id: 123 })
+ * await adk.tables.myTable.createTableRows({ rows: [{ name: 'Jane', age: 30 }] })
+ * await adk.tables.myTable.updateTableRows({ rows: [{ id: 123, name: 'Jane' }] })
+ * await adk.tables.myTable.upsertTableRows({ rows: [{ name: 'Bob', age: 25 }] })
+ * await adk.tables.myTable.deleteTableRows({ ids: [123, 456] })
+ * \`\`\`
+ */
+export function createAdkClient(client: Client): AdkClient {
+  return {
+    actions: {
+      ${actionTypes.map((action) => `
+      '${action.name}': async (input) => {
+        const response = await client.callAction({
+          type: '${action.name}',
+          input,
+        })
+        return response.output as any
+      }
+      `).join(`,
+`)}
+    },
+
+    workflows: {
+      ${workflowTypes.map((workflow) => `
+      '${workflow.name}': {
+        createWorkflow: async (params) => {
+          return client.createWorkflow({
+            name: '${workflow.name}',
+            ...params,
+          }) as any
+        },
+        getWorkflow: async (params) => {
+          return client.getWorkflow(params) as any
+        },
+        updateWorkflow: async (params) => {
+          return client.updateWorkflow(params) as any
+        },
+        deleteWorkflow: async (params) => {
+          return client.deleteWorkflow(params) as any
+        },
+        getOrCreateWorkflow: async (params) => {
+          return client.getOrCreateWorkflow({
+            name: '${workflow.name}',
+            ...params,
+          }) as any
+        },
+      }
+      `).join(`,
+`)}
+    },
+
+    tables: {
+      ${tableTypes.map((table) => `
+      '${table.name}': {
+        findTableRows: async (params) => {
+          return client.findTableRows({
+            table: '${table.name}',
+            ...params,
+          }) as any
+        },
+        getTableRow: async (params) => {
+          return client.getTableRow({
+            table: '${table.name}',
+            ...params,
+          }) as any
+        },
+        createTableRows: async (params) => {
+          return client.createTableRows({
+            table: '${table.name}',
+            ...params,
+          }) as any
+        },
+        updateTableRows: async (params) => {
+          return client.updateTableRows({
+            table: '${table.name}',
+            ...params,
+          }) as any
+        },
+        upsertTableRows: async (params) => {
+          return client.upsertTableRows({
+            table: '${table.name}',
+            ...params,
+          }) as any
+        },
+        deleteTableRows: async (params) => {
+          return client.deleteTableRows({
+            table: '${table.name}',
+            ...params,
+          }) as any
+        },
+      }
+      `).join(`,
+`)}
+    },
+
+    client,
+  }
+}
+`;
+  const clientWrapperPath = path18.join(project.path, ".adk", "client.ts");
+  const formattedContent = await formatCode(content);
+  const contentHash = crypto3.createHash("sha256").update(formattedContent.replace(/\/\/ Generated at: .+\n/, "")).digest("hex");
+  try {
+    const existingContent = await readFile3(clientWrapperPath, "utf-8");
+    const existingHash = crypto3.createHash("sha256").update(existingContent.replace(/\/\/ Generated at: .+\n/, "")).digest("hex");
+    if (contentHash === existingHash) {
+      return;
+    }
+  } catch {}
+  await createFile(clientWrapperPath, formattedContent);
+}
 // src/bot-generator/generator.ts
 import dedent from "dedent";
 import { existsSync as existsSync7 } from "fs";
 import fs16 from "fs/promises";
-import path33 from "path";
+import path34 from "path";
 
 // src/generators/interface-types.ts
 import { transforms as transforms2 } from "@botpress/sdk";
-import crypto3 from "crypto";
-import path18 from "path";
+import crypto4 from "crypto";
+import path19 from "path";
 init_utils();
 var sameMajorVersion = (a, b) => {
   const majorA = a.split(".")[0];
@@ -7036,7 +7427,7 @@ var getIntegrationInterface = (integration, int) => {
 };
 var getInterfaceHash = (int, integrations) => {
   const versions = integrations.filter((x) => !!getIntegrationInterface(x.definition, int)).map((x) => `${x.definition.id}|${x.definition.version}|${x.definition.updatedAt}|${x.alias}`).sort().join("|");
-  return crypto3.createHash("sha256").update(`${int.id}|${int.version}|${int.updatedAt}|${versions}`).digest("hex");
+  return crypto4.createHash("sha256").update(`${int.id}|${int.version}|${int.updatedAt}|${versions}`).digest("hex");
 };
 var getInterfaceNames = (int) => ({
   name: camelCase(int.name),
@@ -7045,8 +7436,8 @@ var getInterfaceNames = (int) => ({
     actions: `Interface_Actions_${pascalCase(int.name)}`
   },
   paths: {
-    index: path18.join(snakeCase(int.name), `index.ts`),
-    actions: path18.join(snakeCase(int.name), `actions.ts`)
+    index: path19.join(snakeCase(int.name), `index.ts`),
+    actions: path19.join(snakeCase(int.name), `actions.ts`)
   }
 });
 async function generateInterfaceTypes(int, integrations) {
@@ -7151,12 +7542,12 @@ Description: ${action.description || "No description"}`)}
 // src/generators/table-types.ts
 init_utils();
 init_fs();
-import path19 from "path";
+import path20 from "path";
 async function generateTableTypes(project) {
   const tables = [];
   for (const tableRef of project.tables) {
     try {
-      const tablePath = path19.join(project.path, tableRef.path);
+      const tablePath = path20.join(project.path, tableRef.path);
       const tableModule = await import(`${tablePath}?t=${Date.now()}`);
       const tableInstance = tableModule.default || tableModule[tableRef.export];
       if (tableInstance && tableInstance.columns) {
@@ -7242,14 +7633,14 @@ ${outputColumns}
   content += `  };
 }
 `;
-  const tableTypesPath = path19.join(project.path, ".adk", "table-types.d.ts");
+  const tableTypesPath = path20.join(project.path, ".adk", "table-types.d.ts");
   await createFile(tableTypesPath, await formatCode(content));
 }
 
 // src/generators/trigger-types.ts
 init_utils();
 init_fs();
-import path20 from "path";
+import path21 from "path";
 async function generateTriggerTypes(project) {
   const triggerEvents = {};
   for (const trigger of project.triggers) {
@@ -7289,19 +7680,19 @@ ${triggersType}
   };
 }
 `;
-  const triggerTypesPath = path20.join(project.path, ".adk", "trigger-types.d.ts");
+  const triggerTypesPath = path21.join(project.path, ".adk", "trigger-types.d.ts");
   await createFile(triggerTypesPath, await formatCode(content));
 }
 
 // src/generators/state-types.ts
 init_utils();
 init_fs();
-import path21 from "path";
+import path22 from "path";
 async function generateStateTypes(project) {
   let botStateType = "{}";
   let userStateType = "{}";
   try {
-    const configPath = path21.join(project.path, "agent.config.ts");
+    const configPath = path22.join(project.path, "agent.config.ts");
     const configModule = await import(`${configPath}?t=${Date.now()}`);
     const config = configModule.default;
     if (config?.bot?.state) {
@@ -7332,14 +7723,14 @@ declare module "@botpress/runtime/_types/state" {
   export type UserState = ${userStateType};
 }
 `;
-  const stateTypesPath = path21.join(project.path, ".adk", "state-types.d.ts");
+  const stateTypesPath = path22.join(project.path, ".adk", "state-types.d.ts");
   await createFile(stateTypesPath, await formatCode(content));
 }
 
 // src/generators/tag-types.ts
 init_utils();
 init_fs();
-import path22 from "path";
+import path23 from "path";
 import { BUILT_IN_TAGS } from "@botpress/runtime/definition";
 function generateTagTypeString(builtInTags, configTags) {
   const builtInTagStrings = Object.entries(builtInTags).map(([key, tag]) => {
@@ -7378,7 +7769,7 @@ async function generateTagTypes(project) {
   let messageTagsType = "Record<string, string | undefined>";
   let workflowTagsType = "Record<string, string | undefined>";
   try {
-    const configPath = path22.join(project.path, "agent.config.ts");
+    const configPath = path23.join(project.path, "agent.config.ts");
     const configModule = await import(`${configPath}?t=${Date.now()}`);
     const config = configModule.default;
     botTagsType = generateTagTypeString(BUILT_IN_TAGS.bot, config?.bot?.tags);
@@ -7424,18 +7815,18 @@ declare module "@botpress/runtime/_types/tags" {
   export type WorkflowTags = ${workflowTagsType};
 }
 `;
-  const tagTypesPath = path22.join(project.path, ".adk", "tag-types.d.ts");
+  const tagTypesPath = path23.join(project.path, ".adk", "tag-types.d.ts");
   await createFile(tagTypesPath, await formatCode(content));
 }
 
 // src/generators/configuration-types.ts
 init_utils();
 init_fs();
-import path23 from "path";
+import path24 from "path";
 async function generateConfigurationTypes(project) {
   let configurationType = "{}";
   try {
-    const configPath = path23.join(project.path, "agent.config.ts");
+    const configPath = path24.join(project.path, "agent.config.ts");
     const configModule = await import(`${configPath}?t=${Date.now()}`);
     const config = configModule.default;
     if (config?.configuration?.schema) {
@@ -7459,26 +7850,26 @@ declare module "@botpress/runtime/_types/configuration" {
   export type Configuration = ${configurationType};
 }
 `;
-  const configTypesPath = path23.join(project.path, ".adk", "configuration-types.d.ts");
+  const configTypesPath = path24.join(project.path, ".adk", "configuration-types.d.ts");
   await createFile(configTypesPath, await formatCode(content));
 }
 
 // src/generators/workflow-types.ts
 init_utils();
 init_fs();
-import * as path24 from "path";
-import { BuiltInWorkflows as BuiltInWorkflows2 } from "@botpress/runtime/internal";
-function isBuiltinWorkflow(name) {
-  return !!Object.values(BuiltInWorkflows2).find((x) => x.name === name);
+import * as path25 from "path";
+import { BuiltInWorkflows as BuiltInWorkflows3 } from "@botpress/runtime/internal";
+function isBuiltinWorkflow2(name) {
+  return !!Object.values(BuiltInWorkflows3).find((x) => x.name === name);
 }
 async function generateWorkflowTypes(project) {
   const workflows = [];
   for (const workflowRef of project.workflows) {
     try {
-      if (isBuiltinWorkflow(workflowRef.definition.name)) {
+      if (isBuiltinWorkflow2(workflowRef.definition.name)) {
         continue;
       }
-      const workflowPath = path24.join(project.path, workflowRef.path);
+      const workflowPath = path25.join(project.path, workflowRef.path);
       const workflowModule = await import(`${workflowPath}?t=${Date.now()}`);
       const workflowInstance = workflowModule[workflowRef.export] || workflowModule.default;
       if (!workflowInstance) {
@@ -7525,14 +7916,14 @@ declare module "@botpress/runtime/_types/workflows" {
 ${typeDefinitions || "    // No workflows defined yet"}
   };
 }`;
-  const workflowTypesPath = path24.join(project.path, ".adk", "workflow-types.d.ts");
+  const workflowTypesPath = path25.join(project.path, ".adk", "workflow-types.d.ts");
   await createFile(workflowTypesPath, await formatCode(content));
 }
 
 // src/generators/conversation-types.ts
 init_utils();
 init_fs();
-import path25 from "path";
+import path26 from "path";
 function hasConversationIdProperty(schema) {
   if (!schema || typeof schema !== "object") {
     return false;
@@ -7555,7 +7946,7 @@ async function generateConversationTypes(project) {
   const conversationTypes = {};
   for (const conversationRef of project.conversations) {
     try {
-      const conversationPath = path25.join(project.path, conversationRef.path);
+      const conversationPath = path26.join(project.path, conversationRef.path);
       const conversationModule = await import(`${conversationPath}?t=${Date.now()}`);
       const conversationInstance = conversationModule[conversationRef.export] || conversationModule.default;
       if (!conversationInstance) {
@@ -7641,14 +8032,14 @@ ${routableEventsDefinitions || "    // No routable events found"}
   };
 }
 `;
-  const conversationTypesPath = path25.join(project.path, ".adk", "conversation-types.d.ts");
+  const conversationTypesPath = path26.join(project.path, ".adk", "conversation-types.d.ts");
   await createFile(conversationTypesPath, await formatCode(content));
 }
 
 // src/generators/event-types.ts
 init_utils();
 init_fs();
-import path26 from "path";
+import path27 from "path";
 async function generateEventTypes(project) {
   const defaultEvents = ["register: {}"];
   const integrationEvents = [];
@@ -7700,7 +8091,7 @@ ${allEvents.map((e) => `    ${e}`).join(`
   export type EventPayload<T extends EventName> = Events[T];
 }
 `;
-  const eventTypesPath = path26.join(project.path, ".adk", "event-types.d.ts");
+  const eventTypesPath = path27.join(project.path, ".adk", "event-types.d.ts");
   await createFile(eventTypesPath, await formatCode(content));
 }
 
@@ -7710,7 +8101,7 @@ init_fs();
 // src/utils/link-sdk.ts
 import { existsSync as existsSync3, realpathSync } from "fs";
 import fs12 from "fs/promises";
-import path27 from "path";
+import path28 from "path";
 function findPackage(name, startDir) {
   let current;
   try {
@@ -7718,17 +8109,17 @@ function findPackage(name, startDir) {
   } catch {
     current = startDir;
   }
-  while (current !== path27.dirname(current)) {
-    const pkgPath = path27.join(current, "node_modules", name);
+  while (current !== path28.dirname(current)) {
+    const pkgPath = path28.join(current, "node_modules", name);
     if (existsSync3(pkgPath)) {
       return pkgPath;
     }
-    current = path27.dirname(current);
+    current = path28.dirname(current);
   }
   return null;
 }
 async function linkSdk(agentDir, botDir) {
-  const targetSdkPath = path27.join(botDir, "node_modules", "@botpress", "sdk");
+  const targetSdkPath = path28.join(botDir, "node_modules", "@botpress", "sdk");
   if (existsSync3(targetSdkPath)) {
     return;
   }
@@ -7742,14 +8133,14 @@ async function linkSdk(agentDir, botDir) {
     console.warn(`Warning: Could not find @botpress/sdk from @botpress/runtime location (${runtimePath})`);
     return;
   }
-  const targetBotpressDir = path27.join(botDir, "node_modules", "@botpress");
+  const targetBotpressDir = path28.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 path29 from "path";
 import fs13 from "fs/promises";
 import { existsSync as existsSync4 } from "fs";
 import { Client as Client13 } from "@botpress/client";
@@ -7761,7 +8152,7 @@ class DevIdManager {
   constructor(projectPath, botProjectPath) {
     this.projectPath = projectPath;
     this.botProjectPath = botProjectPath;
-    this.projectCachePath = path28.join(botProjectPath, ".botpress", "project.cache.json");
+    this.projectCachePath = path29.join(botProjectPath, ".botpress", "project.cache.json");
   }
   async getClient() {
     if (!this.client) {
@@ -7798,7 +8189,7 @@ class DevIdManager {
   }
   async saveProjectCache(cache2) {
     try {
-      await fs13.mkdir(path28.dirname(this.projectCachePath), { recursive: true });
+      await fs13.mkdir(path29.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);
@@ -7847,7 +8238,7 @@ class DevIdManager {
 }
 
 // src/bot-generator/integration-sync.ts
-import path29 from "path";
+import path30 from "path";
 import fs14 from "fs/promises";
 import { existsSync as existsSync5 } from "fs";
 class IntegrationSync {
@@ -7857,7 +8248,7 @@ class IntegrationSync {
   constructor(projectPath, botProjectPath) {
     this.projectPath = projectPath;
     this.botProjectPath = botProjectPath;
-    this.bpModulesPath = path29.join(botProjectPath, "bp_modules");
+    this.bpModulesPath = path30.join(botProjectPath, "bp_modules");
   }
   async parseIntegrations() {
     const project = await AgentProject.load(this.projectPath);
@@ -7888,12 +8279,12 @@ class IntegrationSync {
     return integrations;
   }
   async isIntegrationSynced(integration) {
-    const targetFolder = path29.join(this.bpModulesPath, `integration_${integration.alias}`);
+    const targetFolder = path30.join(this.bpModulesPath, `integration_${integration.alias}`);
     if (!existsSync5(targetFolder)) {
       return false;
     }
     try {
-      const indexPath = path29.join(targetFolder, "index.ts");
+      const indexPath = path30.join(targetFolder, "index.ts");
       if (!existsSync5(indexPath)) {
         return false;
       }
@@ -7925,8 +8316,8 @@ class IntegrationSync {
     await command.output();
   }
   async renameIntegrationFolder(integration) {
-    const sourceFolder = path29.join(this.bpModulesPath, integration.name.replace("/", "-"));
-    const targetFolder = path29.join(this.bpModulesPath, `integration_${integration.alias}`);
+    const sourceFolder = path30.join(this.bpModulesPath, integration.name.replace("/", "-"));
+    const targetFolder = path30.join(this.bpModulesPath, `integration_${integration.alias}`);
     if (!existsSync5(sourceFolder)) {
       throw new Error(`Integration folder not found: ${sourceFolder}`);
     }
@@ -7936,7 +8327,7 @@ class IntegrationSync {
     await fs14.rename(sourceFolder, targetFolder);
   }
   async removeIntegrationFolder(alias) {
-    const targetFolder = path29.join(this.bpModulesPath, `integration_${alias}`);
+    const targetFolder = path30.join(this.bpModulesPath, `integration_${alias}`);
     if (existsSync5(targetFolder)) {
       await fs14.rm(targetFolder, { recursive: true, force: true });
     }
@@ -7970,7 +8361,7 @@ class IntegrationSync {
 }
 
 // src/bot-generator/interface-sync.ts
-import path30 from "path";
+import path31 from "path";
 import fs15 from "fs/promises";
 import { existsSync as existsSync6 } from "fs";
 init_constants();
@@ -7981,7 +8372,7 @@ class InterfaceSync {
   constructor(projectPath, botProjectPath) {
     this.projectPath = projectPath;
     this.botProjectPath = botProjectPath;
-    this.bpModulesPath = path30.join(botProjectPath, "bp_modules");
+    this.bpModulesPath = path31.join(botProjectPath, "bp_modules");
   }
   async parseInterfaces() {
     const interfaces = [];
@@ -7999,12 +8390,12 @@ class InterfaceSync {
     return interfaces;
   }
   async isInterfaceSynced(interfaceInfo) {
-    const targetFolder = path30.join(this.bpModulesPath, `interface_${pascalCase(interfaceInfo.alias)}`);
+    const targetFolder = path31.join(this.bpModulesPath, `interface_${pascalCase(interfaceInfo.alias)}`);
     if (!existsSync6(targetFolder)) {
       return false;
     }
     try {
-      const indexPath = path30.join(targetFolder, "index.ts");
+      const indexPath = path31.join(targetFolder, "index.ts");
       if (!existsSync6(indexPath)) {
         return false;
       }
@@ -8050,8 +8441,8 @@ class InterfaceSync {
     });
   }
   async renameInterfaceFolder(interfaceInfo) {
-    const sourceFolder = path30.join(this.bpModulesPath, interfaceInfo.name);
-    const targetFolder = path30.join(this.bpModulesPath, `interface_${pascalCase(interfaceInfo.alias)}`);
+    const sourceFolder = path31.join(this.bpModulesPath, interfaceInfo.name);
+    const targetFolder = path31.join(this.bpModulesPath, `interface_${pascalCase(interfaceInfo.alias)}`);
     if (!existsSync6(sourceFolder)) {
       throw new Error(`Interface folder not found: ${sourceFolder}`);
     }
@@ -8061,7 +8452,7 @@ class InterfaceSync {
     await fs15.rename(sourceFolder, targetFolder);
   }
   async removeInterfaceFolder(alias) {
-    const targetFolder = path30.join(this.bpModulesPath, `interface_${pascalCase(alias)}`);
+    const targetFolder = path31.join(this.bpModulesPath, `interface_${pascalCase(alias)}`);
     if (existsSync6(targetFolder)) {
       await fs15.rm(targetFolder, { recursive: true, force: true });
     }
@@ -8098,26 +8489,28 @@ class InterfaceSync {
 init_utils();
 import { transforms as transforms3 } from "@botpress/sdk";
 init_constants();
-import { BuiltInActions as BuiltInActions2, BuiltInWorkflows as BuiltInWorkflows3, Primitives as Primitives3 } from "@botpress/runtime/internal";
+import { BuiltInActions as BuiltInActions2, BuiltInWorkflows as BuiltInWorkflows4, Primitives as Primitives3 } from "@botpress/runtime/internal";
 import { BUILT_IN_TAGS as BUILT_IN_TAGS2 } from "@botpress/runtime/definition";
 var plural = (n, word) => `${n} ${word}${n === 1 ? "" : "s"}`;
-function isBuiltinWorkflow2(name) {
-  return !!Object.values(BuiltInWorkflows3).find((x) => x.name === name);
+function isBuiltinWorkflow3(name) {
+  return !!Object.values(BuiltInWorkflows4).find((x) => x.name === name);
 }
 function isBuiltinAction(name) {
   return !!Object.values(BuiltInActions2).find((x) => x.name === name);
 }
 function getImportPath(from, to) {
-  return path33.relative(path33.dirname(from), to).replace(/\.ts$/, "").replace(/\\/g, "/");
+  return path34.relative(path34.dirname(from), to).replace(/\.ts$/, "").replace(/\\/g, "/");
 }
 
 class BotGenerator {
   projectPath;
   outputPath;
+  adkCommand;
   callbacks;
   constructor(options) {
-    this.projectPath = path33.resolve(options.projectPath);
-    this.outputPath = path33.resolve(options.outputPath || path33.join(this.projectPath, ".adk"));
+    this.projectPath = path34.resolve(options.projectPath);
+    this.outputPath = path34.resolve(options.outputPath || path34.join(this.projectPath, ".adk"));
+    this.adkCommand = options.adkCommand;
     this.callbacks = options.callbacks;
   }
   async listFilesRecursive(rootDir) {
@@ -8128,8 +8521,8 @@ class BotGenerator {
       const walk = async (dir, relativeBase) => {
         const entries = await fs16.readdir(dir, { withFileTypes: true });
         for (const entry of entries) {
-          const abs = path33.join(dir, entry.name);
-          const rel = path33.join(relativeBase, entry.name);
+          const abs = path34.join(dir, entry.name);
+          const rel = path34.join(relativeBase, entry.name);
           if (entry.isDirectory()) {
             await walk(abs, rel);
           } else {
@@ -8150,7 +8543,7 @@ class BotGenerator {
       const entries = await fs16.readdir(dir, { withFileTypes: true });
       for (const entry of entries) {
         if (entry.isDirectory()) {
-          const subdir = path33.join(dir, entry.name);
+          const subdir = path34.join(dir, entry.name);
           await removeIfEmpty(subdir);
         }
       }
@@ -8182,6 +8575,7 @@ class BotGenerator {
     await this.generateEventTypes();
     await this.generateIntegrationActionTypes();
     await this.generateRuntimeTypes();
+    await this.generateClientWrapper();
     await this.generateBotIndex();
     await this.generatePackageJson(project);
     await this.generateTsConfig();
@@ -8194,18 +8588,18 @@ class BotGenerator {
       workspaceId: project.agentInfo?.workspaceId
     });
     const integrations = await manager3.loadIntegrations(project.dependencies || {});
-    const integrationsDir = path33.join(this.projectPath, ".adk", "integrations");
+    const integrationsDir = path34.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 = `./${path33.join("integrations", types6.names.paths.index).replace(/\\/g, "/")}`;
+        const importPath = `./${path34.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 = path33.join(this.projectPath, ".adk", "integrations", filePath);
-          const dir = path33.dirname(fullPath);
+          const fullPath = path34.join(this.projectPath, ".adk", "integrations", filePath);
+          const dir = path34.dirname(fullPath);
           await fs16.mkdir(dir, { recursive: true });
           await createFile(fullPath, content);
           files.add(filePath);
@@ -8226,11 +8620,11 @@ class BotGenerator {
         };
       }
       `;
-    await createFile(path33.join(this.projectPath, ".adk", "integrations-types.d.ts"), await formatCode(types5));
+    await createFile(path34.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 = path33.join(integrationsDir, rel);
+        const abs = path34.join(integrationsDir, rel);
         try {
           await fs16.rm(abs, { force: true });
         } catch {}
@@ -8280,6 +8674,10 @@ class BotGenerator {
     const { generateIntegrationActionTypes: generateIntegrationActionTypes2 } = await Promise.resolve().then(() => (init_integration_action_types(), exports_integration_action_types));
     await generateIntegrationActionTypes2(project);
   }
+  async generateClientWrapper() {
+    const project = await AgentProject.load(this.projectPath);
+    await generateClientWrapper(project);
+  }
   async generateRuntimeTypes() {
     const project = await AgentProject.load(this.projectPath);
     const manager3 = new IntegrationManager({
@@ -8299,7 +8697,7 @@ class BotGenerator {
     let botStateType = "{}";
     let userStateType = "{}";
     try {
-      const configPath = path33.join(project.path, "agent.config.ts");
+      const configPath = path34.join(project.path, "agent.config.ts");
       const configModule = await import(`${configPath}?t=${Date.now()}`);
       const config = configModule.default;
       if (config?.bot?.state) {
@@ -8335,7 +8733,7 @@ declare module "@botpress/runtime/_types/state" {
   export type UserState = ${userStateType};
 }
 `;
-    await createFile(path33.join(this.projectPath, ".adk", "runtime.d.ts"), await formatCode(types5));
+    await createFile(path34.join(this.projectPath, ".adk", "runtime.d.ts"), await formatCode(types5));
   }
   async generateInterfacesTypes() {
     const project = await AgentProject.load(this.projectPath);
@@ -8343,7 +8741,7 @@ declare module "@botpress/runtime/_types/state" {
       workspaceId: project.agentInfo?.workspaceId
     });
     const manager3 = new InterfaceManager;
-    const interfacesDir = path33.join(this.projectPath, ".adk", "interfaces");
+    const interfacesDir = path34.join(this.projectPath, ".adk", "interfaces");
     const existingInterfaceFiles = await this.listFilesRecursive(interfacesDir);
     const interfaces = await manager3.loadInterfaces(project.dependencies || {}).then((result) => result.interfaces.filter((int) => int.definition).map((x) => x.definition));
     const integrationsWithAlias = await integrationManager.loadIntegrations(project.dependencies || {}).then((result) => result.integrations.filter((int) => int.enabled && int.definition).map((x) => ({ alias: x.alias, definition: x.definition })));
@@ -8352,11 +8750,11 @@ declare module "@botpress/runtime/_types/state" {
     let files = new Set;
     for (const int of interfaces) {
       const types6 = await generateInterfaceTypes(int, integrationsWithAlias);
-      imports.add(`import { ${types6.names.typings.index} } from "./${path33.join("interfaces", types6.names.paths.index).replace(/\\/g, "/")}";`);
+      imports.add(`import { ${types6.names.typings.index} } from "./${path34.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 = path33.join(this.projectPath, ".adk", "interfaces", filePath);
-        const dir = path33.dirname(fullPath);
+        const fullPath = path34.join(this.projectPath, ".adk", "interfaces", filePath);
+        const dir = path34.dirname(fullPath);
         await fs16.mkdir(dir, { recursive: true });
         await createFile(fullPath, content);
         files.add(filePath);
@@ -8393,12 +8791,12 @@ declare module "@botpress/runtime/_types/state" {
 `)}
       };
       `;
-    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));
+    await createFile(path34.join(this.projectPath, ".adk", "interfaces.d.ts"), await formatCode(types5));
+    await createFile(path34.join(this.projectPath, ".adk", "interfaces.ts"), await formatCode(consts));
     const staleInterfaceFiles = existingInterfaceFiles.filter((f) => !files.has(f));
     if (staleInterfaceFiles.length > 0) {
       for (const rel of staleInterfaceFiles) {
-        const abs = path33.join(interfacesDir, rel);
+        const abs = path34.join(interfacesDir, rel);
         try {
           await fs16.rm(abs, { force: true });
         } catch {}
@@ -8431,7 +8829,7 @@ declare module "@botpress/runtime/_types/state" {
 `) : ""}
       } as Record<string, IntegrationPackage>;
     `;
-    await createFile(path33.join(this.outputPath, "src", "integrations.ts"), content);
+    await createFile(path34.join(this.outputPath, "src", "integrations.ts"), content);
   }
   async generateInterfacesDefinition() {
     const interfaces = BUILTIN_INTERFACES;
@@ -8454,7 +8852,7 @@ declare module "@botpress/runtime/_types/state" {
 `) : ""}
       } as Record<string, InterfacePackage>;
     `;
-    await createFile(path33.join(this.outputPath, "src", "interfaces.ts"), await formatCode(content));
+    await createFile(path34.join(this.outputPath, "src", "interfaces.ts"), await formatCode(content));
   }
   reportServerConfigSync(serverConfigResult, integrations) {
     if (!this.callbacks) {
@@ -8493,7 +8891,9 @@ declare module "@botpress/runtime/_types/state" {
     const project = await AgentProject.load(this.projectPath);
     const integrations = project.integrations;
     const enabledIntegrations = integrations.filter((i) => i.enabled);
-    const serverConfigResult = await fetchServerIntegrationConfigs(project);
+    const isDeployOrBuild = this.adkCommand === "adk-deploy" || this.adkCommand === "adk-build";
+    const configTargetBotId = isDeployOrBuild ? project.agentInfo?.botId : undefined;
+    const serverConfigResult = await fetchServerIntegrationConfigs(project, configTargetBotId);
     this.reportServerConfigSync(serverConfigResult, enabledIntegrations);
     const imports = [];
     const addIntegrations = [];
@@ -8526,9 +8926,9 @@ declare module "@botpress/runtime/_types/state" {
     if (project.config?.workflow?.tags) {
       Object.assign(workflowTags, project.config.workflow.tags);
     }
-    const crypto4 = __require("crypto");
+    const crypto5 = __require("crypto");
     const hashString = (str) => {
-      return crypto4.createHash("md5").update(str).digest("hex").substring(0, 5).toUpperCase();
+      return crypto5.createHash("md5").update(str).digest("hex").substring(0, 5).toUpperCase();
     };
     for (const trigger of project.triggers) {
       const triggerName = trigger.definition.name;
@@ -8543,10 +8943,10 @@ declare module "@botpress/runtime/_types/state" {
     const workflowInstances = [];
     for (const workflow of project.workflows) {
       try {
-        if (isBuiltinWorkflow2(workflow.definition.name)) {
+        if (isBuiltinWorkflow3(workflow.definition.name)) {
           continue;
         }
-        const workflowPath = path33.join(project.path, workflow.path);
+        const workflowPath = path34.join(project.path, workflow.path);
         const workflowModule = await import(`${workflowPath}?t=${Date.now()}`);
         const workflowInstance = workflowModule.default || workflowModule[workflow.export];
         if (workflowInstance) {
@@ -8556,7 +8956,7 @@ declare module "@botpress/runtime/_types/state" {
         console.error(`Failed to load workflow ${workflow.definition.name}:`, error);
       }
     }
-    for (const workflow of Object.values(BuiltInWorkflows3)) {
+    for (const workflow of Object.values(BuiltInWorkflows4)) {
       workflowInstances.push(workflow);
     }
     for (const workflow of workflowInstances) {
@@ -8801,7 +9201,7 @@ configuration: {
     const fullContent = content + integrationsSection + `
 
 export default bot;`;
-    await createFile(path33.join(this.outputPath, "bot.definition.ts"), await formatCode(fullContent));
+    await createFile(path34.join(this.outputPath, "bot.definition.ts"), await formatCode(fullContent));
   }
   async generateBotIndex() {
     const content = dedent`
@@ -8840,7 +9240,7 @@ export default bot;`;
 
       export default bot
     `;
-    await createFile(path33.join(this.outputPath, "src", "index.ts"), await formatCode(content));
+    await createFile(path34.join(this.outputPath, "src", "index.ts"), await formatCode(content));
   }
   async generatePackageJson(project) {
     const packageJson = {
@@ -8854,7 +9254,7 @@ export default bot;`;
         typescript: "^5.9.3"
       }
     };
-    await createFile(path33.join(this.outputPath, "package.json"), JSON.stringify(packageJson, null, 2));
+    await createFile(path34.join(this.outputPath, "package.json"), JSON.stringify(packageJson, null, 2));
   }
   async generateTsConfig() {
     const tsConfig = {
@@ -8885,7 +9285,7 @@ export default bot;`;
       },
       include: [".botpress/**/*", "src/**/*", "bp_modules/**/*", "./*.ts", "./*.json", "../*.d.ts"]
     };
-    await createFile(path33.join(this.outputPath, "tsconfig.json"), JSON.stringify(tsConfig, null, 2));
+    await createFile(path34.join(this.outputPath, "tsconfig.json"), JSON.stringify(tsConfig, null, 2));
   }
   async generateGlobalTypes() {
     const content = dedent`
@@ -8908,11 +9308,11 @@ export default bot;`;
 
       export {};
     `;
-    await createFile(path33.join(this.outputPath, "global.d.ts"), await formatCode(content));
+    await createFile(path34.join(this.outputPath, "global.d.ts"), await formatCode(content));
   }
   async copyAssets() {
-    const assetsPath = path33.join(this.projectPath, "assets");
-    const targetPath = path33.join(this.outputPath, "assets");
+    const assetsPath = path34.join(this.projectPath, "assets");
+    const targetPath = path34.join(this.outputPath, "assets");
     if (existsSync7(assetsPath)) {
       await fs16.mkdir(targetPath, { recursive: true });
       await this.copyDirectory(assetsPath, targetPath);
@@ -8921,8 +9321,8 @@ export default bot;`;
   async copyDirectory(src, dest) {
     const entries = await fs16.readdir(src, { withFileTypes: true });
     for (const entry of entries) {
-      const srcPath = path33.join(src, entry.name);
-      const destPath = path33.join(dest, entry.name);
+      const srcPath = path34.join(src, entry.name);
+      const destPath = path34.join(dest, entry.name);
       if (entry.isDirectory()) {
         await fs16.mkdir(destPath, { recursive: true });
         await this.copyDirectory(srcPath, destPath);
@@ -8934,16 +9334,16 @@ export default bot;`;
   async generateAdkRuntime() {
     const project = new AgentProject(this.projectPath);
     await project.reload();
-    const srcDir = path33.join(this.outputPath, "src");
+    const srcDir = path34.join(this.outputPath, "src");
     {
-      const dest = path33.join(srcDir, "conversations.ts");
+      const dest = path34.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, path33.join(project.path, conversation.path));
+          const importPath = getImportPath(dest, path34.join(project.path, conversation.path));
           imports.set(conversation.path, {
             name,
             statement: `import * as ${name} from "${importPath}";`
@@ -8969,14 +9369,14 @@ export default bot;`;
       await createFile(dest, await formatCode(content2));
     }
     {
-      const dest = path33.join(srcDir, "knowledge.ts");
+      const dest = path34.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, path33.join(project.path, knowledge.path));
+          const importPath = getImportPath(dest, path34.join(project.path, knowledge.path));
           imports.set(knowledge.path, {
             name,
             statement: `import * as ${name} from "${importPath}";`
@@ -9002,7 +9402,7 @@ export default bot;`;
       await createFile(dest, await formatCode(content2));
     }
     {
-      const dest = path33.join(srcDir, "triggers.ts");
+      const dest = path34.join(srcDir, "triggers.ts");
       const { transforms: transforms4 } = await import("@botpress/sdk");
       const imports = new Map;
       const exports = new Set;
@@ -9011,7 +9411,7 @@ export default bot;`;
       for (const trigger of project.triggers) {
         if (!imports.has(trigger.path)) {
           const name = `triggers_${index++}`;
-          const importPath = getImportPath(dest, path33.join(project.path, trigger.path));
+          const importPath = getImportPath(dest, path34.join(project.path, trigger.path));
           imports.set(trigger.path, {
             name,
             statement: `import * as ${name} from "${importPath}";`
@@ -9021,7 +9421,7 @@ export default bot;`;
       }
       for (const trigger of project.triggers) {
         try {
-          const absolutePath = path33.join(project.path, trigger.path);
+          const absolutePath = path34.join(project.path, trigger.path);
           const triggerModule = await import(`${absolutePath}?t=${Date.now()}`);
           const triggerInstance = triggerModule[trigger.export] || triggerModule.default;
           if (triggerInstance && triggerInstance.payload) {
@@ -9064,17 +9464,17 @@ export default bot;`;
       await createFile(dest, await formatCode(content2));
     }
     {
-      const dest = path33.join(srcDir, "workflows.ts");
+      const dest = path34.join(srcDir, "workflows.ts");
       const imports = new Map;
       const exports = new Set;
       let index = 1;
       for (const workflow of project.workflows) {
-        if (isBuiltinWorkflow2(workflow.definition.name)) {
+        if (isBuiltinWorkflow3(workflow.definition.name)) {
           continue;
         }
         if (!imports.has(workflow.path)) {
           const name = `workflows_${index++}`;
-          const importPath = getImportPath(dest, path33.join(project.path, workflow.path));
+          const importPath = getImportPath(dest, path34.join(project.path, workflow.path));
           const statement = `import * as ${name} from "${importPath}";`;
           imports.set(workflow.path, {
             name,
@@ -9083,7 +9483,7 @@ export default bot;`;
         }
       }
       for (const workflow of project.workflows) {
-        if (isBuiltinWorkflow2(workflow.definition.name)) {
+        if (isBuiltinWorkflow3(workflow.definition.name)) {
           continue;
         }
         const importEntry = imports.get(workflow.path);
@@ -9108,7 +9508,7 @@ export default bot;`;
       await createFile(dest, await formatCode(content2));
     }
     {
-      const dest = path33.join(srcDir, "actions.ts");
+      const dest = path34.join(srcDir, "actions.ts");
       const imports = new Map;
       const exports = new Set;
       let index = 1;
@@ -9118,7 +9518,7 @@ export default bot;`;
         }
         if (!imports.has(action.path)) {
           const name = `actions_${index++}`;
-          const importPath = getImportPath(dest, path33.join(project.path, action.path));
+          const importPath = getImportPath(dest, path34.join(project.path, action.path));
           imports.set(action.path, {
             name,
             statement: `import * as ${name} from "${importPath}";`
@@ -9144,14 +9544,14 @@ export default bot;`;
       await createFile(dest, await formatCode(content2));
     }
     {
-      const dest = path33.join(srcDir, "tables.ts");
+      const dest = path34.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, path33.join(project.path, table.path));
+          const importPath = getImportPath(dest, path34.join(project.path, table.path));
           imports.set(table.path, {
             name,
             statement: `import * as ${name} from "${importPath}";`
@@ -9177,8 +9577,8 @@ export default bot;`;
       await createFile(dest, await formatCode(content2));
     }
     {
-      const dest = path33.join(srcDir, "config.ts");
-      const importPath = getImportPath(dest, path33.join(project.path, "agent.config.ts"));
+      const dest = path34.join(srcDir, "config.ts");
+      const importPath = getImportPath(dest, path34.join(project.path, "agent.config.ts"));
       const content2 = `
       ////////////////////////////////////////////////////////
       // DO NOT EDIT THIS FILE DIRECTLY
@@ -9244,13 +9644,13 @@ export default bot;`;
         handlers.actions.setup(bot);
       }
     `;
-    await createFile(path33.join(this.outputPath, "src", "adk-runtime.ts"), await formatCode(content));
+    await createFile(path34.join(this.outputPath, "src", "adk-runtime.ts"), await formatCode(content));
   }
   async copyAssetsRuntime() {
-    const assetsRuntimePath = path33.join(this.projectPath, ".adk", "assets-runtime.ts");
+    const assetsRuntimePath = path34.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));
+      await createFile(path34.join(this.outputPath, "src", "assets-runtime.ts"), await formatCode(content));
     }
   }
 }
@@ -9259,11 +9659,11 @@ async function generateBotProject(options) {
   await generator.generate();
   await generator.generateAdkRuntime();
   await generator.copyAssetsRuntime();
-  const botPath = options.outputPath || path33.join(options.projectPath, ".adk", "bot");
+  const botPath = options.outputPath || path34.join(options.projectPath, ".adk", "bot");
   await linkSdk(options.projectPath, botPath);
-  const devIdManager = new DevIdManager(options.projectPath, options.outputPath || path33.join(options.projectPath, ".adk", "bot"));
+  const devIdManager = new DevIdManager(options.projectPath, options.outputPath || path34.join(options.projectPath, ".adk", "bot"));
   await devIdManager.restoreDevId();
-  const integrationSync = new IntegrationSync(options.projectPath, options.outputPath || path33.join(options.projectPath, ".adk", "bot"));
+  const integrationSync = new IntegrationSync(options.projectPath, options.outputPath || path34.join(options.projectPath, ".adk", "bot"));
   const integrationSyncResult = await integrationSync.syncIntegrations();
   if (integrationSyncResult.errors.length > 0) {
     console.warn(`⚠️  Some integrations failed to sync:`);
@@ -9271,7 +9671,7 @@ async function generateBotProject(options) {
       console.warn(`  - ${alias}: ${error}`);
     });
   }
-  const interfaceSync = new InterfaceSync(options.projectPath, options.outputPath || path33.join(options.projectPath, ".adk", "bot"));
+  const interfaceSync = new InterfaceSync(options.projectPath, options.outputPath || path34.join(options.projectPath, ".adk", "bot"));
   const interfaceSyncResult = await interfaceSync.syncInterfaces();
   if (interfaceSyncResult.errors.length > 0) {
     console.warn(`⚠️  Some interfaces failed to sync:`);
@@ -9779,8 +10179,8 @@ class TableManager {
   }
 }
 // src/knowledge/manager.ts
-import crypto4 from "crypto";
-import path34 from "path";
+import crypto5 from "crypto";
+import path35 from "path";
 import fs17 from "fs/promises";
 import { glob } from "glob";
 import { Client as Client15 } from "@botpress/client";
@@ -9870,7 +10270,7 @@ class KnowledgeManager {
     const sortedEntries = Object.entries(fileHashes).sort(([a], [b]) => a.localeCompare(b));
     const combined = sortedEntries.map(([filePath, hash]) => `${filePath}:${hash}`).join(`
 `);
-    return crypto4.createHash("sha256").update(combined).digest("hex");
+    return crypto5.createHash("sha256").update(combined).digest("hex");
   }
   async listRemoteKnowledgeBases() {
     const client = await this.getClient();
@@ -9985,7 +10385,7 @@ class KnowledgeManager {
   }
   computeConfigHash(config) {
     const sortedConfig = JSON.stringify(config, Object.keys(config).sort());
-    return crypto4.createHash("sha256").update(sortedConfig).digest("hex");
+    return crypto5.createHash("sha256").update(sortedConfig).digest("hex");
   }
   async syncWebsiteSource(kbName, kbId, force) {
     const client = await this.getClient();
@@ -10230,16 +10630,16 @@ class KnowledgeManager {
   }
   async scanLocalFileHashes(directoryPath, filterFn) {
     const projectDir = this.project.path;
-    const directory = path34.resolve(projectDir, directoryPath);
+    const directory = path35.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 = path34.relative(directory, file);
+      const relPath = path35.relative(directory, file);
       const content = await fs17.readFile(file);
-      hashes[relPath] = crypto4.createHash("sha256").update(content).digest("hex");
+      hashes[relPath] = crypto5.createHash("sha256").update(content).digest("hex");
     }
     this.fileHashCache.set(directory, hashes);
     return hashes;
@@ -10345,7 +10745,7 @@ class KnowledgeManager {
   }
   async syncDirectorySource(client, kbName, kbId, dsId, directoryPath, filterFn, force) {
     const projectDir = this.project.path;
-    const directory = path34.resolve(projectDir, directoryPath);
+    const directory = path35.resolve(projectDir, directoryPath);
     if (!directory.startsWith(projectDir)) {
       throw new Error("Directory path must be within the agent's directory");
     }
@@ -10367,8 +10767,8 @@ class KnowledgeManager {
       return true;
     }).map((f) => ({
       abs: f,
-      rel: path34.relative(directory, f),
-      name: path34.basename(f)
+      rel: path35.relative(directory, f),
+      name: path35.basename(f)
     }));
     console.log(`  Found ${allFiles.length} files in ${directoryPath}`);
     const cachedHashes = await this.scanLocalFileHashes(directoryPath, filterFn);
@@ -10443,14 +10843,14 @@ class KnowledgeManager {
   async upsertFile(client, local, dsId, tags, force, cachedHash) {
     const key = `data_source://document/${dsId}/${local.rel}`;
     const content = await fs17.readFile(local.abs);
-    const hash = cachedHash ?? crypto4.createHash("sha256").update(content).digest("hex");
+    const hash = cachedHash ?? crypto5.createHash("sha256").update(content).digest("hex");
     try {
       const { file } = await client.getFile({ id: key });
       if (!force && isFileMetadata(file.metadata) && file.metadata.hash === hash) {
         return null;
       }
     } catch {}
-    const title = path34.basename(local.name, path34.extname(local.name));
+    const title = path35.basename(local.name, path35.extname(local.name));
     const metadata = {
       hash,
       dsId,
@@ -10715,7 +11115,7 @@ class FileWatcher2 extends EventEmitter3 {
 }
 // src/preflight/checker.ts
 import { Client as Client16 } from "@botpress/client";
-import path35 from "path";
+import path36 from "path";
 
 // src/preflight/types.ts
 function hasIntegrationChanges(integrations) {
@@ -11077,7 +11477,7 @@ class PreflightChecker {
     options?.onProgress?.("Regenerating bot project...");
     await generateBotProject({
       projectPath: this.projectPath,
-      outputPath: path35.join(this.projectPath, ".adk", "bot"),
+      outputPath: path36.join(this.projectPath, ".adk", "bot"),
       callbacks: options
     });
     options?.onSuccess?.("Bot project regenerated");
@@ -11087,19 +11487,19 @@ class PreflightChecker {
 import dedent2 from "dedent";
 import { existsSync as existsSync9 } from "fs";
 import fs18 from "fs/promises";
-import path36 from "path";
+import path37 from "path";
 import { spawn } from "child_process";
 init_utils();
 init_credentials();
 async function findAgentRoot(startPath) {
-  let currentPath = path36.resolve(startPath);
-  const root = path36.parse(currentPath).root;
+  let currentPath = path37.resolve(startPath);
+  const root = path37.parse(currentPath).root;
   while (currentPath !== root) {
     try {
-      await fs18.access(path36.join(currentPath, "agent.config.ts"));
+      await fs18.access(path37.join(currentPath, "agent.config.ts"));
       return currentPath;
     } catch {
-      currentPath = path36.dirname(currentPath);
+      currentPath = path37.dirname(currentPath);
     }
   }
   return null;
@@ -11111,7 +11511,7 @@ class ScriptRunner {
   prod;
   credentials;
   constructor(options) {
-    this.projectPath = path36.resolve(options.projectPath);
+    this.projectPath = path37.resolve(options.projectPath);
     this.forceRegenerate = options.forceRegenerate ?? false;
     this.prod = options.prod ?? false;
     this.credentials = options.credentials;
@@ -11120,9 +11520,9 @@ class ScriptRunner {
     const project = await AgentProject.load(this.projectPath, {
       adkCommand: "adk-build"
     });
-    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 botPath = path37.join(this.projectPath, ".adk", "bot");
+    const runnerPath = path37.join(botPath, "src", "script-runner.ts");
+    const botpressTypesPath = path37.join(botPath, ".botpress", "implementation", "index.ts");
     const needsRegenerate = this.forceRegenerate || !existsSync9(runnerPath) || !existsSync9(botpressTypesPath);
     if (needsRegenerate) {
       try {
@@ -11239,7 +11639,7 @@ class ScriptRunner {
 
       runScript()
     `;
-    await fs18.writeFile(path36.join(botPath, "src", "script-runner.ts"), await formatCode(content), "utf-8");
+    await fs18.writeFile(path37.join(botPath, "src", "script-runner.ts"), await formatCode(content), "utf-8");
   }
   async setupTestRuntime(options = {}) {
     const { botPath, project } = await this.prepare();
@@ -11270,7 +11670,7 @@ class ScriptRunner {
     for (const [key, value] of Object.entries(envVars)) {
       process.env[key] = value;
     }
-    const runtimePath = path36.join(botPath, "src", "index.ts");
+    const runtimePath = path37.join(botPath, "src", "index.ts");
     return {
       botPath,
       runtimePath,
@@ -11318,7 +11718,7 @@ class ScriptRunner {
   }
   async run(scriptPath, options = {}) {
     const { botPath, runnerPath, project } = await this.prepare();
-    const absoluteScriptPath = path36.isAbsolute(scriptPath) ? scriptPath : path36.resolve(this.projectPath, scriptPath);
+    const absoluteScriptPath = path37.isAbsolute(scriptPath) ? scriptPath : path37.resolve(this.projectPath, scriptPath);
     if (!existsSync9(absoluteScriptPath)) {
       throw new Error(`Script not found: ${absoluteScriptPath}`);
     }
@@ -11417,6 +11817,7 @@ export {
   initAssets,
   getRelativeTime,
   generateIntegrationTypes,
+  generateClientWrapper,
   generateBotProject,
   generateAssetsTypes,
   generateAssetsRuntime,
@@ -11467,4 +11868,4 @@ export {
   AgentProject
 };
 
-//# debugId=FB5A010697544F3364756E2164756E21
+//# debugId=9C7E68110BCAF64064756E2164756E21