@botpress/runtime 1.13.9 → 1.13.11

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.13.9", adk: "1.13.9", sdk: "5.0.2", llmz: "0.0.35", zai: "2.5.6", cognitive: "0.3.3" };
+    define_PACKAGE_VERSIONS_default = { runtime: "1.13.11", adk: "1.13.11", sdk: "5.0.2", llmz: "0.0.37", zai: "2.5.6", cognitive: "0.3.3" };
   }
 });
 
@@ -14851,7 +14851,7 @@ var init_assets = __esm({
 
 // src/runtime/context/context.ts
 import { AsyncLocalStorage as AsyncLocalStorage2 } from "async_hooks";
-var storage, context2;
+var storage, defaultContext, context2;
 var init_context3 = __esm({
   "src/runtime/context/context.ts"() {
     "use strict";
@@ -14859,6 +14859,7 @@ var init_context3 = __esm({
     init_define_PACKAGE_VERSIONS();
     init_singletons();
     storage = getSingleton("__ADK_GLOBAL_CTX_STORAGE", () => new AsyncLocalStorage2());
+    defaultContext = getSingleton("__ADK_GLOBAL_DEFAULT_CTX", () => ({ value: null }));
     context2 = {
       enterWith: (data) => {
         storage.enterWith(data);
@@ -14877,7 +14878,10 @@ var init_context3 = __esm({
         return store;
       },
       get: (key, opts) => {
-        const store = storage.getStore();
+        let store = storage.getStore();
+        if (!store && defaultContext.value) {
+          store = defaultContext.value;
+        }
         if (store) {
           store.states ??= [];
           store.tags ??= [];
@@ -14893,6 +14897,28 @@ var init_context3 = __esm({
         const store = storage.getStore();
         if (!store) throw new Error("Cannot set context outside of `run`");
         store[key] = value;
+      },
+      /**
+       * Set a default context that will be used as a fallback when no AsyncLocalStorage context is active.
+       * This is useful for testing and script execution where code runs outside of request handlers.
+       *
+       * @example
+       * ```typescript
+       * context.setDefaultContext({
+       *   botId: 'my-bot',
+       *   integrations: agentRegistry.integrations,
+       *   interfaces: agentRegistry.interfaces,
+       * })
+       * ```
+       */
+      setDefaultContext: (data) => {
+        defaultContext.value = data;
+      },
+      /**
+       * Clear the default context.
+       */
+      clearDefaultContext: () => {
+        defaultContext.value = null;
       }
     };
   }
@@ -27286,41 +27312,41 @@ var require_ms = __commonJS({
           return void 0;
       }
     }
-    function fmtShort(ms3) {
-      var msAbs = Math.abs(ms3);
+    function fmtShort(ms4) {
+      var msAbs = Math.abs(ms4);
       if (msAbs >= d) {
-        return Math.round(ms3 / d) + "d";
+        return Math.round(ms4 / d) + "d";
       }
       if (msAbs >= h) {
-        return Math.round(ms3 / h) + "h";
+        return Math.round(ms4 / h) + "h";
       }
       if (msAbs >= m) {
-        return Math.round(ms3 / m) + "m";
+        return Math.round(ms4 / m) + "m";
       }
       if (msAbs >= s) {
-        return Math.round(ms3 / s) + "s";
+        return Math.round(ms4 / s) + "s";
       }
-      return ms3 + "ms";
+      return ms4 + "ms";
     }
-    function fmtLong(ms3) {
-      var msAbs = Math.abs(ms3);
+    function fmtLong(ms4) {
+      var msAbs = Math.abs(ms4);
       if (msAbs >= d) {
-        return plural(ms3, msAbs, d, "day");
+        return plural(ms4, msAbs, d, "day");
       }
       if (msAbs >= h) {
-        return plural(ms3, msAbs, h, "hour");
+        return plural(ms4, msAbs, h, "hour");
       }
       if (msAbs >= m) {
-        return plural(ms3, msAbs, m, "minute");
+        return plural(ms4, msAbs, m, "minute");
       }
       if (msAbs >= s) {
-        return plural(ms3, msAbs, s, "second");
+        return plural(ms4, msAbs, s, "second");
       }
-      return ms3 + " ms";
+      return ms4 + " ms";
     }
-    function plural(ms3, msAbs, n, name) {
+    function plural(ms4, msAbs, n, name) {
       var isPlural = msAbs >= n * 1.5;
-      return Math.round(ms3 / n) + " " + name + (isPlural ? "s" : "");
+      return Math.round(ms4 / n) + " " + name + (isPlural ? "s" : "");
     }
   }
 });
@@ -27365,8 +27391,8 @@ var require_common = __commonJS({
           }
           const self2 = debug;
           const curr = Number(/* @__PURE__ */ new Date());
-          const ms3 = curr - (prevTime || curr);
-          self2.diff = ms3;
+          const ms4 = curr - (prevTime || curr);
+          self2.diff = ms4;
           self2.prev = prevTime;
           self2.curr = curr;
           prevTime = curr;
@@ -34273,6 +34299,9 @@ Always prefer information from the knowledge bases over general knowledge when a
                 ...props.hooks?.onBeforeTool && {
                   onBeforeTool: asyncResource.bind(props.hooks.onBeforeTool)
                 },
+                ...props.hooks?.onIterationStart && {
+                  onIterationStart: asyncResource.bind(props.hooks.onIterationStart)
+                },
                 ...props.hooks?.onAfterTool && {
                   onAfterTool: asyncResource.bind(props.hooks.onAfterTool)
                 },
@@ -44200,7 +44229,7 @@ var init_actions = __esm({
               }
               integrations ??= context2.get("integrations", { optional: true });
               client2 ??= context2.get("client", { optional: true });
-              const integration = integrations.find((i) => i.alias === integrationName);
+              const integration = integrations?.find((i) => i.alias === integrationName);
               const actionDef = integration?.definition.actions?.[actionName];
               const handler = async (params) => {
                 integrations ??= context2.get("integrations", { optional: true });
@@ -45123,15 +45152,51 @@ var init_validate_tag_name = __esm({
   }
 });
 
+// src/utilities/validate-event-name.ts
+function validateEventName(name) {
+  if (!name || typeof name !== "string") {
+    return { valid: false, error: "Event name must be a non-empty string" };
+  }
+  if (name.length > 100) {
+    return { valid: false, error: `Event name "${name}" must be less than 100 characters` };
+  }
+  if (!/^[a-zA-Z]/.test(name)) {
+    return { valid: false, error: `Event name "${name}" must start with a letter` };
+  }
+  if (!/^[a-zA-Z0-9_]+$/.test(name)) {
+    return {
+      valid: false,
+      error: `Event name "${name}" can only contain letters (A-Z, a-z), numbers (0-9), and underscores (_)`
+    };
+  }
+  return { valid: true };
+}
+function validateEventDefinitions(events, context3) {
+  for (const eventName of Object.keys(events)) {
+    const validation = validateEventName(eventName);
+    if (!validation.valid) {
+      throw new Error(`Invalid event name in ${context3}: ${validation.error}`);
+    }
+  }
+}
+var init_validate_event_name = __esm({
+  "src/utilities/validate-event-name.ts"() {
+    "use strict";
+    init_define_BUILD();
+    init_define_PACKAGE_VERSIONS();
+  }
+});
+
 // src/define-config.ts
 import { z as z17 } from "@botpress/sdk";
-var zuiSchema, modelSchema, tagDefinitionSchema, configSchema, AGENT_CONFIG_BRAND, defineConfig;
+var zuiSchema, modelSchema, tagDefinitionSchema, eventDefinitionSchema, configSchema, AGENT_CONFIG_BRAND, defineConfig;
 var init_define_config = __esm({
   "src/define-config.ts"() {
     "use strict";
     init_define_BUILD();
     init_define_PACKAGE_VERSIONS();
     init_validate_tag_name();
+    init_validate_event_name();
     zuiSchema = z17.custom(
       (val) => {
         if (typeof val === "object" && val !== null && "parse" in val) {
@@ -45156,6 +45221,13 @@ var init_define_config = __esm({
         description: z17.string().optional()
       })
     );
+    eventDefinitionSchema = z17.record(
+      z17.string(),
+      z17.object({
+        schema: zuiSchema.optional(),
+        description: z17.string().optional()
+      })
+    );
     configSchema = z17.object({
       name: z17.string().optional(),
       description: z17.string().optional(),
@@ -45196,7 +45268,8 @@ var init_define_config = __esm({
         zai: val?.zai ?? "openai:gpt-4.1-2025-04-14",
         autonomous: val?.autonomous ?? "openai:gpt-4.1-mini-2025-04-14"
       })),
-      dependencies: z17.custom()
+      dependencies: z17.custom(),
+      events: eventDefinitionSchema.optional()
     });
     AGENT_CONFIG_BRAND = Symbol.for("@botpress/runtime/AgentConfig");
     defineConfig = (config) => {
@@ -45216,6 +45289,9 @@ var init_define_config = __esm({
       if (parsed.workflow?.tags) {
         validateTagDefinitions(parsed.workflow.tags, "workflow.tags");
       }
+      if (parsed.events) {
+        validateEventDefinitions(parsed.events, "events");
+      }
       return {
         ...parsed,
         __brand: "AgentConfig",
@@ -45473,12 +45549,12 @@ var init_workflow_step = __esm({
       workflowControlContext.abort();
       throw createStepSignal();
     };
-    step.sleep = async (name, ms3) => {
+    step.sleep = async (name, ms4) => {
       await _step(
         name,
         async () => {
           const remainingTime = context2.get("runtime").getRemainingExecutionTimeInMs();
-          if (remainingTime - MIN_STEP_REMAINING_TIME_MS <= ms3 || ms3 >= 1e4) {
+          if (remainingTime - MIN_STEP_REMAINING_TIME_MS <= ms4 || ms4 >= 1e4) {
             const client2 = context2.get("client");
             const workflowControlContext = context2.get("workflowControlContext");
             await client2.createEvent({
@@ -45486,7 +45562,7 @@ var init_workflow_step = __esm({
               payload: {},
               workflowId: workflowControlContext.workflow.id,
               schedule: {
-                delay: ms3
+                delay: ms4
               }
             });
             await updateWorkflow({
@@ -45495,7 +45571,7 @@ var init_workflow_step = __esm({
             });
             workflowControlContext.abort();
           } else {
-            await new Promise((resolve) => void setTimeout(resolve, ms3));
+            await new Promise((resolve) => void setTimeout(resolve, ms4));
             context2.get("workflowControlContext").signal.throwIfAborted();
           }
         },
@@ -45506,8 +45582,8 @@ var init_workflow_step = __esm({
       );
     };
     step.sleepUntil = async (name, date) => {
-      const ms3 = Math.max(0, new Date(date).getTime() - Date.now() - MIN_STEP_REMAINING_TIME_MS);
-      await step.sleep(name, ms3);
+      const ms4 = Math.max(0, new Date(date).getTime() - Date.now() - MIN_STEP_REMAINING_TIME_MS);
+      await step.sleep(name, ms4);
     };
     step.waitForWorkflow = async (name, workflowId) => {
       const workflowControlContext = context2.get("workflowControlContext");
@@ -45726,12 +45802,13 @@ function createWorkflowExecutionState(client2, workflowId) {
     name: BUILT_IN_STATES.workflowSteps
   });
 }
-var workflowStepContextSchema, workflowExecutionContextSchema, StepSymbol, BaseWorkflowInstance;
+var import_ms2, workflowStepContextSchema, workflowExecutionContextSchema, StepSymbol, BaseWorkflowInstance;
 var init_workflow_instance = __esm({
   "src/primitives/workflow-instance.ts"() {
     "use strict";
     init_define_BUILD();
     init_define_PACKAGE_VERSIONS();
+    import_ms2 = __toESM(require_ms(), 1);
     init_errors();
     init_library();
     init_autonomous();
@@ -45858,6 +45935,81 @@ var init_workflow_instance = __esm({
         });
         Object.assign(this.workflow, workflow);
       }
+      /**
+       * Extend the workflow timeout by setting a new timeout.
+       * This is useful for long-running workflows that need more time to complete.
+       *
+       * @param options - Either `{ in: string }` for relative duration or `{ at: string }` for absolute ISO timestamp
+       * @returns A promise that resolves when the timeout is updated (can be awaited or not)
+       * @example
+       * // Relative timeout (duration from now):
+       * workflow.setTimeout({ in: '30m' })  // Timeout in 30 minutes
+       * workflow.setTimeout({ in: '6 hours' })  // Timeout in 6 hours
+       *
+       * // Absolute timeout (ISO timestamp):
+       * workflow.setTimeout({ at: '2024-12-25T00:00:00Z' })
+       *
+       * // Optionally await if you need to ensure the update completes:
+       * await workflow.setTimeout({ in: '1h' })
+       */
+      setTimeout(options) {
+        let newTimeoutAt;
+        if ("in" in options) {
+          const durationMs = (0, import_ms2.default)(options.in);
+          if (!durationMs) {
+            throw new Error(`Invalid duration format: "${options.in}". Use formats like "30m", "1h", "6 hours".`);
+          }
+          newTimeoutAt = new Date(Date.now() + durationMs).toISOString();
+        } else {
+          const date = new Date(options.at);
+          if (isNaN(date.getTime())) {
+            throw new Error(`Invalid ISO date format: "${options.at}".`);
+          }
+          newTimeoutAt = date.toISOString();
+        }
+        return updateWorkflow({
+          id: this.id,
+          timeoutAt: newTimeoutAt
+        }).then(({ workflow }) => {
+          Object.assign(this.workflow, workflow);
+        });
+      }
+      /**
+       * Fail the workflow with an error reason.
+       * This immediately interrupts the workflow handler and marks the workflow as failed.
+       * Can only be called from within a workflow handler.
+       *
+       * @param reason - The error reason for the failure
+       * @throws Never returns - always throws to interrupt the handler
+       * @example
+       * workflow.fail('Invalid input data')
+       */
+      fail(reason) {
+        const controlContext = context2.get("workflowControlContext", { optional: true });
+        if (!controlContext || controlContext.workflow.id !== this.id) {
+          throw new Error("workflow.fail() can only be called from within the workflow handler");
+        }
+        controlContext.fail(reason);
+        throw createStepSignal();
+      }
+      /**
+       * Complete the workflow early with the given output.
+       * This immediately interrupts the workflow handler and marks the workflow as completed.
+       * Can only be called from within a workflow handler.
+       *
+       * @param output - The workflow output (typed according to workflow definition)
+       * @throws Never returns - always throws to interrupt the handler
+       * @example
+       * workflow.complete({ result: 'success', data: processedData })
+       */
+      complete(output2) {
+        const controlContext = context2.get("workflowControlContext", { optional: true });
+        if (!controlContext || controlContext.workflow.id !== this.id) {
+          throw new Error("workflow.complete() can only be called from within the workflow handler");
+        }
+        controlContext.complete(output2);
+        throw createStepSignal();
+      }
       /**
        * Provide data in response to a workflow data request (instance method).
        * Call this method from a conversation handler when you receive a WorkflowDataRequestEvent.
@@ -45908,6 +46060,7 @@ var init_workflow_instance = __esm({
           workflow: this.workflow,
           aborted: false,
           failed: false,
+          completed: false,
           acked: false,
           restarted: false,
           signal: abortSignal,
@@ -45922,6 +46075,10 @@ var init_workflow_instance = __esm({
             workflowControlContext.failed = true;
             workflowControlContext.failedReason = reason;
           },
+          complete: (result) => {
+            workflowControlContext.completed = true;
+            workflowControlContext.completedResult = result;
+          },
           ack: async () => {
             if (workflowControlContext.acked) {
               return;
@@ -45975,7 +46132,8 @@ var init_workflow_instance = __esm({
               step,
               client: this.client,
               execute: this.execute.bind(this),
-              signal: abortSignal
+              signal: abortSignal,
+              workflow: this
             });
             return {
               status: "done",
@@ -45986,6 +46144,12 @@ var init_workflow_instance = __esm({
           }
         } catch (err) {
           if (isStepSignal(err)) {
+            if (workflowControlContext.completed) {
+              return {
+                status: "done",
+                result: workflowControlContext.completedResult
+              };
+            }
             if (workflowControlContext.failed) {
               return {
                 status: "error",
@@ -46601,6 +46765,268 @@ var init_tracked_state = __esm({
   }
 });
 
+// src/runtime/tracked-tags.ts
+function isSystemTag(key) {
+  return key.includes(":");
+}
+var TrackedTags;
+var init_tracked_tags = __esm({
+  "src/runtime/tracked-tags.ts"() {
+    "use strict";
+    init_define_BUILD();
+    init_define_PACKAGE_VERSIONS();
+    init_context3();
+    init_tracing();
+    TrackedTags = class _TrackedTags {
+      type;
+      id;
+      client;
+      _tags = {};
+      _initialTags = {};
+      _loaded = false;
+      _saving = false;
+      _saveAgain = false;
+      _saveAgainCount = 0;
+      static _savingAll = false;
+      static _saveAllAgain = false;
+      static _saveAllCount = 0;
+      constructor(props) {
+        this.type = props.type;
+        this.id = props.id;
+        this.client = props.client;
+      }
+      static create(props) {
+        const tags = context2.get("tags", { optional: true });
+        const executionFinished = context2.get("executionFinished", { optional: true });
+        if (executionFinished) {
+          throw new Error(`Cannot create new TrackedTags "${props.type}/${props.id}" after execution has finished.`);
+        }
+        const match2 = tags?.find((x) => x.id === props.id && x.type === props.type);
+        if (match2) {
+          return match2;
+        }
+        const instance = new _TrackedTags(props);
+        if (props.initialTags) {
+          instance._tags = { ...props.initialTags };
+          instance._initialTags = { ...props.initialTags };
+          instance._loaded = true;
+        }
+        tags?.push(instance);
+        return instance;
+      }
+      static async saveAllDirty() {
+        if (this._savingAll) {
+          this._saveAllAgain = true;
+          return;
+        }
+        try {
+          this._savingAll = true;
+          const tags = context2.get("tags", { optional: true });
+          const dirtyTags = tags?.filter((t) => t.isDirty()) || [];
+          if (!dirtyTags.length) {
+            return;
+          }
+          await span(
+            "tags.saveAllDirty",
+            {
+              tags_count: tags?.length || 0,
+              tags: tags.map((t) => `${t.type}/${t.id}`)
+            },
+            () => Promise.allSettled(dirtyTags.map((t) => t.save()))
+          );
+        } finally {
+          this._savingAll = false;
+          if (this._saveAllAgain && this._saveAllCount++ <= 5) {
+            this._saveAllAgain = false;
+            await this.saveAllDirty();
+          } else {
+            this._saveAllCount = 0;
+          }
+        }
+      }
+      static async loadAll() {
+        await span("tags.loadAll", {}, async () => {
+          const client2 = context2.get("client")._inner;
+          const bot2 = context2.get("bot", { optional: true });
+          const user2 = context2.get("user", { optional: true });
+          const conversation = context2.get("conversation", { optional: true });
+          const workflow = context2.get("workflow", { optional: true });
+          if (bot2) {
+            const botTags = bot2.tags;
+            _TrackedTags.create({
+              client: client2,
+              type: "bot",
+              id: bot2.id,
+              ...botTags && { initialTags: botTags }
+            });
+          }
+          if (user2) {
+            const userTags = user2.tags;
+            _TrackedTags.create({
+              client: client2,
+              type: "user",
+              id: user2.id,
+              ...userTags && { initialTags: userTags }
+            });
+          }
+          if (conversation) {
+            const conversationTags = conversation.tags;
+            _TrackedTags.create({
+              client: client2,
+              type: "conversation",
+              id: conversation.id,
+              ...conversationTags && { initialTags: conversationTags }
+            });
+          }
+          if (workflow) {
+            const workflowTags = workflow.tags;
+            _TrackedTags.create({
+              client: client2,
+              type: "workflow",
+              id: workflow.id,
+              ...workflowTags && { initialTags: workflowTags }
+            });
+          }
+          const tags = context2.get("tags", { optional: true });
+          const unloadedTags = tags?.filter((tag) => !tag._loaded) ?? [];
+          if (unloadedTags.length > 0) {
+            await Promise.allSettled(unloadedTags.map((tag) => tag.load()));
+          }
+        });
+      }
+      static unloadAll() {
+        context2.get("tags", { optional: true })?.splice(0);
+      }
+      async load(force = false) {
+        if (this._loaded && !force) {
+          return;
+        }
+        await span(
+          "tags.load",
+          {
+            type: this.type,
+            id: this.id
+          },
+          async () => {
+            const tags = await this.fetchTags();
+            this._tags = { ...tags };
+            this._initialTags = { ...tags };
+            this._loaded = true;
+          }
+        );
+      }
+      async save() {
+        if (this._saving) {
+          this._saveAgain = true;
+          return;
+        }
+        const executionFinished = context2.get("executionFinished", { optional: true });
+        if (executionFinished) {
+          throw new Error(`Cannot save TrackedTags "${this.type}/${this.id}" after execution has finished.`);
+        }
+        try {
+          this._saving = true;
+          await span(
+            "tags.save",
+            {
+              type: this.type,
+              id: this.id
+            },
+            async () => {
+              await this.persistTags(this._tags);
+              this._initialTags = { ...this._tags };
+            }
+          );
+        } finally {
+          this._saving = false;
+          if (this._saveAgain && this._saveAgainCount++ <= 5) {
+            this._saveAgain = false;
+            await this.save();
+          } else {
+            this._saveAgainCount = 0;
+          }
+        }
+      }
+      isDirty() {
+        const currentKeys = Object.keys(this._tags).filter((k) => !isSystemTag(k)).sort();
+        const initialKeys = Object.keys(this._initialTags).filter((k) => !isSystemTag(k)).sort();
+        if (currentKeys.length !== initialKeys.length) {
+          return true;
+        }
+        for (const key of currentKeys) {
+          if (this._tags[key] !== this._initialTags[key]) {
+            return true;
+          }
+        }
+        return false;
+      }
+      get tags() {
+        return new Proxy(this._tags, {
+          set: (target, prop, value) => {
+            if (isSystemTag(prop)) {
+              return true;
+            }
+            target[prop] = value;
+            return true;
+          },
+          deleteProperty: (target, prop) => {
+            if (isSystemTag(prop)) {
+              return true;
+            }
+            target[prop] = void 0;
+            return true;
+          }
+        });
+      }
+      set tags(value) {
+        this._tags = { ...value };
+      }
+      async fetchTags() {
+        try {
+          if (this.type === "bot") {
+            const { bot: bot2 } = await this.client.getBot({ id: this.id });
+            return bot2.tags || {};
+          } else if (this.type === "user") {
+            const { user: user2 } = await this.client.getUser({ id: this.id });
+            return user2.tags || {};
+          } else if (this.type === "conversation") {
+            const { conversation } = await this.client.getConversation({ id: this.id });
+            return conversation.tags || {};
+          } else if (this.type === "workflow") {
+            const { workflow } = await this.client.getWorkflow({ id: this.id });
+            return workflow.tags || {};
+          }
+        } catch (err) {
+          console.error(`Failed to fetch tags for ${this.type}/${this.id}:`, err);
+        }
+        return {};
+      }
+      async persistTags(tags) {
+        const tagsForApi = {};
+        for (const [key, value] of Object.entries(tags)) {
+          if (value !== void 0 && !isSystemTag(key)) {
+            tagsForApi[key] = value;
+          }
+        }
+        try {
+          if (this.type === "bot") {
+            await this.client.updateBot({ id: this.id, tags: tagsForApi });
+          } else if (this.type === "user") {
+            await this.client.updateUser({ id: this.id, tags: tagsForApi });
+          } else if (this.type === "conversation") {
+            await this.client.updateConversation({ id: this.id, tags: tagsForApi });
+          } else if (this.type === "workflow") {
+            await this.client.updateWorkflow({ id: this.id, tags: tagsForApi });
+          }
+        } catch (err) {
+          console.error(`Failed to persist tags for ${this.type}/${this.id}:`, err);
+          throw err;
+        }
+      }
+    };
+  }
+});
+
 // src/runtime/context/inspector-handler.ts
 async function handleInspectorDisable() {
   const inspector = await import("inspector");
@@ -46743,6 +47169,7 @@ var init_handlers = __esm({
     init_http();
     init_agent_registry();
     init_tracked_state();
+    init_tracked_tags();
     init_tracing();
     init_heavy_imports();
     init_environment();
@@ -46870,12 +47297,13 @@ var init_handlers = __esm({
                         reject(error);
                       } finally {
                         clearTimeout(timeout);
-                        await TrackedState2.saveAllDirty();
+                        await Promise.all([TrackedState2.saveAllDirty(), TrackedTags.saveAllDirty()]);
                       }
                     });
                   } finally {
-                    await TrackedState2.saveAllDirty();
+                    await Promise.all([TrackedState2.saveAllDirty(), TrackedTags.saveAllDirty()]);
                     TrackedState2.unloadAll();
+                    TrackedTags.unloadAll();
                     context2.set("executionFinished", true);
                     await shutdownPromiseTracker();
                   }
@@ -48343,34 +48771,36 @@ var init_trigger2 = __esm({
           } else {
             events.add(name);
           }
-          const [integration, event] = name.split(":");
           const names = /* @__PURE__ */ new Set([name]);
-          const int = adk.project.integrations.find((x) => x.alias === integration || x.definition.name === integration);
-          if (!int) {
-            console.warn(`Integration "${integration}" not found for event "${name}". Skipping trigger registration.`);
-            continue;
+          if (name.includes(":")) {
+            const [integration, event] = name.split(":");
+            const int = adk.project.integrations.find((x) => x.alias === integration || x.definition.name === integration);
+            if (!int) {
+              console.warn(`Integration "${integration}" not found for event "${name}". Skipping trigger registration.`);
+              continue;
+            }
+            names.add(`${int.definition.name}:${event}`);
+            names.add(`${int.alias}:${event}`);
           }
-          names.add(`${int.definition.name}:${event}`);
-          names.add(`${int.alias}:${event}`);
           for (const name2 of names) {
-            bot2.on.event(name2, async ({ event: event2, ctx }) => {
+            bot2.on.event(name2, async ({ event, ctx }) => {
               const conversation = context2.get("conversation", { optional: true });
               await span(
                 "handler.trigger",
                 {
                   botId: ctx.botId,
-                  eventId: event2.id,
+                  eventId: event.id,
                   "event.type": originalName,
-                  conversationId: event2.conversationId,
+                  conversationId: event.conversationId,
                   integration: conversation?.integration,
                   channel: conversation?.channel,
-                  userId: event2.userId
+                  userId: event.userId
                 },
                 async () => {
                   console.log(`Evaluating trigger "${trigger.name}" for event "${originalName}" (mapped to "${name2}")`);
                   await trigger.handler({
                     event: {
-                      ...event2,
+                      ...event,
                       type: originalName
                     }
                   });
@@ -48389,7 +48819,7 @@ var workflow_exports = {};
 __export(workflow_exports, {
   setup: () => setup3
 });
-var import_ms2, setup3;
+var import_ms3, setup3;
 var init_workflow2 = __esm({
   "src/runtime/handlers/workflow.ts"() {
     "use strict";
@@ -48402,7 +48832,7 @@ var init_workflow2 = __esm({
     init_esm();
     init_adk();
     init_workflow_utils();
-    import_ms2 = __toESM(require_ms(), 1);
+    import_ms3 = __toESM(require_ms(), 1);
     setup3 = (bot2) => {
       const handler = async function({ workflow, event, client: client2, ctx, conversation }) {
         await span(
@@ -48430,7 +48860,7 @@ var init_workflow2 = __esm({
               });
               return;
             }
-            const DEFAULT_TIMEOUT_MS = (0, import_ms2.default)("5m");
+            const DEFAULT_TIMEOUT_MS = (0, import_ms3.default)("5m");
             const configuredTimeout = workflowDefinition.timeout;
             if (workflow.timeoutAt && configuredTimeout !== DEFAULT_TIMEOUT_MS) {
               const workflowStartedAt = new Date(workflow.createdAt).getTime();
@@ -48448,10 +48878,13 @@ var init_workflow2 = __esm({
                 s.setAttribute("workflow.timeout.to", configuredTimeout);
               }
             }
-            const instance = await BaseWorkflowInstance.load({
-              id: workflow.id,
-              workflow
-            });
+            const [instance] = await Promise.all([
+              BaseWorkflowInstance.load({
+                id: workflow.id,
+                workflow
+              }),
+              TrackedState2.loadAll()
+            ]);
             void workflow.acknowledgeStartOfProcessing();
             try {
               const interval = setInterval(async () => {
@@ -48606,15 +49039,18 @@ var init_event = __esm({
             logger.warn(`Skipping ${WorkflowCallbackEvent.name} event, conversation not found in context`);
             return;
           }
-          let alias = conversation.integration;
-          const colonIndex = event.type.indexOf(":");
-          if (colonIndex > 0) {
-            alias = event.type.substring(0, colonIndex);
-          }
-          const handlerName = alias + "." + conversation.channel;
-          const handler = findMatchingHandler(adk.project.conversations, handlerName);
+          const handlerName = conversation.integration + "." + conversation.channel;
+          const isBuiltInEvent = event.type === WorkflowCallbackEvent.name || event.type === WorkflowDataRequestEvent2.name;
+          const matchingHandlers = adk.project.conversations.filter(
+            (h) => matchesChannel(h.channel, handlerName) && (isBuiltInEvent || h.events.includes(event.type))
+          );
+          const handler = 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];
           if (!handler) {
-            logger.debug(`Skipping message, no ADK Conversation defined for "${handlerName}"`);
+            logger.debug(`Skipping event "${event.type}", no ADK Conversation listening to this event for channel "${handlerName}"`);
             return;
           }
           await span(
@@ -48632,15 +49068,18 @@ var init_event = __esm({
             async () => {
               const chat = new BotpressChat(context2.getAll());
               context2.set("chat", chat);
-              const transcript = await chat.fetchTranscript();
+              const [transcript, _statesLoaded, _tagsLoaded] = await Promise.all([
+                chat.fetchTranscript(),
+                TrackedState2.loadAll(),
+                TrackedTags.loadAll()
+              ]);
               if (transcript.find((x) => x.id === event.id)) {
                 logger.debug(`Message ${event.id} already processed`);
                 return;
               }
               await chat.addEvent(event);
-              await TrackedState2.loadAll();
               await handler[ConversationHandler]();
-              await TrackedState2.saveAllDirty();
+              await Promise.all([TrackedState2.saveAllDirty(), TrackedTags.saveAllDirty()]);
               await chat.saveTranscript();
             }
           );
@@ -48733,259 +49172,6 @@ var init_handlers2 = __esm({
   }
 });
 
-// src/runtime/tracked-tags.ts
-var TrackedTags;
-var init_tracked_tags = __esm({
-  "src/runtime/tracked-tags.ts"() {
-    "use strict";
-    init_define_BUILD();
-    init_define_PACKAGE_VERSIONS();
-    init_context3();
-    init_tracing();
-    TrackedTags = class _TrackedTags {
-      type;
-      id;
-      client;
-      _tags = {};
-      _initialTags = {};
-      _loaded = false;
-      _saving = false;
-      _saveAgain = false;
-      _saveAgainCount = 0;
-      static _savingAll = false;
-      static _saveAllAgain = false;
-      static _saveAllCount = 0;
-      constructor(props) {
-        this.type = props.type;
-        this.id = props.id;
-        this.client = props.client;
-      }
-      static create(props) {
-        const tags = context2.get("tags", { optional: true });
-        const executionFinished = context2.get("executionFinished", { optional: true });
-        if (executionFinished) {
-          throw new Error(`Cannot create new TrackedTags "${props.type}/${props.id}" after execution has finished.`);
-        }
-        const match2 = tags?.find((x) => x.id === props.id && x.type === props.type);
-        if (match2) {
-          return match2;
-        }
-        const instance = new _TrackedTags(props);
-        if (props.initialTags) {
-          instance._tags = { ...props.initialTags };
-          instance._initialTags = { ...props.initialTags };
-          instance._loaded = true;
-        }
-        tags?.push(instance);
-        return instance;
-      }
-      static async saveAllDirty() {
-        if (this._savingAll) {
-          this._saveAllAgain = true;
-          return;
-        }
-        try {
-          this._savingAll = true;
-          const tags = context2.get("tags", { optional: true });
-          const dirtyTags = tags?.filter((t) => t.isDirty()) || [];
-          if (!dirtyTags.length) {
-            return;
-          }
-          await span(
-            "tags.saveAllDirty",
-            {
-              tags_count: tags?.length || 0,
-              tags: tags.map((t) => `${t.type}/${t.id}`)
-            },
-            () => Promise.allSettled(dirtyTags.map((t) => t.save()))
-          );
-        } finally {
-          this._savingAll = false;
-          if (this._saveAllAgain && this._saveAllCount++ <= 5) {
-            this._saveAllAgain = false;
-            await this.saveAllDirty();
-          } else {
-            this._saveAllCount = 0;
-          }
-        }
-      }
-      static async loadAll() {
-        await span("tags.loadAll", {}, async () => {
-          const client2 = context2.get("client")._inner;
-          const bot2 = context2.get("bot", { optional: true });
-          const user2 = context2.get("user", { optional: true });
-          const conversation = context2.get("conversation", { optional: true });
-          const workflow = context2.get("workflow", { optional: true });
-          if (bot2) {
-            const botTags = bot2.tags;
-            _TrackedTags.create({
-              client: client2,
-              type: "bot",
-              id: bot2.id,
-              ...botTags && { initialTags: botTags }
-            });
-          }
-          if (user2) {
-            const userTags = user2.tags;
-            _TrackedTags.create({
-              client: client2,
-              type: "user",
-              id: user2.id,
-              ...userTags && { initialTags: userTags }
-            });
-          }
-          if (conversation) {
-            const conversationTags = conversation.tags;
-            _TrackedTags.create({
-              client: client2,
-              type: "conversation",
-              id: conversation.id,
-              ...conversationTags && { initialTags: conversationTags }
-            });
-          }
-          if (workflow) {
-            const workflowTags = workflow.tags;
-            _TrackedTags.create({
-              client: client2,
-              type: "workflow",
-              id: workflow.id,
-              ...workflowTags && { initialTags: workflowTags }
-            });
-          }
-          const tags = context2.get("tags", { optional: true });
-          const unloadedTags = tags?.filter((tag) => !tag._loaded) ?? [];
-          if (unloadedTags.length > 0) {
-            await Promise.allSettled(unloadedTags.map((tag) => tag.load()));
-          }
-        });
-      }
-      static unloadAll() {
-        context2.get("tags", { optional: true })?.splice(0);
-      }
-      async load(force = false) {
-        if (this._loaded && !force) {
-          return;
-        }
-        await span(
-          "tags.load",
-          {
-            type: this.type,
-            id: this.id
-          },
-          async () => {
-            const tags = await this.fetchTags();
-            this._tags = { ...tags };
-            this._initialTags = { ...tags };
-            this._loaded = true;
-          }
-        );
-      }
-      async save() {
-        if (this._saving) {
-          this._saveAgain = true;
-          return;
-        }
-        const executionFinished = context2.get("executionFinished", { optional: true });
-        if (executionFinished) {
-          throw new Error(`Cannot save TrackedTags "${this.type}/${this.id}" after execution has finished.`);
-        }
-        try {
-          this._saving = true;
-          await span(
-            "tags.save",
-            {
-              type: this.type,
-              id: this.id
-            },
-            async () => {
-              await this.persistTags(this._tags);
-              this._initialTags = { ...this._tags };
-            }
-          );
-        } finally {
-          this._saving = false;
-          if (this._saveAgain && this._saveAgainCount++ <= 5) {
-            this._saveAgain = false;
-            await this.save();
-          } else {
-            this._saveAgainCount = 0;
-          }
-        }
-      }
-      isDirty() {
-        const currentKeys = Object.keys(this._tags).sort();
-        const initialKeys = Object.keys(this._initialTags).sort();
-        if (currentKeys.length !== initialKeys.length) {
-          return true;
-        }
-        for (const key of currentKeys) {
-          if (this._tags[key] !== this._initialTags[key]) {
-            return true;
-          }
-        }
-        return false;
-      }
-      get tags() {
-        return new Proxy(this._tags, {
-          set: (target, prop, value) => {
-            target[prop] = value;
-            return true;
-          },
-          deleteProperty: (target, prop) => {
-            target[prop] = void 0;
-            return true;
-          }
-        });
-      }
-      set tags(value) {
-        this._tags = { ...value };
-      }
-      async fetchTags() {
-        try {
-          if (this.type === "bot") {
-            const { bot: bot2 } = await this.client.getBot({ id: this.id });
-            return bot2.tags || {};
-          } else if (this.type === "user") {
-            const { user: user2 } = await this.client.getUser({ id: this.id });
-            return user2.tags || {};
-          } else if (this.type === "conversation") {
-            const { conversation } = await this.client.getConversation({ id: this.id });
-            return conversation.tags || {};
-          } else if (this.type === "workflow") {
-            const { workflow } = await this.client.getWorkflow({ id: this.id });
-            return workflow.tags || {};
-          }
-        } catch (err) {
-          console.error(`Failed to fetch tags for ${this.type}/${this.id}:`, err);
-        }
-        return {};
-      }
-      async persistTags(tags) {
-        const tagsForApi = {};
-        for (const [key, value] of Object.entries(tags)) {
-          if (value !== void 0) {
-            tagsForApi[key] = value;
-          }
-        }
-        try {
-          if (this.type === "bot") {
-            await this.client.updateBot({ id: this.id, tags: tagsForApi });
-          } else if (this.type === "user") {
-            await this.client.updateUser({ id: this.id, tags: tagsForApi });
-          } else if (this.type === "conversation") {
-            await this.client.updateConversation({ id: this.id, tags: tagsForApi });
-          } else if (this.type === "workflow") {
-            await this.client.updateWorkflow({ id: this.id, tags: tagsForApi });
-          }
-        } catch (err) {
-          console.error(`Failed to persist tags for ${this.type}/${this.id}:`, err);
-          throw err;
-        }
-      }
-    };
-  }
-});
-
 // src/runtime/index.ts
 var init_runtime = __esm({
   "src/runtime/index.ts"() {