@botpress/adk 1.13.18 → 1.14.0

package/dist/index.js

@@ -666,7 +666,7 @@ var PRETTIER_CONFIG, formatCode = async (code, filepath) => {
 `));
     return code;
   }
-}, ADK_VERSION = "1.13.18", relative2 = (from, to) => {
+}, ADK_VERSION = "1.14.0", relative2 = (from, to) => {
   const fromDir = path10.dirname(from);
   const relative3 = path10.relative(fromDir, to);
   return relative3.startsWith(".") ? relative3 : `./${relative3}`;
@@ -690,7 +690,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 +705,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 +750,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 +763,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 +797,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 +809,7 @@ var init_integration_action_types = __esm(() => {
 var require_package = __commonJS((exports, module) => {
   module.exports = {
     name: "@botpress/adk",
-    version: "1.13.18",
+    version: "1.14.0",
     description: "Core ADK library for building AI agents on Botpress",
     type: "module",
     main: "dist/index.js",
@@ -856,7 +856,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.18",
+      "@botpress/runtime": "^1.14.0",
       "@botpress/sdk": "^5.1.0",
       "@bpinternal/jex": "^1.2.4",
       "@bpinternal/yargs-extra": "^0.0.21",
@@ -1072,6 +1072,9 @@ class BaseCommand {
   on(event, listener) {
     this.events.on(event, listener);
   }
+  off(event, listener) {
+    this.events.off(event, listener);
+  }
   emit(event, ...args) {
     if (event === "done") {
       this.deferred.resolve(args[0]);
@@ -1617,7 +1620,16 @@ class BpDevCommand extends BaseCommand {
     if (this.childProcess.stdout) {
       this.childProcess.stdout.on("data", (data) => {
         const text = data.toString();
-        this.parseOutput(text);
+        if (text.includes('"worker_stats"')) {
+          const nonWorkerStatsText = text.split(`
+`).filter((line) => !line.includes('"type":"worker_stats"') && !line.includes('"type": "worker_stats"')).join(`
+`);
+          if (nonWorkerStatsText.trim()) {
+            this.parseOutput(nonWorkerStatsText);
+          }
+        } else {
+          this.parseOutput(text);
+        }
         this.emit("stdout", text);
       });
     }
@@ -3426,7 +3438,65 @@ class IntegrationOperations {
   }
 }
 // src/integrations/checker.ts
+import { Client as Client9 } from "@botpress/client";
+
+// src/integrations/config-utils.ts
 import { Client as Client8 } from "@botpress/client";
+function mergeIntegrationConfig(current, desired) {
+  if (desired === undefined) {
+    return current || {};
+  }
+  return { ...current || {}, ...desired };
+}
+function configsMatch(current, desired, schemaDefaults = {}) {
+  return Object.keys(desired).every((key) => {
+    const currentValue = current?.[key] ?? schemaDefaults[key];
+    const desiredValue = desired[key] ?? schemaDefaults[key];
+    return JSON.stringify(currentValue) === JSON.stringify(desiredValue);
+  });
+}
+async function fetchServerIntegrationConfigs(project, targetBotId) {
+  const { devId, botId } = project.agentInfo ?? {};
+  const targetId = targetBotId || devId || botId;
+  if (!targetId) {
+    return { configs: {}, fetched: false, skipped: true };
+  }
+  try {
+    const credentials = await auth.getActiveCredentials();
+    const client = new Client8({
+      token: credentials.token,
+      apiUrl: credentials.apiUrl,
+      workspaceId: project.agentInfo?.workspaceId || credentials.workspaceId,
+      headers: { "x-multiple-integrations": "true" }
+    });
+    try {
+      return await fetchBotConfigs(client, targetId);
+    } catch (err) {
+      if (targetBotId) {
+        throw err;
+      }
+      if (devId && botId && devId !== botId) {
+        return await fetchBotConfigs(client, botId);
+      }
+      throw err;
+    }
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return { configs: {}, fetched: false, skipped: false, error: message };
+  }
+}
+async function fetchBotConfigs(client, botId) {
+  const { bot } = await client.getBot({ id: botId });
+  const configs = {};
+  for (const [alias, integration] of Object.entries(bot.integrations || {})) {
+    if (integration.configuration && Object.keys(integration.configuration).length > 0) {
+      configs[alias] = integration.configuration;
+    }
+  }
+  return { configs, fetched: true, skipped: false };
+}
+
+// src/integrations/checker.ts
 class IntegrationChecker {
   projectPath;
   client;
@@ -3441,7 +3511,7 @@ class IntegrationChecker {
       if (!workspaceId) {
         throw new Error('No workspace ID found. Please login with "adk login"');
       }
-      this.client = new Client8({
+      this.client = new Client9({
         token: credentials.token,
         apiUrl: credentials.apiUrl,
         workspaceId,
@@ -3579,17 +3649,8 @@ class IntegrationChecker {
       if (config !== undefined) {
         const configType = configurationType ?? installedIntegration.configurationType;
         const schema = configType && definition.configurations?.[configType]?.schema || definition.configurations?.["default"]?.schema || definition.configuration?.schema;
-        const schemaProperties = schema?.properties || {};
-        const allKeys = new Set([
-          ...Object.keys(installedIntegration.configuration || {}),
-          ...Object.keys(config || {})
-        ]);
-        const configsMatch = Array.from(allKeys).every((key) => {
-          const currentValue = installedIntegration.configuration?.[key] ?? schemaProperties[key]?.default;
-          const desiredValue = config?.[key] ?? schemaProperties[key]?.default;
-          return JSON.stringify(currentValue) === JSON.stringify(desiredValue);
-        });
-        if (!configsMatch) {
+        const schemaDefaults = Object.fromEntries(Object.entries(schema?.properties || {}).flatMap(([k, v]) => v?.default !== undefined ? [[k, v.default]] : []));
+        if (!configsMatch(installedIntegration.configuration, config, schemaDefaults)) {
           result.needsConfiguration = true;
         }
       }
@@ -3605,7 +3666,7 @@ class IntegrationChecker {
   }
 }
 // src/integrations/sync-manager.ts
-import { Client as Client9 } from "@botpress/client";
+import { Client as Client10 } from "@botpress/client";
 function normalizeConfigurationType(configType) {
   if (configType === "default" || configType === null) {
     return;
@@ -3627,7 +3688,7 @@ class IntegrationSyncManager {
       if (!workspaceId) {
         throw new Error('No workspace ID found. Please login with "adk login"');
       }
-      this.client = new Client9({
+      this.client = new Client10({
         token: credentials.token,
         apiUrl: credentials.apiUrl,
         workspaceId,
@@ -3670,7 +3731,7 @@ class IntegrationSyncManager {
               [result.alias]: {
                 integrationId: result.desiredIntegrationId || result.definition.id,
                 enabled: result.desiredInstallStatus === "enabled",
-                configuration: result.desiredConfiguration || {},
+                configuration: mergeIntegrationConfig(result.currentConfiguration, result.desiredConfiguration),
                 configurationType: normalizeConfigurationType(result.desiredConfigurationType)
               }
             }
@@ -3689,7 +3750,7 @@ class IntegrationSyncManager {
               [result.alias]: {
                 integrationId: result.desiredIntegrationId || result.definition.id,
                 enabled: result.desiredInstallStatus === "enabled",
-                configuration: result.desiredConfiguration || {},
+                configuration: mergeIntegrationConfig(result.currentConfiguration, result.desiredConfiguration),
                 configurationType: normalizeConfigurationType(result.desiredConfigurationType)
               }
             }
@@ -3706,7 +3767,7 @@ class IntegrationSyncManager {
   }
 }
 // src/interfaces/manager.ts
-import { Client as Client10 } from "@botpress/client";
+import { Client as Client11 } from "@botpress/client";
 
 // src/interfaces/enhanced-cache.ts
 import fs9 from "fs/promises";
@@ -3877,7 +3938,7 @@ class InterfaceManager {
       if (!this.options.workspaceId && !credentials.workspaceId) {
         throw new Error('No workspace ID found in current profile. Please login again with "adk login"');
       }
-      this.client = new Client10({
+      this.client = new Client11({
         token: credentials.token,
         apiUrl: credentials.apiUrl,
         workspaceId: this.options.workspaceId || credentials.workspaceId,
@@ -4875,7 +4936,7 @@ init_validation_errors();
 init_agent_resolver();
 init_types();
 // src/config/manager.ts
-import { Client as Client11 } from "@botpress/client";
+import { Client as Client12 } from "@botpress/client";
 import { sync as jex } from "@bpinternal/jex";
 class ConfigManager {
   botId;
@@ -4886,7 +4947,7 @@ class ConfigManager {
   async getClient() {
     if (!this.client) {
       const credentials = await auth.getActiveCredentials();
-      this.client = new Client11({
+      this.client = new Client12({
         token: credentials.token,
         apiUrl: credentials.apiUrl,
         botId: this.botId,
@@ -6347,7 +6408,7 @@ class AgentProjectGenerator {
         deploy: "adk deploy"
       },
       dependencies: {
-        "@botpress/runtime": `^${"1.13.18"}`
+        "@botpress/runtime": `^${"1.14.0"}`
       },
       devDependencies: {
         typescript: "^5.9.3"
@@ -6957,16 +7018,399 @@ Description: ${tag?.description}`);
     }
   };
 }
+// src/generators/client-wrapper.ts
+init_utils();
+init_fs();
+import path18 from "path";
+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;
+    }
+    try {
+      if (action.path === "<adk:builtin>") {
+        actionTypes.push({
+          name: action.definition.name,
+          inputType: "any",
+          outputType: "any"
+        });
+        continue;
+      }
+      const absolutePath = path18.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) {
+        const inputType = actionInstance.input.toTypescriptType ? actionInstance.input.toTypescriptType() : "any";
+        const outputType = actionInstance.output.toTypescriptType ? actionInstance.output.toTypescriptType() : "any";
+        actionTypes.push({
+          name: action.definition.name,
+          inputType,
+          outputType
+        });
+      }
+    } catch (error) {
+      console.warn(`Warning: Could not process action ${action.definition.name}:`, error);
+      actionTypes.push({
+        name: action.definition.name,
+        inputType: "any",
+        outputType: "any"
+      });
+    }
+  }
+  const workflowTypes = [];
+  for (const workflow of project.workflows) {
+    try {
+      if (isBuiltinWorkflow(workflow.definition.name)) {
+        continue;
+      }
+      const workflowPath = path18.join(project.path, workflow.path);
+      const workflowModule = await import(`${workflowPath}?t=${Date.now()}`);
+      const workflowInstance = workflowModule[workflow.export] || workflowModule.default;
+      if (workflowInstance) {
+        const inputType = workflowInstance.inputSchema ? workflowInstance.inputSchema.toTypescriptType?.() || "any" : "{}";
+        const outputType = workflowInstance.outputSchema ? workflowInstance.outputSchema.toTypescriptType?.() || "any" : "{}";
+        workflowTypes.push({
+          name: workflow.definition.name,
+          inputType,
+          outputType
+        });
+      }
+    } catch (error) {
+      console.warn(`Warning: Could not process workflow ${workflow.definition.name}:`, error);
+    }
+  }
+  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 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'
+
+// 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) => `
+    /**
+     * Call action: ${action.name}
+     */
+    '${action.name}': (input: ${action.inputType}) => Promise<${action.outputType}>
+    `).join(`
+`)}
+  }
+
+  /**
+   * Typed workflow operations
+   */
+  workflows: {
+    ${workflowTypes.map((workflow) => `
+    '${workflow.name}': {
+      /**
+       * Create workflow: ${workflow.name}
+       */
+      createWorkflow: (params: Omit<ParamCreateWorkflow, 'name' | 'input'> & { input?: ${workflow.inputType} }) => Promise<Omit<CreateWorkflowResponse, 'workflow'> & { workflow: TypedWorkflow<${workflow.inputType}, ${workflow.outputType}> }>
+      /**
+       * Get workflow by ID
+       */
+      getWorkflow: (params: ParamGetWorkflow) => Promise<Omit<GetWorkflowResponse, 'workflow'> & { workflow: TypedWorkflow<${workflow.inputType}, ${workflow.outputType}> }>
+      /**
+       * Update workflow
+       */
+      updateWorkflow: (params: Omit<ParamUpdateWorkflow, 'output'> & { output?: ${workflow.outputType} }) => Promise<Omit<UpdateWorkflowResponse, 'workflow'> & { workflow: TypedWorkflow<${workflow.inputType}, ${workflow.outputType}> }>
+      /**
+       * Delete workflow
+       */
+      deleteWorkflow: (params: ParamDeleteWorkflow) => Promise<DeleteWorkflowResponse>
+      /**
+       * Get or create workflow with deduplication key
+       */
+      getOrCreateWorkflow: (params: Omit<ParamGetOrCreateWorkflow, 'name' | 'input'> & { input?: ${workflow.inputType} }) => Promise<Omit<GetOrCreateWorkflowResponse, 'workflow'> & { workflow: TypedWorkflow<${workflow.inputType}, ${workflow.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: ${action.inputType}) => {
+        const response = await client.callAction({
+          type: '${action.name}',
+          input,
+        })
+        return response.output as ${action.outputType}
+      }
+      `).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");
+  await createFile(clientWrapperPath, await formatCode(content));
+}
 // 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 path19 from "path";
 init_utils();
 var sameMajorVersion = (a, b) => {
   const majorA = a.split(".")[0];
@@ -6987,8 +7431,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) {
@@ -7093,12 +7537,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) {
@@ -7184,14 +7628,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) {
@@ -7231,19 +7675,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) {
@@ -7274,14 +7718,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]) => {
@@ -7320,7 +7764,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);
@@ -7366,18 +7810,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) {
@@ -7401,26 +7845,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) {
@@ -7467,14 +7911,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;
@@ -7497,7 +7941,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) {
@@ -7583,14 +8027,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 = [];
@@ -7642,7 +8086,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));
 }
 
@@ -7652,7 +8096,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 {
@@ -7660,17 +8104,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;
   }
@@ -7684,17 +8128,17 @@ 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 Client12 } from "@botpress/client";
+import { Client as Client13 } from "@botpress/client";
 class DevIdManager {
   projectPath;
   botProjectPath;
@@ -7703,7 +8147,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) {
@@ -7713,7 +8157,7 @@ class DevIdManager {
       if (!workspaceId) {
         throw new Error('No workspace ID found in agent.json or current profile. Please login again with "adk login"');
       }
-      this.client = new Client12({
+      this.client = new Client13({
         token: credentials.token,
         apiUrl: credentials.apiUrl,
         workspaceId,
@@ -7740,7 +8184,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);
@@ -7789,7 +8233,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 {
@@ -7799,7 +8243,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);
@@ -7830,12 +8274,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;
       }
@@ -7867,8 +8311,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}`);
     }
@@ -7878,7 +8322,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 });
     }
@@ -7912,7 +8356,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();
@@ -7923,7 +8367,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 = [];
@@ -7941,12 +8385,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;
       }
@@ -7992,8 +8436,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}`);
     }
@@ -8003,7 +8447,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 });
     }
@@ -8040,24 +8484,29 @@ 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";
-function isBuiltinWorkflow2(name) {
-  return !!Object.values(BuiltInWorkflows3).find((x) => x.name === name);
+var plural = (n, word) => `${n} ${word}${n === 1 ? "" : "s"}`;
+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) {
     try {
@@ -8067,8 +8516,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 {
@@ -8089,7 +8538,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);
         }
       }
@@ -8121,6 +8570,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();
@@ -8133,18 +8583,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);
@@ -8165,11 +8615,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 {}
@@ -8219,6 +8669,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({
@@ -8238,7 +8692,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) {
@@ -8274,7 +8728,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);
@@ -8282,7 +8736,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 })));
@@ -8291,11 +8745,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);
@@ -8332,12 +8786,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 {}
@@ -8370,7 +8824,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;
@@ -8393,19 +8847,58 @@ 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) {
+      return;
+    }
+    if (serverConfigResult.error) {
+      this.callbacks.onError?.(`Failed to fetch remote configs: ${serverConfigResult.error}. Server-only config values may be overwritten.`);
+      return;
+    }
+    if (!serverConfigResult.fetched) {
+      return;
+    }
+    const configCount = Object.keys(serverConfigResult.configs).length;
+    if (configCount === 0) {
+      return;
+    }
+    this.callbacks.onSuccess?.(`Preserved remote configs for ${plural(configCount, "integration")}`);
+    for (const { alias, config: localConfig } of integrations) {
+      const serverConfig = serverConfigResult.configs[alias];
+      if (!serverConfig || Object.keys(serverConfig).length === 0) {
+        continue;
+      }
+      const preserved = Object.keys(serverConfig).filter((key) => !localConfig || !(key in localConfig));
+      if (preserved.length > 0) {
+        this.callbacks.onProgress?.(`  ${alias}: preserved ${plural(preserved.length, "remote field")} (${preserved.join(", ")})`);
+      }
+      if (localConfig) {
+        const overridden = Object.keys(localConfig).filter((key) => (key in serverConfig) && localConfig[key] !== serverConfig[key]);
+        if (overridden.length > 0) {
+          this.callbacks.onProgress?.(`  ${alias}: local overrides ${plural(overridden.length, "field")} (${overridden.join(", ")})`);
+        }
+      }
+    }
   }
   async generateBotDefinition() {
     const project = await AgentProject.load(this.projectPath);
     const integrations = project.integrations;
+    const enabledIntegrations = integrations.filter((i) => i.enabled);
+    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 = [];
-    for (const integration of integrations.filter((i) => i.enabled)) {
+    for (const integration of enabledIntegrations) {
       const { alias, configurationType, config } = integration;
       const importName = `integration_${getIntegrationAlias(alias)}`;
       imports.push(`import ${importName} from "./bp_modules/${importName}";`);
       const configType = configurationType && configurationType !== "default" ? `, configurationType: "${configurationType}"` : "";
-      const configData = config && Object.keys(config).length > 0 ? `, configuration: ${JSON.stringify(config)}` : "";
+      const mergedConfig = mergeIntegrationConfig(serverConfigResult.configs[alias], config);
+      const configData = Object.keys(mergedConfig).length > 0 ? `, configuration: ${JSON.stringify(mergedConfig)}` : "";
       addIntegrations.push(`bot.addIntegration(${importName}, { alias: "${alias}", enabled: true${configType}${configData} });`);
     }
     const botTags = {};
@@ -8445,10 +8938,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) {
@@ -8458,7 +8951,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) {
@@ -8703,7 +9196,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`
@@ -8742,7 +9235,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 = {
@@ -8756,7 +9249,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 = {
@@ -8787,7 +9280,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`
@@ -8810,11 +9303,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);
@@ -8823,8 +9316,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);
@@ -8836,16 +9329,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}";`
@@ -8871,14 +9364,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}";`
@@ -8904,7 +9397,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;
@@ -8913,7 +9406,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}";`
@@ -8923,7 +9416,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) {
@@ -8966,17 +9459,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,
@@ -8985,7 +9478,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);
@@ -9010,7 +9503,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;
@@ -9020,7 +9513,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}";`
@@ -9046,14 +9539,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}";`
@@ -9079,8 +9572,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
@@ -9146,13 +9639,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));
     }
   }
 }
@@ -9161,11 +9654,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:`);
@@ -9173,7 +9666,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:`);
@@ -9183,7 +9676,7 @@ async function generateBotProject(options) {
   }
 }
 // src/tables/table-manager.ts
-import { Client as Client13 } from "@botpress/client";
+import { Client as Client14 } from "@botpress/client";
 import { transforms as transforms4 } from "@botpress/sdk";
 class TableManager {
   client;
@@ -9197,7 +9690,7 @@ class TableManager {
     if (!this.client) {
       const credentials = await auth.getActiveCredentials();
       this.assertBotId("initialize client");
-      this.client = new Client13({
+      this.client = new Client14({
         token: credentials.token,
         apiUrl: credentials.apiUrl,
         botId: this.botId,
@@ -9682,10 +10175,10 @@ class TableManager {
 }
 // src/knowledge/manager.ts
 import crypto4 from "crypto";
-import path34 from "path";
+import path35 from "path";
 import fs17 from "fs/promises";
 import { glob } from "glob";
-import { Client as Client14 } from "@botpress/client";
+import { Client as Client15 } from "@botpress/client";
 import { DataSource } from "@botpress/runtime";
 
 // src/knowledge/types.ts
@@ -9730,7 +10223,7 @@ class KnowledgeManager {
     if (!this.client) {
       const credentials = await auth.getActiveCredentials();
       this.assertBotId("initialize client");
-      this.client = new Client14({
+      this.client = new Client15({
         token: credentials.token,
         apiUrl: credentials.apiUrl,
         botId: this.botId,
@@ -10132,14 +10625,14 @@ 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");
     }
@@ -10247,7 +10740,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");
     }
@@ -10269,8 +10762,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);
@@ -10352,7 +10845,7 @@ class KnowledgeManager {
         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,
@@ -10616,8 +11109,8 @@ class FileWatcher2 extends EventEmitter3 {
   }
 }
 // src/preflight/checker.ts
-import { Client as Client15 } from "@botpress/client";
-import path35 from "path";
+import { Client as Client16 } from "@botpress/client";
+import path36 from "path";
 
 // src/preflight/types.ts
 function hasIntegrationChanges(integrations) {
@@ -10831,7 +11324,7 @@ class PreflightChecker {
       if (!workspaceId) {
         throw new Error('No workspace ID found. Please login with "adk login"');
       }
-      this.client = new Client15({
+      this.client = new Client16({
         token: credentials.token,
         apiUrl: credentials.apiUrl,
         workspaceId,
@@ -10979,7 +11472,8 @@ 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");
   }
@@ -10988,19 +11482,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;
@@ -11012,7 +11506,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;
@@ -11021,9 +11515,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 {
@@ -11140,7 +11634,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();
@@ -11171,7 +11665,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,
@@ -11184,10 +11678,10 @@ class ScriptRunner {
         const runtimeModule = await import("@botpress/runtime/runtime");
         const { Autonomous } = await import("@botpress/runtime");
         const { context, agentRegistry } = runtimeModule;
-        const { Client: Client16 } = await import("@botpress/client");
+        const { Client: Client17 } = await import("@botpress/client");
         const { BotSpecificClient, BotLogger } = await import("@botpress/sdk");
         const { Cognitive } = await import("@botpress/cognitive");
-        const vanillaClient = new Client16({
+        const vanillaClient = new Client17({
           token: this.credentials.token,
           apiUrl: this.credentials.apiUrl,
           botId
@@ -11219,7 +11713,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}`);
     }
@@ -11318,6 +11812,7 @@ export {
   initAssets,
   getRelativeTime,
   generateIntegrationTypes,
+  generateClientWrapper,
   generateBotProject,
   generateAssetsTypes,
   generateAssetsRuntime,
@@ -11368,4 +11863,4 @@ export {
   AgentProject
 };
 
-//# debugId=91C6214D898FF0B464756E2164756E21
+//# debugId=B2A1E741C14E701164756E2164756E21