@botpress/runtime 1.2.3 → 1.2.5

package/dist/runtime.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({
@@ -35610,6 +35651,7 @@ var CONFIGURATION_TYPE_HEADER = "x-bp-configuration-type";
 var CONFIGURATION_PAYLOAD_HEADER = "x-bp-configuration";
 var OPERATION_TYPE_HEADER = "x-bp-operation";
 var OPERATION_SUBTYPE_HEADER = "x-bp-type";
+var LOG_DELIMITER = "<|MESSAGE_END|>\n";
 
 // src/runtime/context/http.ts
 var decodeBase64Obj = (str) => {
@@ -39715,6 +39757,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
@@ -39758,8 +39802,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}>`);
         }
@@ -39885,6 +39930,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",
@@ -40357,6 +40403,129 @@ init_define_PACKAGE_VERSIONS();
 init_define_BUILD();
 init_define_PACKAGE_VERSIONS();
 
+// 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 = context2.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 = context2.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 = context2.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 = context2.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/definition.ts
 init_define_BUILD();
 init_define_PACKAGE_VERSIONS();
@@ -40365,7 +40534,12 @@ var Definitions;
 ((Definitions2) => {
   const conversationDefinitionSchema = z3.object({
     type: z3.literal("conversation"),
-    channel: z3.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: z3.union([
+      z3.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 '*'"),
+      z3.array(
+        z3.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 = z3.object({
     type: z3.literal("workflow"),
@@ -42662,34 +42836,6 @@ init_define_PACKAGE_VERSIONS();
 import { z as z8 } from "@botpress/sdk";
 import { setTimeout as setTimeout2 } from "node:timers/promises";
 
-// 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/utilities/events.ts
 init_define_BUILD();
 init_define_PACKAGE_VERSIONS();
@@ -42714,18 +42860,14 @@ var Typings2;
   Typings8.Primitive = "conversation";
 })(Typings2 || (Typings2 = {}));
 var BaseConversation = class {
-  integration;
   channel;
   /** @internal */
   schema;
   #handler;
-  #state;
   #startFromTrigger;
-  #interruptionSignal;
   constructor(props) {
     this.channel = props.channel;
     this.schema = props.state ?? z8.object({}).passthrough();
-    this.integration = props.channel.split(".")[0];
     this.#handler = props.handler;
     if (props.startFromTrigger) {
       this.#startFromTrigger = props.startFromTrigger;
@@ -42737,31 +42879,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 context2.get("conversation").id;
-  }
-  get tags() {
-    return context2.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 = context2.get("message", { optional: true });
     const event = context2.get("event", { optional: true });
     const chat = context2.get("chat");
     const client = context2.get("client");
-    const conversationId = this.id;
+    const botpressConversation = context2.get("conversation");
+    const conversationInstance = new BaseConversationInstance(
+      botpressConversation,
+      client
+    );
     let type;
     let requestObject = void 0;
     if (message) {
@@ -42786,11 +42931,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() {
@@ -42798,7 +42942,7 @@ var BaseConversation = class {
             return;
           }
           const { events } = await client.listEvents({
-            conversationId,
+            conversationId: conversationInstance.id,
             status: "pending"
           });
           const newEvents = events.filter(
@@ -42854,98 +42998,30 @@ 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 = context2.get("conversation");
-    const client = context2.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 = context2.get("conversation");
-    const client = context2.get("client");
-    const { name } = getTriggerSubscriptionTags(triggerName, key);
-    await client.updateConversation({
-      id: conversation.id,
-      tags: {
-        [name]: ""
-      }
-    });
-  }
-  async startTyping() {
-    const conversation = context2.get("conversation", { optional: true });
-    const message = context2.get("message", { optional: true });
-    const mapping = InterfaceMappings.getIntegrationAction(
-      "typingIndicator",
-      "startTypingIndicator",
-      conversation?.integration
-    );
-    if (conversation && mapping) {
-      await context2.get("client").callAction({
-        type: mapping,
-        input: {
-          conversationId: conversation.id,
-          messageId: message?.id
-        }
-      }).catch(() => {
-      });
-    }
-  }
-  async stopTyping() {
-    const conversation = context2.get("conversation", { optional: true });
-    const message = context2.get("message", { optional: true });
-    const mapping = InterfaceMappings.getIntegrationAction(
-      "typingIndicator",
-      "stopTypingIndicator",
-      conversation?.integration
-    );
-    if (conversation && mapping) {
-      await context2.get("client").callAction({
-        type: mapping,
-        input: {
-          conversationId: conversation.id,
-          messageId: message?.id
-        }
-      }).catch(() => {
-      });
-    }
-  }
-  async send(message) {
-    try {
-      const chat = context2.get("chat");
-      await trackPromise(
-        chat.sendMessage({
-          type: message.type,
-          payload: message.payload
-        })
-      );
-    } catch (err) {
-      console.error("Error getting context in conversation.send:", err);
-    }
-  }
 };
 
 // src/primitives/knowledge.ts
@@ -42962,6 +43038,7 @@ var BaseKnowledge = class {
   constructor(props) {
     this.name = props.name;
     this.sources = props.sources;
+    this.description = props.description;
   }
   /** @internal */
   getDefinition() {
@@ -43335,6 +43412,7 @@ var Primitives;
 ((Primitives2) => {
   Primitives2.Definitions = Definitions;
   Primitives2.BaseConversation = BaseConversation;
+  Primitives2.BaseConversationInstance = BaseConversationInstance;
   Primitives2.Conversation = Typings2;
   Primitives2.BaseKnowledge = BaseKnowledge;
   Primitives2.Knowledge = Typings3;
@@ -43944,22 +44022,16 @@ 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
     );
-    this.TrackedState = TrackedState.create({
+    this.TrackedState = TrackedState2.create({
       type: "workflow",
       client: client._inner,
       id: workflow.id,
       schema: definition?.stateSchema,
-      name: "workflowState"
+      name: BUILT_IN_STATES.workflowState
     });
     this.id = workflow.id;
     this.name = workflow.name;
@@ -44043,7 +44115,7 @@ var BaseWorkflowInstance = class _BaseWorkflowInstance {
         `No ADK Workflow handler found for "${this.name}"`
       );
     }
-    await TrackedState.loadAll();
+    await TrackedState2.loadAll();
     const workflowControlContext = {
       workflow: this.workflow,
       aborted: false,
@@ -44090,14 +44162,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 context2.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)
@@ -44126,7 +44209,7 @@ var BaseWorkflowInstance = class _BaseWorkflowInstance {
         };
       }
     } finally {
-      await TrackedState.saveAllDirty();
+      await TrackedState2.saveAllDirty();
     }
   }
   /**
@@ -44158,12 +44241,12 @@ var BaseWorkflowInstance = class _BaseWorkflowInstance {
   }
 };
 function createWorkflowExecutionState(client, workflowId) {
-  return TrackedState.create({
+  return TrackedState2.create({
     type: "workflow",
     client,
     id: workflowId,
     schema: workflowExecutionContextSchema,
-    name: "workflowExecutionContext"
+    name: BUILT_IN_STATES.workflowSteps
   });
 }
 
@@ -44190,8 +44273,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) {
@@ -44559,13 +44640,18 @@ 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 {
+var TrackedState2 = class _TrackedState {
   type;
   id;
   name;
@@ -44635,6 +44721,7 @@ var TrackedState = class _TrackedState {
       const client = context2.get("client")._inner;
       const botId = context2.get("botId", { optional: true });
       const user2 = context2.get("user", { optional: true });
+      const conversation = context2.get("conversation", { optional: true });
       if (botId) {
         _TrackedState.create({
           client,
@@ -44653,6 +44740,23 @@ var TrackedState = class _TrackedState {
           schema: adk.project.config.user?.state || z20.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 || z20.object({})
+        });
+      }
       const states = context2.get("states", { optional: true });
       const promises = Promise.allSettled(
         states?.map((state) => state.load()) ?? []
@@ -44699,16 +44803,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 {
@@ -45110,12 +45221,12 @@ var patchHandlers = (bot2) => {
                     reject(error);
                   } finally {
                     clearTimeout(timeout);
-                    await TrackedState.saveAllDirty();
+                    await TrackedState2.saveAllDirty();
                   }
                 });
               } finally {
-                await TrackedState.saveAllDirty();
-                TrackedState.unloadAll();
+                await TrackedState2.saveAllDirty();
+                TrackedState2.unloadAll();
                 await shutdownPromiseTracker();
               }
             }
@@ -46058,6 +46169,31 @@ __export(conversation_exports, {
 });
 init_define_BUILD();
 init_define_PACKAGE_VERSIONS();
+
+// src/runtime/handlers/conversation-matching.ts
+init_define_BUILD();
+init_define_PACKAGE_VERSIONS();
+function matchesChannel(handlerChannel, incomingChannel) {
+  if (handlerChannel === "*") {
+    return true;
+  } else if (Array.isArray(handlerChannel)) {
+    return handlerChannel.includes(incomingChannel);
+  } else {
+    return handlerChannel === incomingChannel;
+  }
+}
+function findMatchingHandler(handlers2, incomingChannel) {
+  const matchingHandlers = handlers2.filter(
+    (h) => matchesChannel(h.channel, incomingChannel)
+  );
+  return matchingHandlers.sort((a, b) => {
+    const aScore = a.channel === "*" ? 0 : Array.isArray(a.channel) ? 1 : 2;
+    const bScore = b.channel === "*" ? 0 : Array.isArray(b.channel) ? 1 : 2;
+    return bScore - aScore;
+  })[0];
+}
+
+// src/runtime/handlers/conversation.ts
 var setup = (bot2) => {
   bot2.on.message(
     "*",
@@ -46079,38 +46215,25 @@ var setup = (bot2) => {
         },
         async () => {
           const handlerName = conversation.integration + "." + conversation.channel;
-          const handler = adk.project.conversations.find(
-            (x) => x.channel === handlerName
-          );
+          const handler = findMatchingHandler(adk.project.conversations, handlerName);
           if (!handler) {
             logger.debug(
               `Skipping message, no ADK Conversation defined for "${handlerName}"`
             );
             return;
           }
-          const startTyping = trackPromise(handler.startTyping());
           const chat = new BotpressChat(context2.getAll());
           context2.set("chat", chat);
-          const state = TrackedState.create({
-            type: "conversation",
-            client: client._inner,
-            id: conversation.id,
-            schema: handler.state,
-            name: "state"
-          });
           const [transcript, _statesLoaded] = await Promise.all([
             chat.fetchTranscript(),
-            TrackedState.loadAll()
+            TrackedState2.loadAll()
           ]);
           if (transcript.find((x) => x.id === message.id)) {
             return;
           }
           await chat.addMessage(message);
-          handler.state = state.value;
           await handler[ConversationHandler]();
-          state.value = handler.state;
-          trackPromise(TrackedState.saveAllDirty());
-          trackPromise(startTyping.then(() => handler.stopTyping()));
+          await TrackedState2.saveAllDirty();
           await chat.saveTranscript();
         }
       );
@@ -46229,7 +46352,7 @@ var setup3 = (bot2) => {
         });
         try {
           const interval = setInterval(async () => {
-            await TrackedState.saveAllDirty();
+            await TrackedState2.saveAllDirty();
           }, 2e4);
           const result = await new Promise((resolve, reject) => {
             const remainingTime = context2.get("runtime").getRemainingExecutionTimeInMs();
@@ -46252,7 +46375,7 @@ var setup3 = (bot2) => {
           });
           if (result.status === "continue") {
             s.setAttribute("workflow.status.final", "continue");
-            await TrackedState.saveAllDirty();
+            await TrackedState2.saveAllDirty();
           } else if (result.status === "done") {
             s.setAttribute("workflow.status.final", "completed");
             await updateWorkflow({
@@ -46366,9 +46489,7 @@ var setup4 = (bot2) => {
         return;
       }
       const handlerName = conversation.integration + "." + conversation.channel;
-      const handler = adk.project.conversations.find(
-        (c) => c.channel === handlerName
-      );
+      const handler = findMatchingHandler(adk.project.conversations, handlerName);
       if (!handler) {
         logger.debug(
           `Skipping message, no ADK Conversation defined for "${handlerName}"`
@@ -46388,28 +46509,17 @@ var setup4 = (bot2) => {
           workflowId: payload.workflowId
         },
         async () => {
-          const startTyping = trackPromise(handler.startTyping());
           const chat = new BotpressChat(context2.getAll());
           context2.set("chat", chat);
-          const state = TrackedState.create({
-            type: "conversation",
-            client: client._inner,
-            id: conversation.id,
-            schema: handler.state,
-            name: "state"
-          });
           const transcript = await chat.fetchTranscript();
           if (transcript.find((x) => x.id === event.id)) {
             logger.debug(`Message ${event.id} already processed`);
             return;
           }
           await chat.addEvent(event);
-          await TrackedState.loadAll();
-          handler.state = state.value;
+          await TrackedState2.loadAll();
           await handler[ConversationHandler]();
-          state.value = handler.state;
-          trackPromise(TrackedState.saveAllDirty());
-          trackPromise(startTyping.then(() => handler.stopTyping()));
+          await TrackedState2.saveAllDirty();
           await chat.saveTranscript();
         }
       );
@@ -47404,7 +47514,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,
@@ -47416,8 +47536,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) => {
@@ -47438,6 +47557,7 @@ function installStructuredLogging() {
 }
 
 // src/runtime.ts
+init_trigger_tags();
 import { z as z24 } from "@botpress/sdk";
 if (Environment.isDevelopment() || Environment.isProduction()) {
   installStructuredLogging();
@@ -47450,7 +47570,7 @@ export {
   Message,
   PromiseTracker,
   SubworkflowFinished,
-  TrackedState,
+  TrackedState2 as TrackedState,
   TrackedStateSchema,
   TranscriptSchema,
   WorkflowCallbackEvent,