@botpress/runtime 1.2.3 → 1.2.5

package/dist/library.js

@@ -48,7 +48,7 @@ var init_define_BUILD = __esm({
 var define_PACKAGE_VERSIONS_default;
 var init_define_PACKAGE_VERSIONS = __esm({
   "<define:__PACKAGE_VERSIONS__>"() {
-    define_PACKAGE_VERSIONS_default = { runtime: "1.2.3", adk: "not-installed", sdk: "4.16.0", llmz: "0.0.26", zai: "2.1.16", cognitive: "0.1.47" };
+    define_PACKAGE_VERSIONS_default = { runtime: "1.2.5", adk: "not-installed", sdk: "4.16.0", llmz: "0.0.26", zai: "2.1.16", cognitive: "0.1.47" };
   }
 });
 
@@ -27463,6 +27463,47 @@ var require_indexv2 = __commonJS({
   }
 });
 
+// src/utilities/trigger-tags.ts
+var trigger_tags_exports = {};
+__export(trigger_tags_exports, {
+  getTriggerSubscriptionTags: () => getTriggerSubscriptionTags,
+  getTriggerTagName: () => getTriggerTagName,
+  getTriggerTagValue: () => getTriggerTagValue,
+  isConversationSubscribedToTrigger: () => isConversationSubscribedToTrigger
+});
+import crypto2 from "crypto";
+var hashString, getTriggerTagName, getTriggerTagValue, getTriggerSubscriptionTags, isConversationSubscribedToTrigger;
+var init_trigger_tags = __esm({
+  "src/utilities/trigger-tags.ts"() {
+    "use strict";
+    init_define_BUILD();
+    init_define_PACKAGE_VERSIONS();
+    hashString = (str) => {
+      return crypto2.createHash("md5").update(str).digest("hex").substring(0, 5).toUpperCase();
+    };
+    getTriggerTagName = (triggerName) => {
+      return `trigger${hashString(triggerName)}`;
+    };
+    getTriggerTagValue = (key) => {
+      return key ?? "*";
+    };
+    getTriggerSubscriptionTags = (triggerName, key) => {
+      return {
+        name: getTriggerTagName(triggerName),
+        value: getTriggerTagValue(key)
+      };
+    };
+    isConversationSubscribedToTrigger = (conversationTags, triggerName, triggerKey) => {
+      const tagName = getTriggerTagName(triggerName);
+      const tagValue = conversationTags[tagName];
+      if (!tagValue) {
+        return false;
+      }
+      return tagValue === "*" || tagValue === triggerKey;
+    };
+  }
+});
+
 // ../../node_modules/.bun/@isaacs+balanced-match@4.0.1/node_modules/@isaacs/balanced-match/dist/esm/index.js
 var balanced, maybeMatch, range;
 var init_esm3 = __esm({
@@ -36247,6 +36288,7 @@ init_define_PACKAGE_VERSIONS();
 // src/consts.ts
 init_define_BUILD();
 init_define_PACKAGE_VERSIONS();
+var LOG_DELIMITER = "<|MESSAGE_END|>\n";
 
 // src/runtime/context/handlers.ts
 import { Client } from "@botpress/client";
@@ -40241,6 +40283,8 @@ If the question is not related to the knowledge bases, do NOT use this tool.`.tr
         const { passages } = await client.searchFiles({
           query,
           withContext: true,
+          includeBreadcrumb: true,
+          contextDepth: 4,
           tags: {
             [WellKnownTags.knowledge.KNOWLEDGE]: "true",
             [WellKnownTags.knowledge.KNOWLEDGE_BASE_NAME]: kbNames
@@ -40284,8 +40328,9 @@ If the question is not related to the knowledge bases, do NOT use this tool.`.tr
             citationMetadata.sourceId = tags[WellKnownTags.knowledge.KNOWLEDGE_SOURCE_ID];
           }
           const { tag } = citations.registerSource(citationMetadata);
-          message.push(`<${tag} file="${p.file.key}">`);
-          message.push(`**${citationMetadata.title || p.file.key}**`);
+          message.push(
+            `<${tag} file="${p.file.key}" title="${citationMetadata.title || p.file.key}">`
+          );
           message.push(p.content);
           message.push(`</${tag}>`);
         }
@@ -40411,6 +40456,7 @@ Always prefer information from the knowledge bases over general knowledge when a
                                   message: "ThinkSignal"
                                 });
                                 err[HandledErrorProp] = true;
+                                throw err;
                               } else {
                                 s.setAttributes({
                                   "autonomous.tool.status": "error",
@@ -40941,7 +40987,17 @@ function serializeArgs(...args) {
   });
 }
 function writeStructuredLog(type, ...args) {
+  const output2 = process.stdout;
   const { spanId, traceId } = getTraceContext();
+  let maybeArgObj = null;
+  try {
+    maybeArgObj = typeof args[0] === "string" ? JSON.parse(args[0]) : args[0];
+  } catch {
+  }
+  if (maybeArgObj && typeof maybeArgObj === "object" && maybeArgObj.type === "worker_stats") {
+    output2.write((0, import_fast_safe_stringify3.default)(maybeArgObj) + LOG_DELIMITER);
+    return;
+  }
   const logEntry = {
     timestamp: (/* @__PURE__ */ new Date()).toISOString(),
     type,
@@ -40953,8 +41009,7 @@ function writeStructuredLog(type, ...args) {
   if (traceId) {
     logEntry.traceId = traceId;
   }
-  const output2 = process.stdout;
-  output2.write(JSON.stringify(logEntry) + "\n");
+  output2.write((0, import_fast_safe_stringify3.default)(logEntry) + LOG_DELIMITER);
 }
 function installStructuredLogging() {
   console.log = (...args) => {
@@ -40975,36 +41030,9 @@ function installStructuredLogging() {
 }
 
 // src/runtime.ts
+init_trigger_tags();
 import { z as z4 } from "@botpress/sdk";
 
-// src/utilities/trigger-tags.ts
-init_define_BUILD();
-init_define_PACKAGE_VERSIONS();
-import crypto2 from "crypto";
-var hashString = (str) => {
-  return crypto2.createHash("md5").update(str).digest("hex").substring(0, 5).toUpperCase();
-};
-var getTriggerTagName = (triggerName) => {
-  return `trigger${hashString(triggerName)}`;
-};
-var getTriggerTagValue = (key) => {
-  return key ?? "*";
-};
-var getTriggerSubscriptionTags = (triggerName, key) => {
-  return {
-    name: getTriggerTagName(triggerName),
-    value: getTriggerTagValue(key)
-  };
-};
-var isConversationSubscribedToTrigger = (conversationTags, triggerName, triggerKey) => {
-  const tagName = getTriggerTagName(triggerName);
-  const tagValue = conversationTags[tagName];
-  if (!tagValue) {
-    return false;
-  }
-  return tagValue === "*" || tagValue === triggerKey;
-};
-
 // src/types.ts
 init_define_BUILD();
 init_define_PACKAGE_VERSIONS();
@@ -41606,12 +41634,6 @@ var BaseWorkflowInstance = class _BaseWorkflowInstance {
   workflow;
   // @internal
   TrackedState;
-  set state(state) {
-    this.TrackedState.value = state;
-  }
-  get state() {
-    return this.TrackedState.value;
-  }
   constructor(workflow, client) {
     const definition = adk.project.workflows.find(
       (w) => w.name === workflow.name
@@ -41621,7 +41643,7 @@ var BaseWorkflowInstance = class _BaseWorkflowInstance {
       client: client._inner,
       id: workflow.id,
       schema: definition?.stateSchema,
-      name: "workflowState"
+      name: BUILT_IN_STATES.workflowState
     });
     this.id = workflow.id;
     this.name = workflow.name;
@@ -41752,14 +41774,25 @@ var BaseWorkflowInstance = class _BaseWorkflowInstance {
         "Workflow execution state is not loaded"
       );
       workflowExecutionState.value.executionCount++;
+      if (!this.TrackedState.value) {
+        this.TrackedState.value = {};
+      }
+      const trackedState = this.TrackedState;
+      const stateProxy = new Proxy(this.TrackedState.value, {
+        set(target, prop, value) {
+          const result2 = Reflect.set(target, prop, value);
+          trackedState.markDirty();
+          return result2;
+        }
+      });
       const result = await context.run(
         {
           ...ctx,
           workflowControlContext
         },
-        async () => handler.call(this, {
+        async () => handler({
           input: this.input,
-          state: this.state,
+          state: stateProxy,
           step,
           client: this.client,
           execute: this.execute.bind(this)
@@ -41825,7 +41858,7 @@ function createWorkflowExecutionState(client, workflowId) {
     client,
     id: workflowId,
     schema: workflowExecutionContextSchema,
-    name: "workflowExecutionContext"
+    name: BUILT_IN_STATES.workflowSteps
   });
 }
 
@@ -41852,8 +41885,6 @@ var BaseWorkflow = class {
   /** @internal */
   schedule;
   timeout = (0, import_ms.default)("5m");
-  // Runtime state
-  state;
   constructor(props) {
     this.name = props.name;
     if (props.description !== void 0) {
@@ -42216,10 +42247,15 @@ var EMPTY_STATE = {
 };
 var MAX_SWAP_FILE_SIZE = import_bytes2.default.parse("100MB");
 var BUILT_IN_STATES = {
-  user: "userState",
+  /** Generic conversation-specific state (user-defined per conversation) */
   conversation: "state",
+  /** User-specific state (persists across conversations per user) */
+  user: "userState",
+  /** Bot-wide global state (persists across all conversations) */
   bot: "botState",
+  /** Workflow-specific state (persists across workflow executions) */
   workflowState: "workflowState",
+  /** Workflow cached steps executions */
   workflowSteps: "workflowSteps"
 };
 var TrackedState = class _TrackedState {
@@ -42292,6 +42328,7 @@ var TrackedState = class _TrackedState {
       const client = context.get("client")._inner;
       const botId = context.get("botId", { optional: true });
       const user2 = context.get("user", { optional: true });
+      const conversation = context.get("conversation", { optional: true });
       if (botId) {
         _TrackedState.create({
           client,
@@ -42310,6 +42347,23 @@ var TrackedState = class _TrackedState {
           schema: adk.project.config.user?.state || z12.object({})
         });
       }
+      if (conversation) {
+        const definition = adk.project.conversations.find((c) => {
+          const def = c.getDefinition();
+          if (typeof def.channel === "string") {
+            return def.channel === conversation.channel || def.channel === "*";
+          } else {
+            return def.channel.includes(conversation.channel);
+          }
+        });
+        _TrackedState.create({
+          client,
+          name: BUILT_IN_STATES.conversation,
+          type: "conversation",
+          id: conversation.id,
+          schema: definition?.schema || z12.object({})
+        });
+      }
       const states = context.get("states", { optional: true });
       const promises = Promise.allSettled(
         states?.map((state) => state.load()) ?? []
@@ -42356,16 +42410,23 @@ var TrackedState = class _TrackedState {
         } else {
           this.value = value;
         }
-        if ((this.value == null || this.value === void 0) && this.state && "parse" in this.state) {
-          try {
-            this.value = this.state.parse({});
-            this._isDirty = true;
-          } catch (error) {
+        if (this.value == null || this.value === void 0) {
+          if (this.state && "parse" in this.state) {
             try {
-              this.value = this.state.parse(void 0);
+              this.value = this.state.parse({});
               this._isDirty = true;
-            } catch {
+            } catch (error) {
+              try {
+                this.value = this.state.parse(void 0);
+                this._isDirty = true;
+              } catch {
+                this.value = {};
+                this._isDirty = true;
+              }
             }
+          } else {
+            this.value = {};
+            this._isDirty = true;
           }
         }
         try {
@@ -42961,24 +43022,145 @@ init_define_BUILD();
 init_define_PACKAGE_VERSIONS();
 import { z as z16 } from "@botpress/sdk";
 import { setTimeout as setTimeout2 } from "node:timers/promises";
+
+// src/primitives/conversation-instance.ts
+init_define_BUILD();
+init_define_PACKAGE_VERSIONS();
+var BaseConversationInstance = class {
+  id;
+  channel;
+  integration;
+  tags;
+  conversation;
+  // @internal
+  client;
+  // @internal
+  TrackedState;
+  constructor(conversation, client) {
+    this.id = conversation.id;
+    this.channel = conversation.channel;
+    this.integration = conversation.integration;
+    this.tags = conversation.tags;
+    this.conversation = conversation;
+    this.client = client;
+    const states = context.get("states", { optional: true });
+    const existingState = states?.find(
+      (s) => s.type === "conversation" && s.id === conversation.id && s.name === BUILT_IN_STATES.conversation
+    );
+    if (!existingState) {
+      throw new Error(
+        `Conversation state not found for conversation ${conversation.id}. Make sure TrackedState.loadAll() is called before creating conversation instances.`
+      );
+    }
+    this.TrackedState = existingState;
+  }
+  /**
+   * Send a message to this conversation
+   */
+  async send(message) {
+    try {
+      const chat = context.get("chat");
+      await trackPromise(
+        chat.sendMessage({
+          type: message.type,
+          payload: message.payload
+        })
+      );
+    } catch (err) {
+      console.error("Error sending message in conversation:", err);
+    }
+  }
+  /**
+   * Start typing indicator
+   */
+  async startTyping() {
+    const mapping = InterfaceMappings.getIntegrationAction(
+      "typingIndicator",
+      "startTypingIndicator",
+      this.integration
+    );
+    if (mapping) {
+      const message = context.get("message", { optional: true });
+      await this.client.callAction({
+        type: mapping,
+        input: {
+          conversationId: this.id,
+          messageId: message?.id
+        }
+      }).catch(() => {
+      });
+    }
+  }
+  /**
+   * Stop typing indicator
+   */
+  async stopTyping() {
+    const mapping = InterfaceMappings.getIntegrationAction(
+      "typingIndicator",
+      "stopTypingIndicator",
+      this.integration
+    );
+    if (mapping) {
+      const message = context.get("message", { optional: true });
+      await this.client.callAction({
+        type: mapping,
+        input: {
+          conversationId: this.id,
+          messageId: message?.id
+        }
+      }).catch(() => {
+      });
+    }
+  }
+  /**
+   * Subscribe to a trigger
+   */
+  async subscribeToTrigger(triggerName, key) {
+    const { getTriggerSubscriptionTags: getTriggerSubscriptionTags2, isConversationSubscribedToTrigger: isConversationSubscribedToTrigger2 } = await Promise.resolve().then(() => (init_trigger_tags(), trigger_tags_exports));
+    if (isConversationSubscribedToTrigger2(this.tags, triggerName, key)) {
+      return;
+    }
+    const { name, value } = getTriggerSubscriptionTags2(triggerName, key);
+    await this.client.updateConversation({
+      id: this.id,
+      tags: {
+        [name]: value
+      }
+    });
+  }
+  /**
+   * Unsubscribe from a trigger
+   */
+  async unsubscribeFromTrigger(triggerName, key) {
+    const { getTriggerSubscriptionTags: getTriggerSubscriptionTags2, isConversationSubscribedToTrigger: isConversationSubscribedToTrigger2 } = await Promise.resolve().then(() => (init_trigger_tags(), trigger_tags_exports));
+    if (!isConversationSubscribedToTrigger2(this.tags, triggerName, key)) {
+      return;
+    }
+    const { name } = getTriggerSubscriptionTags2(triggerName, key);
+    await this.client.updateConversation({
+      id: this.id,
+      tags: {
+        [name]: ""
+      }
+    });
+  }
+};
+
+// src/primitives/conversation.ts
 var ConversationHandler = Symbol.for("conversation.handler");
 var Typings3;
 ((Typings8) => {
   Typings8.Primitive = "conversation";
 })(Typings3 || (Typings3 = {}));
 var BaseConversation = class {
-  integration;
   channel;
   /** @internal */
   schema;
   #handler;
-  #state;
   #startFromTrigger;
-  #interruptionSignal;
   constructor(props) {
     this.channel = props.channel;
     this.schema = props.state ?? z16.object({}).passthrough();
-    this.integration = props.channel.split(".")[0];
     this.#handler = props.handler;
     if (props.startFromTrigger) {
       this.#startFromTrigger = props.startFromTrigger;
@@ -42990,31 +43172,34 @@ var BaseConversation = class {
   }
   /** @internal */
   getDefinition() {
-    return {
-      type: "conversation",
-      channel: this.channel
-    };
-  }
-  set state(state) {
-    this.#state = state;
-  }
-  get state() {
-    return this.#state;
-  }
-  get id() {
-    return context.get("conversation").id;
-  }
-  get tags() {
-    return context.get("conversation").tags;
+    if (this.channel === "*") {
+      return {
+        type: "conversation",
+        channel: "*"
+      };
+    } else if (Array.isArray(this.channel)) {
+      return {
+        type: "conversation",
+        channel: this.channel
+      };
+    } else {
+      return {
+        type: "conversation",
+        channel: this.channel
+      };
+    }
   }
-  // TODO: separate the handler from the conversation definition
-  // TODO: each execution should have its own instance to avoid state conflicts etc
+  /** @internal */
   async [ConversationHandler]() {
     const message = context.get("message", { optional: true });
     const event = context.get("event", { optional: true });
     const chat = context.get("chat");
     const client = context.get("client");
-    const conversationId = this.id;
+    const botpressConversation = context.get("conversation");
+    const conversationInstance = new BaseConversationInstance(
+      botpressConversation,
+      client
+    );
     let type;
     let requestObject = void 0;
     if (message) {
@@ -43039,11 +43224,10 @@ var BaseConversation = class {
       type = "event";
     }
     const controller = new AbortController();
-    this.#interruptionSignal = controller.signal;
     void span(
       "interruption.check",
       {
-        conversationId
+        conversationId: conversationInstance.id
       },
       async (s) => {
         async function checkNewUserMessage() {
@@ -43051,7 +43235,7 @@ var BaseConversation = class {
             return;
           }
           const { events } = await client.listEvents({
-            conversationId,
+            conversationId: conversationInstance.id,
             status: "pending"
           });
           const newEvents = events.filter(
@@ -43107,100 +43291,36 @@ var BaseConversation = class {
     const execute = Autonomous.createExecute({
       mode: "chat",
       defaultModel: adk.project.config.defaultModels.autonomous,
-      ...this.#interruptionSignal && {
-        interruption: this.#interruptionSignal
+      interruption: controller.signal
+    });
+    if (!conversationInstance.TrackedState.value) {
+      conversationInstance.TrackedState.value = {};
+    }
+    const stateProxy = new Proxy(conversationInstance.TrackedState.value, {
+      set(target, prop, value) {
+        const result = Reflect.set(target, prop, value);
+        conversationInstance.TrackedState.markDirty();
+        return result;
       }
     });
-    await this.#handler.call(this, {
+    await this.#handler({
       type,
       message,
       event,
       request: requestObject,
+      conversation: conversationInstance,
+      state: stateProxy,
+      client,
       execute
     });
     controller.abort();
   }
-  async subscribeToTrigger(triggerName, key) {
-    if (isConversationSubscribedToTrigger(this.tags, triggerName, key)) {
-      return;
-    }
-    const conversation = context.get("conversation");
-    const client = context.get("client");
-    const { name, value } = getTriggerSubscriptionTags(triggerName, key);
-    await client.updateConversation({
-      id: conversation.id,
-      tags: {
-        [name]: value
-      }
-    });
-  }
-  async unsubscribeFromTrigger(triggerName, key) {
-    if (!isConversationSubscribedToTrigger(this.tags, triggerName, key)) {
-      return;
-    }
-    const conversation = context.get("conversation");
-    const client = context.get("client");
-    const { name } = getTriggerSubscriptionTags(triggerName, key);
-    await client.updateConversation({
-      id: conversation.id,
-      tags: {
-        [name]: ""
-      }
-    });
-  }
-  async startTyping() {
-    const conversation = context.get("conversation", { optional: true });
-    const message = context.get("message", { optional: true });
-    const mapping = InterfaceMappings.getIntegrationAction(
-      "typingIndicator",
-      "startTypingIndicator",
-      conversation?.integration
-    );
-    if (conversation && mapping) {
-      await context.get("client").callAction({
-        type: mapping,
-        input: {
-          conversationId: conversation.id,
-          messageId: message?.id
-        }
-      }).catch(() => {
-      });
-    }
-  }
-  async stopTyping() {
-    const conversation = context.get("conversation", { optional: true });
-    const message = context.get("message", { optional: true });
-    const mapping = InterfaceMappings.getIntegrationAction(
-      "typingIndicator",
-      "stopTypingIndicator",
-      conversation?.integration
-    );
-    if (conversation && mapping) {
-      await context.get("client").callAction({
-        type: mapping,
-        input: {
-          conversationId: conversation.id,
-          messageId: message?.id
-        }
-      }).catch(() => {
-      });
-    }
-  }
-  async send(message) {
-    try {
-      const chat = context.get("chat");
-      await trackPromise(
-        chat.sendMessage({
-          type: message.type,
-          payload: message.payload
-        })
-      );
-    } catch (err) {
-      console.error("Error getting context in conversation.send:", err);
-    }
-  }
 };
 
+// src/runtime/handlers/conversation-matching.ts
+init_define_BUILD();
+init_define_PACKAGE_VERSIONS();
+
 // src/runtime/handlers/trigger.ts
 init_define_BUILD();
 init_define_PACKAGE_VERSIONS();
@@ -43225,7 +43345,12 @@ var Definitions;
 ((Definitions2) => {
   const conversationDefinitionSchema = z17.object({
     type: z17.literal("conversation"),
-    channel: z17.string().min(1, "Channel must be a non-empty string").max(255, "Channel must be less than 255 characters").regex(/^[a-zA-Z0-9._-]+$/, "Channel must be a valid identifier")
+    channel: z17.union([
+      z17.string().min(1, "Channel must be a non-empty string").max(255, "Channel must be less than 255 characters").regex(/^(\*|[a-zA-Z0-9._-]+)$/, "Channel must be a valid identifier or glob '*'"),
+      z17.array(
+        z17.string().min(1, "Channel must be a non-empty string").max(255, "Channel must be less than 255 characters").regex(/^[a-zA-Z0-9._-]+$/, "Channel must be a valid identifier")
+      )
+    ])
   });
   const workflowDefinitionSchema = z17.object({
     type: z17.literal("workflow"),
@@ -45475,6 +45600,7 @@ var BaseKnowledge = class {
   constructor(props) {
     this.name = props.name;
     this.sources = props.sources;
+    this.description = props.description;
   }
   /** @internal */
   getDefinition() {
@@ -45848,6 +45974,7 @@ var Primitives;
 ((Primitives2) => {
   Primitives2.Definitions = Definitions;
   Primitives2.BaseConversation = BaseConversation;
+  Primitives2.BaseConversationInstance = BaseConversationInstance;
   Primitives2.Conversation = Typings3;
   Primitives2.BaseKnowledge = BaseKnowledge;
   Primitives2.Knowledge = Typings4;
@@ -45876,6 +46003,7 @@ init_define_PACKAGE_VERSIONS();
 export {
   Action,
   Autonomous,
+  BaseConversationInstance,
   BaseConversation as Conversation,
   DataSource2 as DataSource,
   Errors,