@botpress/runtime 1.2.3 → 1.2.5

package/dist/internal.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({
@@ -36437,6 +36478,14 @@ init_define_PACKAGE_VERSIONS();
 // src/consts.ts
 init_define_BUILD();
 init_define_PACKAGE_VERSIONS();
+var BOT_ID_HEADER = "x-bot-id";
+var BOT_USER_ID_HEADER = "x-bot-user-id";
+var WEBHOOK_ID_HEADER = "x-webhook-id";
+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/handlers.ts
 import { Client } from "@botpress/client";
@@ -40431,6 +40480,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
@@ -40474,8 +40525,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}>`);
         }
@@ -40601,6 +40653,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",
@@ -40945,7 +40998,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,
@@ -40957,8 +41020,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) => {
@@ -40979,36 +41041,9 @@ function installStructuredLogging() {
 }
 
 // src/runtime.ts
+init_trigger_tags();
 import { z as z4 } from "@botpress/sdk";
 
-// src/utilities/trigger-tags.ts
-init_define_BUILD();
-init_define_PACKAGE_VERSIONS();
-import crypto2 from "crypto";
-var hashString = (str) => {
-  return crypto2.createHash("md5").update(str).digest("hex").substring(0, 5).toUpperCase();
-};
-var getTriggerTagName = (triggerName) => {
-  return `trigger${hashString(triggerName)}`;
-};
-var getTriggerTagValue = (key) => {
-  return key ?? "*";
-};
-var getTriggerSubscriptionTags = (triggerName, key) => {
-  return {
-    name: getTriggerTagName(triggerName),
-    value: getTriggerTagValue(key)
-  };
-};
-var isConversationSubscribedToTrigger = (conversationTags, triggerName, triggerKey) => {
-  const tagName = getTriggerTagName(triggerName);
-  const tagValue = conversationTags[tagName];
-  if (!tagValue) {
-    return false;
-  }
-  return tagValue === "*" || tagValue === triggerKey;
-};
-
 // src/types.ts
 init_define_BUILD();
 init_define_PACKAGE_VERSIONS();
@@ -41087,8 +41122,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) {
@@ -41456,10 +41489,15 @@ var EMPTY_STATE = {
 };
 var MAX_SWAP_FILE_SIZE = import_bytes2.default.parse("100MB");
 var BUILT_IN_STATES = {
-  user: "userState",
+  /** Generic conversation-specific state (user-defined per conversation) */
   conversation: "state",
+  /** User-specific state (persists across conversations per user) */
+  user: "userState",
+  /** Bot-wide global state (persists across all conversations) */
   bot: "botState",
+  /** Workflow-specific state (persists across workflow executions) */
   workflowState: "workflowState",
+  /** Workflow cached steps executions */
   workflowSteps: "workflowSteps"
 };
 var TrackedState = class _TrackedState {
@@ -41532,6 +41570,7 @@ var TrackedState = class _TrackedState {
       const client = context.get("client")._inner;
       const botId = context.get("botId", { optional: true });
       const user2 = context.get("user", { optional: true });
+      const conversation = context.get("conversation", { optional: true });
       if (botId) {
         _TrackedState.create({
           client,
@@ -41550,6 +41589,23 @@ var TrackedState = class _TrackedState {
           schema: adk.project.config.user?.state || z9.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 || z9.object({})
+        });
+      }
       const states = context.get("states", { optional: true });
       const promises = Promise.allSettled(
         states?.map((state) => state.load()) ?? []
@@ -41596,16 +41652,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 {
@@ -42215,24 +42278,145 @@ init_define_BUILD();
 init_define_PACKAGE_VERSIONS();
 import { z as z13 } from "@botpress/sdk";
 import { setTimeout as setTimeout2 } from "node:timers/promises";
+
+// src/primitives/conversation-instance.ts
+init_define_BUILD();
+init_define_PACKAGE_VERSIONS();
+var BaseConversationInstance = class {
+  id;
+  channel;
+  integration;
+  tags;
+  conversation;
+  // @internal
+  client;
+  // @internal
+  TrackedState;
+  constructor(conversation, client) {
+    this.id = conversation.id;
+    this.channel = conversation.channel;
+    this.integration = conversation.integration;
+    this.tags = conversation.tags;
+    this.conversation = conversation;
+    this.client = client;
+    const states = context.get("states", { optional: true });
+    const existingState = states?.find(
+      (s) => s.type === "conversation" && s.id === conversation.id && s.name === BUILT_IN_STATES.conversation
+    );
+    if (!existingState) {
+      throw new Error(
+        `Conversation state not found for conversation ${conversation.id}. Make sure TrackedState.loadAll() is called before creating conversation instances.`
+      );
+    }
+    this.TrackedState = existingState;
+  }
+  /**
+   * Send a message to this conversation
+   */
+  async send(message) {
+    try {
+      const chat = context.get("chat");
+      await trackPromise(
+        chat.sendMessage({
+          type: message.type,
+          payload: message.payload
+        })
+      );
+    } catch (err) {
+      console.error("Error sending message in conversation:", err);
+    }
+  }
+  /**
+   * Start typing indicator
+   */
+  async startTyping() {
+    const mapping = InterfaceMappings.getIntegrationAction(
+      "typingIndicator",
+      "startTypingIndicator",
+      this.integration
+    );
+    if (mapping) {
+      const message = context.get("message", { optional: true });
+      await this.client.callAction({
+        type: mapping,
+        input: {
+          conversationId: this.id,
+          messageId: message?.id
+        }
+      }).catch(() => {
+      });
+    }
+  }
+  /**
+   * Stop typing indicator
+   */
+  async stopTyping() {
+    const mapping = InterfaceMappings.getIntegrationAction(
+      "typingIndicator",
+      "stopTypingIndicator",
+      this.integration
+    );
+    if (mapping) {
+      const message = context.get("message", { optional: true });
+      await this.client.callAction({
+        type: mapping,
+        input: {
+          conversationId: this.id,
+          messageId: message?.id
+        }
+      }).catch(() => {
+      });
+    }
+  }
+  /**
+   * Subscribe to a trigger
+   */
+  async subscribeToTrigger(triggerName, key) {
+    const { getTriggerSubscriptionTags: getTriggerSubscriptionTags2, isConversationSubscribedToTrigger: isConversationSubscribedToTrigger2 } = await Promise.resolve().then(() => (init_trigger_tags(), trigger_tags_exports));
+    if (isConversationSubscribedToTrigger2(this.tags, triggerName, key)) {
+      return;
+    }
+    const { name, value } = getTriggerSubscriptionTags2(triggerName, key);
+    await this.client.updateConversation({
+      id: this.id,
+      tags: {
+        [name]: value
+      }
+    });
+  }
+  /**
+   * Unsubscribe from a trigger
+   */
+  async unsubscribeFromTrigger(triggerName, key) {
+    const { getTriggerSubscriptionTags: getTriggerSubscriptionTags2, isConversationSubscribedToTrigger: isConversationSubscribedToTrigger2 } = await Promise.resolve().then(() => (init_trigger_tags(), trigger_tags_exports));
+    if (!isConversationSubscribedToTrigger2(this.tags, triggerName, key)) {
+      return;
+    }
+    const { name } = getTriggerSubscriptionTags2(triggerName, key);
+    await this.client.updateConversation({
+      id: this.id,
+      tags: {
+        [name]: ""
+      }
+    });
+  }
+};
+
+// src/primitives/conversation.ts
 var ConversationHandler = Symbol.for("conversation.handler");
 var Typings3;
 ((Typings8) => {
   Typings8.Primitive = "conversation";
 })(Typings3 || (Typings3 = {}));
 var BaseConversation = class {
-  integration;
   channel;
   /** @internal */
   schema;
   #handler;
-  #state;
   #startFromTrigger;
-  #interruptionSignal;
   constructor(props) {
     this.channel = props.channel;
     this.schema = props.state ?? z13.object({}).passthrough();
-    this.integration = props.channel.split(".")[0];
     this.#handler = props.handler;
     if (props.startFromTrigger) {
       this.#startFromTrigger = props.startFromTrigger;
@@ -42244,31 +42428,34 @@ var BaseConversation = class {
   }
   /** @internal */
   getDefinition() {
-    return {
-      type: "conversation",
-      channel: this.channel
-    };
-  }
-  set state(state) {
-    this.#state = state;
-  }
-  get state() {
-    return this.#state;
-  }
-  get id() {
-    return context.get("conversation").id;
-  }
-  get tags() {
-    return context.get("conversation").tags;
+    if (this.channel === "*") {
+      return {
+        type: "conversation",
+        channel: "*"
+      };
+    } else if (Array.isArray(this.channel)) {
+      return {
+        type: "conversation",
+        channel: this.channel
+      };
+    } else {
+      return {
+        type: "conversation",
+        channel: this.channel
+      };
+    }
   }
-  // TODO: separate the handler from the conversation definition
-  // TODO: each execution should have its own instance to avoid state conflicts etc
+  /** @internal */
   async [ConversationHandler]() {
     const message = context.get("message", { optional: true });
     const event = context.get("event", { optional: true });
     const chat = context.get("chat");
     const client = context.get("client");
-    const conversationId = this.id;
+    const botpressConversation = context.get("conversation");
+    const conversationInstance = new BaseConversationInstance(
+      botpressConversation,
+      client
+    );
     let type;
     let requestObject = void 0;
     if (message) {
@@ -42293,11 +42480,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() {
@@ -42305,7 +42491,7 @@ var BaseConversation = class {
             return;
           }
           const { events } = await client.listEvents({
-            conversationId,
+            conversationId: conversationInstance.id,
             status: "pending"
           });
           const newEvents = events.filter(
@@ -42361,100 +42547,36 @@ var BaseConversation = class {
     const execute = Autonomous.createExecute({
       mode: "chat",
       defaultModel: adk.project.config.defaultModels.autonomous,
-      ...this.#interruptionSignal && {
-        interruption: this.#interruptionSignal
+      interruption: controller.signal
+    });
+    if (!conversationInstance.TrackedState.value) {
+      conversationInstance.TrackedState.value = {};
+    }
+    const stateProxy = new Proxy(conversationInstance.TrackedState.value, {
+      set(target, prop, value) {
+        const result = Reflect.set(target, prop, value);
+        conversationInstance.TrackedState.markDirty();
+        return result;
       }
     });
-    await this.#handler.call(this, {
+    await this.#handler({
       type,
       message,
       event,
       request: requestObject,
+      conversation: conversationInstance,
+      state: stateProxy,
+      client,
       execute
     });
     controller.abort();
   }
-  async subscribeToTrigger(triggerName, key) {
-    if (isConversationSubscribedToTrigger(this.tags, triggerName, key)) {
-      return;
-    }
-    const conversation = context.get("conversation");
-    const client = context.get("client");
-    const { name, value } = getTriggerSubscriptionTags(triggerName, key);
-    await client.updateConversation({
-      id: conversation.id,
-      tags: {
-        [name]: value
-      }
-    });
-  }
-  async unsubscribeFromTrigger(triggerName, key) {
-    if (!isConversationSubscribedToTrigger(this.tags, triggerName, key)) {
-      return;
-    }
-    const conversation = context.get("conversation");
-    const client = context.get("client");
-    const { name } = getTriggerSubscriptionTags(triggerName, key);
-    await client.updateConversation({
-      id: conversation.id,
-      tags: {
-        [name]: ""
-      }
-    });
-  }
-  async startTyping() {
-    const conversation = context.get("conversation", { optional: true });
-    const message = context.get("message", { optional: true });
-    const mapping = InterfaceMappings.getIntegrationAction(
-      "typingIndicator",
-      "startTypingIndicator",
-      conversation?.integration
-    );
-    if (conversation && mapping) {
-      await context.get("client").callAction({
-        type: mapping,
-        input: {
-          conversationId: conversation.id,
-          messageId: message?.id
-        }
-      }).catch(() => {
-      });
-    }
-  }
-  async stopTyping() {
-    const conversation = context.get("conversation", { optional: true });
-    const message = context.get("message", { optional: true });
-    const mapping = InterfaceMappings.getIntegrationAction(
-      "typingIndicator",
-      "stopTypingIndicator",
-      conversation?.integration
-    );
-    if (conversation && mapping) {
-      await context.get("client").callAction({
-        type: mapping,
-        input: {
-          conversationId: conversation.id,
-          messageId: message?.id
-        }
-      }).catch(() => {
-      });
-    }
-  }
-  async send(message) {
-    try {
-      const chat = context.get("chat");
-      await trackPromise(
-        chat.sendMessage({
-          type: message.type,
-          payload: message.payload
-        })
-      );
-    } catch (err) {
-      console.error("Error getting context in conversation.send:", err);
-    }
-  }
 };
 
+// src/runtime/handlers/conversation-matching.ts
+init_define_BUILD();
+init_define_PACKAGE_VERSIONS();
+
 // src/runtime/handlers/trigger.ts
 init_define_BUILD();
 init_define_PACKAGE_VERSIONS();
@@ -42944,12 +43066,6 @@ var BaseWorkflowInstance = class _BaseWorkflowInstance {
   workflow;
   // @internal
   TrackedState;
-  set state(state) {
-    this.TrackedState.value = state;
-  }
-  get state() {
-    return this.TrackedState.value;
-  }
   constructor(workflow, client) {
     const definition = adk.project.workflows.find(
       (w) => w.name === workflow.name
@@ -42959,7 +43075,7 @@ var BaseWorkflowInstance = class _BaseWorkflowInstance {
       client: client._inner,
       id: workflow.id,
       schema: definition?.stateSchema,
-      name: "workflowState"
+      name: BUILT_IN_STATES.workflowState
     });
     this.id = workflow.id;
     this.name = workflow.name;
@@ -43090,14 +43206,25 @@ var BaseWorkflowInstance = class _BaseWorkflowInstance {
         "Workflow execution state is not loaded"
       );
       workflowExecutionState.value.executionCount++;
+      if (!this.TrackedState.value) {
+        this.TrackedState.value = {};
+      }
+      const trackedState = this.TrackedState;
+      const stateProxy = new Proxy(this.TrackedState.value, {
+        set(target, prop, value) {
+          const result2 = Reflect.set(target, prop, value);
+          trackedState.markDirty();
+          return result2;
+        }
+      });
       const result = await context.run(
         {
           ...ctx,
           workflowControlContext
         },
-        async () => handler.call(this, {
+        async () => handler({
           input: this.input,
-          state: this.state,
+          state: stateProxy,
           step,
           client: this.client,
           execute: this.execute.bind(this)
@@ -43163,7 +43290,7 @@ function createWorkflowExecutionState(client, workflowId) {
     client,
     id: workflowId,
     schema: workflowExecutionContextSchema,
-    name: "workflowExecutionContext"
+    name: BUILT_IN_STATES.workflowSteps
   });
 }
 
@@ -43175,7 +43302,12 @@ var Definitions;
 ((Definitions2) => {
   const conversationDefinitionSchema = z18.object({
     type: z18.literal("conversation"),
-    channel: z18.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: z18.union([
+      z18.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 '*'"),
+      z18.array(
+        z18.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 = z18.object({
     type: z18.literal("workflow"),
@@ -45425,6 +45557,7 @@ var BaseKnowledge = class {
   constructor(props) {
     this.name = props.name;
     this.sources = props.sources;
+    this.description = props.description;
   }
   /** @internal */
   getDefinition() {
@@ -45798,6 +45931,7 @@ var Primitives;
 ((Primitives2) => {
   Primitives2.Definitions = Definitions;
   Primitives2.BaseConversation = BaseConversation;
+  Primitives2.BaseConversationInstance = BaseConversationInstance;
   Primitives2.Conversation = Typings3;
   Primitives2.BaseKnowledge = BaseKnowledge;
   Primitives2.Knowledge = Typings4;
@@ -45871,20 +46005,14 @@ var WorkerPool = class {
   };
   constructor(workerScript) {
     this.workerScript = workerScript || path4.join(process.cwd(), ".botpress/dist/index.cjs");
-    debugLog(
-      "[WorkerPool] Initializing...",
-      this.workerScript,
-      process.cwd()
-    );
+    debugLog("[WorkerPool] Initializing...", this.workerScript, process.cwd());
     this.initialize();
   }
   /**
    * Initialize the worker pool with the configured number of workers
    */
   initialize() {
-    debugLog(
-      `[WorkerPool] Initializing pool with ${WORKER_POOL_SIZE} workers`
-    );
+    debugLog(`[WorkerPool] Initializing pool with ${WORKER_POOL_SIZE} workers`);
     for (let i = 0; i < WORKER_POOL_SIZE; i++) {
       this.createWorker();
     }
@@ -45989,6 +46117,9 @@ var WorkerPool = class {
           case "debug":
             console.debug(prefix, ...args);
             break;
+          case "log":
+            console.log(prefix, ...args);
+            break;
           default:
             debugLog(prefix, ...args);
         }
@@ -46437,7 +46568,7 @@ function initializeParentWorker(bot2) {
         }
       })
     );
-  }, 2e3);
+  }, 500);
 }
 
 // src/workers/dev_worker.ts
@@ -46445,46 +46576,16 @@ init_define_BUILD();
 init_define_PACKAGE_VERSIONS();
 import { parentPort } from "worker_threads";
 var DEBUG_ENABLED3 = process.env.BP_DEBUG === "true" || process.env.BP_DEBUG === "1";
-var originalLog = console.log;
 function debugLog3(...args) {
   if (DEBUG_ENABLED3) {
-    originalLog(...args);
+    console.log(...args);
   }
 }
-function setupLogRelay() {
-  if (!parentPort) return;
-  const originalConsole = {
-    log: console.log,
-    info: console.info,
-    warn: console.warn,
-    error: console.error,
-    debug: console.debug
-  };
-  originalLog = originalConsole.log;
-  const createLogRelay = (level) => {
-    return (...args) => {
-      parentPort.postMessage({
-        type: "log",
-        level,
-        args
-      });
-      if (DEBUG_ENABLED3) {
-        originalConsole[level](...args);
-      }
-    };
-  };
-  console.log = createLogRelay("log");
-  console.info = createLogRelay("info");
-  console.warn = createLogRelay("warn");
-  console.error = createLogRelay("error");
-  console.debug = createLogRelay("debug");
-}
 function runWorker(bot2) {
   const expiryTime = process.env.WORKER_EXPIRY_TIME ? parseInt(process.env.WORKER_EXPIRY_TIME, 10) : Date.now() + 5 * 60 * 1e3;
   if (!parentPort) {
     throw new Error("This script must be run as a worker thread");
   }
-  setupLogRelay();
   parentPort.on("message", async (message) => {
     const { type, taskId, event } = message;
     if (type !== "event" || !taskId) {
@@ -46545,15 +46646,25 @@ var isWorkerMode = () => {
 };
 export {
   Action,
+  BOT_ID_HEADER,
+  BOT_USER_ID_HEADER,
+  BUILT_IN_STATES,
+  BaseConversationInstance,
   BaseWorkflowInstance,
   BuiltInWorkflows,
+  CONFIGURATION_PAYLOAD_HEADER,
+  CONFIGURATION_TYPE_HEADER,
   BaseConversation as Conversation,
   DataSource2 as DataSource,
   Errors,
   BaseKnowledge as Knowledge,
+  LOG_DELIMITER,
+  OPERATION_SUBTYPE_HEADER,
+  OPERATION_TYPE_HEADER,
   Primitives,
   BaseTable as Table,
   Trigger,
+  WEBHOOK_ID_HEADER,
   BaseWorkflow as Workflow,
   contextManager,
   createSpan,