@botpress/adk 1.14.0 → 1.14.1

package/dist/generators/client-wrapper.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"client-wrapper.d.ts","sourceRoot":"","sources":["../../src/generators/client-wrapper.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,YAAY,EAAE,MAAM,mCAAmC,CAAA;AAShE,wBAAsB,qBAAqB,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC,CAibhF"}
+{"version":3,"file":"client-wrapper.d.ts","sourceRoot":"","sources":["../../src/generators/client-wrapper.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,YAAY,EAAE,MAAM,mCAAmC,CAAA;AAShE,wBAAsB,qBAAqB,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC,CA6dhF"}

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.14.0", 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}`;
@@ -809,7 +794,7 @@ var init_integration_action_types = __esm(() => {
 var require_package = __commonJS((exports, module) => {
   module.exports = {
     name: "@botpress/adk",
-    version: "1.14.0",
+    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.14.0",
+      "@botpress/runtime": "^1.14.1",
       "@botpress/sdk": "^5.1.0",
       "@bpinternal/jex": "^1.2.4",
       "@bpinternal/yargs-extra": "^0.0.21",
@@ -6408,7 +6393,7 @@ class AgentProjectGenerator {
         deploy: "adk deploy"
       },
       dependencies: {
-        "@botpress/runtime": `^${"1.14.0"}`
+        "@botpress/runtime": `^${"1.14.1"}`
       },
       devDependencies: {
         typescript: "^5.9.3"
@@ -7022,6 +7007,8 @@ Description: ${tag?.description}`);
 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);
@@ -7032,57 +7019,32 @@ async function generateClientWrapper(project) {
     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);
+    if (action.path === "<adk:builtin>") {
       actionTypes.push({
         name: action.definition.name,
-        inputType: "any",
-        outputType: "any"
+        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) {
-    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);
+    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) {
@@ -7118,6 +7080,21 @@ async function generateClientWrapper(project) {
       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
 ////////////////////////////////////////////////////////
@@ -7128,6 +7105,10 @@ async function generateClientWrapper(project) {
 ////////////////////////////////////////////////////////
 
 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
@@ -7195,12 +7176,23 @@ export interface AdkClient {
    * Typed action calls
    */
   actions: {
-    ${actionTypes.map((action) => `
+    ${actionTypes.map((action) => {
+    if (action.isBuiltin) {
+      return `
     /**
      * Call action: ${action.name}
      */
-    '${action.name}': (input: ${action.inputType}) => Promise<${action.outputType}>
-    `).join(`
+    '${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(`
 `)}
   }
 
@@ -7208,20 +7200,23 @@ export interface AdkClient {
    * Typed workflow operations
    */
   workflows: {
-    ${workflowTypes.map((workflow) => `
+    ${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?: ${workflow.inputType} }) => Promise<Omit<CreateWorkflowResponse, 'workflow'> & { workflow: TypedWorkflow<${workflow.inputType}, ${workflow.outputType}> }>
+      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<${workflow.inputType}, ${workflow.outputType}> }>
+      getWorkflow: (params: ParamGetWorkflow) => Promise<Omit<GetWorkflowResponse, 'workflow'> & { workflow: TypedWorkflow<${inputType}, ${outputType}> }>
       /**
        * Update workflow
        */
-      updateWorkflow: (params: Omit<ParamUpdateWorkflow, 'output'> & { output?: ${workflow.outputType} }) => Promise<Omit<UpdateWorkflowResponse, 'workflow'> & { workflow: TypedWorkflow<${workflow.inputType}, ${workflow.outputType}> }>
+      updateWorkflow: (params: Omit<ParamUpdateWorkflow, 'output'> & { output?: ${outputType} }) => Promise<Omit<UpdateWorkflowResponse, 'workflow'> & { workflow: TypedWorkflow<${inputType}, ${outputType}> }>
       /**
        * Delete workflow
        */
@@ -7229,9 +7224,10 @@ export interface AdkClient {
       /**
        * 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}> }>
+      getOrCreateWorkflow: (params: Omit<ParamGetOrCreateWorkflow, 'name' | 'input'> & { input?: ${inputType} }) => Promise<Omit<GetOrCreateWorkflowResponse, 'workflow'> & { workflow: TypedWorkflow<${inputType}, ${outputType}> }>
     }
-    `).join(`
+    `;
+  }).join(`
 `)}
   }
 
@@ -7310,12 +7306,12 @@ export function createAdkClient(client: Client): AdkClient {
   return {
     actions: {
       ${actionTypes.map((action) => `
-      '${action.name}': async (input: ${action.inputType}) => {
+      '${action.name}': async (input) => {
         const response = await client.callAction({
           type: '${action.name}',
           input,
         })
-        return response.output as ${action.outputType}
+        return response.output as any
       }
       `).join(`,
 `)}
@@ -7399,7 +7395,16 @@ export function createAdkClient(client: Client): AdkClient {
 }
 `;
   const clientWrapperPath = path18.join(project.path, ".adk", "client.ts");
-  await createFile(clientWrapperPath, await formatCode(content));
+  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";
@@ -7409,7 +7414,7 @@ import path34 from "path";
 
 // src/generators/interface-types.ts
 import { transforms as transforms2 } from "@botpress/sdk";
-import crypto3 from "crypto";
+import crypto4 from "crypto";
 import path19 from "path";
 init_utils();
 var sameMajorVersion = (a, b) => {
@@ -7422,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),
@@ -8921,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;
@@ -10174,7 +10179,7 @@ class TableManager {
   }
 }
 // src/knowledge/manager.ts
-import crypto4 from "crypto";
+import crypto5 from "crypto";
 import path35 from "path";
 import fs17 from "fs/promises";
 import { glob } from "glob";
@@ -10265,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();
@@ -10380,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();
@@ -10634,7 +10639,7 @@ class KnowledgeManager {
     for (const file of files) {
       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;
@@ -10838,7 +10843,7 @@ 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) {
@@ -11863,4 +11868,4 @@ export {
   AgentProject
 };
 
-//# debugId=B2A1E741C14E701164756E2164756E21
+//# debugId=9C7E68110BCAF64064756E2164756E21