@botpress/runtime 1.13.8 → 1.13.10

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.13.8", adk: "1.13.8", sdk: "5.0.2", llmz: "0.0.35", zai: "2.5.6", cognitive: "0.3.3" };
+    define_PACKAGE_VERSIONS_default = { runtime: "1.13.10", adk: "1.13.10", sdk: "5.0.2", llmz: "0.0.35", zai: "2.5.6", cognitive: "0.3.3" };
   }
 });
 
@@ -26314,7 +26314,7 @@ var require_form_data = __commonJS({
     var parseUrl = __require("url").parse;
     var fs3 = __require("fs");
     var Stream2 = __require("stream").Stream;
-    var crypto3 = __require("crypto");
+    var crypto2 = __require("crypto");
     var mime = require_mime_types();
     var asynckit = require_asynckit();
     var setToStringTag = require_es_set_tostringtag();
@@ -26520,7 +26520,7 @@ var require_form_data = __commonJS({
       return Buffer.concat([dataBuffer, Buffer.from(this._lastBoundary())]);
     };
     FormData3.prototype._generateBoundary = function() {
-      this._boundary = "--------------------------" + crypto3.randomBytes(12).toString("hex");
+      this._boundary = "--------------------------" + crypto2.randomBytes(12).toString("hex");
     };
     FormData3.prototype.getLengthSync = function() {
       var knownLength = this._overheadLength + this._valueLength;
@@ -27795,41 +27795,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" : "");
     }
   }
 });
@@ -27874,8 +27874,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;
@@ -34476,6 +34476,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)
                 },
@@ -34821,47 +34824,6 @@ var init_structured_logging = __esm({
   }
 });
 
-// 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;
-    };
-  }
-});
-
 // src/types.ts
 var init_types2 = __esm({
   "src/types.ts"() {
@@ -35086,15 +35048,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 z3 } 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 = z3.custom(
       (val) => {
         if (typeof val === "object" && val !== null && "parse" in val) {
@@ -35119,6 +35117,13 @@ var init_define_config = __esm({
         description: z3.string().optional()
       })
     );
+    eventDefinitionSchema = z3.record(
+      z3.string(),
+      z3.object({
+        schema: zuiSchema.optional(),
+        description: z3.string().optional()
+      })
+    );
     configSchema = z3.object({
       name: z3.string().optional(),
       description: z3.string().optional(),
@@ -35159,7 +35164,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: z3.custom()
+      dependencies: z3.custom(),
+      events: eventDefinitionSchema.optional()
     });
     AGENT_CONFIG_BRAND = Symbol.for("@botpress/runtime/AgentConfig");
     defineConfig = (config) => {
@@ -35179,6 +35185,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",
@@ -35201,7 +35210,6 @@ var init_runtime = __esm({
     init_structured_logging();
     init_environment();
     init_runtime2();
-    init_trigger_tags();
     init_types2();
     init_errors();
     init_state();
@@ -35954,6 +35962,9 @@ function isEventMessage(event) {
 function isWorkflowCallback(event) {
   return event !== null && typeof event === "object" && "type" in event && event.type === "workflowCallback" && "payload" in event && event.payload !== null && typeof event.payload === "object";
 }
+function isEventOfType(event, eventName) {
+  return isEvent(event) && event.type === eventName;
+}
 var init_events = __esm({
   "src/utilities/events.ts"() {
     "use strict";
@@ -36227,12 +36238,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 = context.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 = context.get("client");
             const workflowControlContext = context.get("workflowControlContext");
             await client2.createEvent({
@@ -36240,7 +36251,7 @@ var init_workflow_step = __esm({
               payload: {},
               workflowId: workflowControlContext.workflow.id,
               schedule: {
-                delay: ms3
+                delay: ms4
               }
             });
             await updateWorkflow({
@@ -36249,7 +36260,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));
             context.get("workflowControlContext").signal.throwIfAborted();
           }
         },
@@ -36260,8 +36271,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 = context.get("workflowControlContext");
@@ -36480,12 +36491,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();
@@ -36612,6 +36624,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 = context.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 = context.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.
@@ -36662,6 +36749,7 @@ var init_workflow_instance = __esm({
           workflow: this.workflow,
           aborted: false,
           failed: false,
+          completed: false,
           acked: false,
           restarted: false,
           signal: abortSignal,
@@ -36676,6 +36764,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;
@@ -36729,7 +36821,8 @@ var init_workflow_instance = __esm({
               step,
               client: this.client,
               execute: this.execute.bind(this),
-              signal: abortSignal
+              signal: abortSignal,
+              workflow: this
             });
             return {
               status: "done",
@@ -36740,6 +36833,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",
@@ -37355,6 +37454,259 @@ var init_tracked_state = __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_context();
+    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 = context.get("tags", { optional: true });
+        const executionFinished = context.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 = context.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 = context.get("client")._inner;
+          const bot2 = context.get("bot", { optional: true });
+          const user2 = context.get("user", { optional: true });
+          const conversation = context.get("conversation", { optional: true });
+          const workflow = context.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 = context.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() {
+        context.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 = context.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) => !k.includes(":")).sort();
+        const initialKeys = Object.keys(this._initialTags).filter((k) => !k.includes(":")).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 && !key.includes(":")) {
+            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
 var init_inspector_handler = __esm({
   "src/runtime/context/inspector-handler.ts"() {
@@ -37436,6 +37788,7 @@ var init_handlers = __esm({
     init_http();
     init_agent_registry();
     init_tracked_state();
+    init_tracked_tags();
     init_tracing();
     init_heavy_imports();
     init_environment();
@@ -38274,38 +38627,6 @@ var init_conversation_instance = __esm({
           });
         }
       }
-      /**
-       * 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]: ""
-          }
-        });
-      }
     };
   }
 });
@@ -38341,19 +38662,11 @@ var init_conversation = __esm({
       /** @internal */
       schema;
       #handler;
-      #startFromTrigger;
       constructor(props) {
         this.channel = props.channel;
         this.events = props.events ?? [];
         this.schema = props.state ?? z19.object({}).passthrough();
         this.#handler = props.handler;
-        if (props.startFromTrigger) {
-          this.#startFromTrigger = props.startFromTrigger;
-        }
-      }
-      /** @internal */
-      get startFromTrigger() {
-        return this.#startFromTrigger;
       }
       /** @internal */
       getDefinition() {
@@ -40773,7 +41086,7 @@ var init_source_website = __esm({
           type: "website",
           state: State,
           async handler({ input, step: step2, state, client: client2 }) {
-            const crypto3 = await import("crypto");
+            const crypto2 = await import("crypto");
             console.log(
               `Starting sync for WebsiteSource [${this.id}] in mode [${this.mode}, maxPages=${this.maxPages}, maxDepth=${this.maxDepth}, baseUrl=${this.baseUrl}, sitemapUrl=${this.sitemapUrl}]`
             );
@@ -40855,7 +41168,7 @@ var init_source_website = __esm({
                   content,
                   metadata: fetchMetadata
                 } = await this.fetchUrl(sitemapUrl.loc);
-                const hash = crypto3.createHash("sha256").update(content).digest("hex");
+                const hash = crypto2.createHash("sha256").update(content).digest("hex");
                 let contentType = fetchedContentType;
                 if (!contentType) {
                   contentType = content.includes("<html") ? "text/html" : "text/markdown";
@@ -47852,7 +48165,7 @@ var init_source_directory = __esm({
             const glob2 = await Promise.resolve().then(() => (init_esm9(), esm_exports3));
             const path4 = await import("path");
             const fs3 = await import("fs/promises");
-            const crypto3 = await import("crypto");
+            const crypto2 = await import("crypto");
             const directory = path4.resolve(adk.environment.agent.directory, this.directoryPath);
             const tags = {
               [WellKnownTags.knowledge.KNOWLEDGE]: "knowledge-base",
@@ -47914,7 +48227,7 @@ var init_source_directory = __esm({
             const upsertFile = async (local) => {
               const key = `data_source://${this.type}/${this.id}/${local.rel}`;
               const content = await fs3.readFile(local.abs);
-              const hash = crypto3.createHash("sha256").update(content).digest("hex");
+              const hash = crypto2.createHash("sha256").update(content).digest("hex");
               const { file } = await client2.getFile({ id: key }).catch(() => ({ file: null }));
               if (!input.force && file?.metadata?.hash === hash) {
                 console.log(`Skipping unchanged file: ${local.rel}`);
@@ -48421,7 +48734,7 @@ var init_primitives = __esm({
 });
 
 // src/runtime/handlers/workflow.ts
-var import_ms2;
+var import_ms3;
 var init_workflow2 = __esm({
   "src/runtime/handlers/workflow.ts"() {
     "use strict";
@@ -48433,7 +48746,7 @@ var init_workflow2 = __esm({
     init_tracing();
     init_adk();
     init_workflow_utils();
-    import_ms2 = __toESM(require_ms(), 1);
+    import_ms3 = __toESM(require_ms(), 1);
   }
 });
 
@@ -48477,259 +48790,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_context();
-    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 = context.get("tags", { optional: true });
-        const executionFinished = context.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 = context.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 = context.get("client")._inner;
-          const bot2 = context.get("bot", { optional: true });
-          const user2 = context.get("user", { optional: true });
-          const conversation = context.get("conversation", { optional: true });
-          const workflow = context.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 = context.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() {
-        context.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 = context.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/client.ts
 import { Client as Client3 } from "@botpress/client";
 function getStandaloneClient() {
@@ -48844,6 +48904,7 @@ export {
   configuration,
   context,
   defineConfig,
+  isEventOfType,
   isWorkflowCallback,
   isWorkflowDataRequest,
   user,