@botpress/runtime 1.13.16 → 1.13.17

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.13.16", adk: "1.13.16", sdk: "5.0.2", llmz: "0.0.37", zai: "2.5.6", cognitive: "0.3.3" };
+    define_PACKAGE_VERSIONS_default = { runtime: "1.13.17", adk: "1.13.17", sdk: "5.0.2", llmz: "0.0.37", zai: "2.5.6", cognitive: "0.3.3" };
   }
 });
 
@@ -36393,7 +36393,13 @@ var init_tracked_state = __esm({
 function isSystemTag(key) {
   return key.includes(":");
 }
-var TrackedTags;
+function isBuiltInTag(key) {
+  return key in BUILT_IN_TAGS.bot || key in BUILT_IN_TAGS.user || key in BUILT_IN_TAGS.conversation || key in BUILT_IN_TAGS.message || key in BUILT_IN_TAGS.workflow;
+}
+function getBuiltInTagsForType(type) {
+  return Object.keys(BUILT_IN_TAGS[type]);
+}
+var BUILT_IN_TAGS, TrackedTags;
 var init_tracked_tags = __esm({
   "src/runtime/tracked-tags.ts"() {
     "use strict";
@@ -36402,6 +36408,19 @@ var init_tracked_tags = __esm({
     init_context();
     init_tracing();
     init_adk();
+    BUILT_IN_TAGS = {
+      conversation: {
+        /** Last synced message timestamp - automatically updated when messages are processed */
+        adkSyncTs: {
+          title: "ADK Sync Timestamp",
+          description: "Built-in: Last synced message timestamp. Automatically updated by the ADK when messages are processed."
+        }
+      },
+      user: {},
+      bot: {},
+      message: {},
+      workflow: {}
+    };
     TrackedTags = class _TrackedTags {
       type;
       id;
@@ -36431,10 +36450,18 @@ var init_tracked_tags = __esm({
           return match2;
         }
         const instance = new _TrackedTags(props);
+        const builtInTagKeys = getBuiltInTagsForType(props.type);
+        const builtInTagDefaults = {};
+        for (const key of builtInTagKeys) {
+          builtInTagDefaults[key] = void 0;
+        }
         if (props.initialTags) {
-          instance._tags = { ...props.initialTags };
-          instance._initialTags = { ...props.initialTags };
+          instance._tags = { ...builtInTagDefaults, ...props.initialTags };
+          instance._initialTags = { ...builtInTagDefaults, ...props.initialTags };
           instance._loaded = true;
+        } else {
+          instance._tags = { ...builtInTagDefaults };
+          instance._initialTags = { ...builtInTagDefaults };
         }
         tags?.push(instance);
         return instance;
@@ -36533,9 +36560,14 @@ var init_tracked_tags = __esm({
             id: this.id
           },
           async () => {
+            const builtInTagKeys = getBuiltInTagsForType(this.type);
+            const builtInTagDefaults = {};
+            for (const key of builtInTagKeys) {
+              builtInTagDefaults[key] = void 0;
+            }
             const tags = await this.fetchTags();
-            this._tags = { ...tags };
-            this._initialTags = { ...tags };
+            this._tags = { ...builtInTagDefaults, ...tags };
+            this._initialTags = { ...builtInTagDefaults, ...tags };
             this._loaded = true;
           }
         );
@@ -36656,7 +36688,7 @@ var init_tracked_tags = __esm({
           if (value === void 0 || isSystemTag(key)) {
             continue;
           }
-          if (validKeys.size === 0 || validKeys.has(key)) {
+          if (isBuiltInTag(key) || validKeys.size === 0 || validKeys.has(key)) {
             tagsForApi[key] = value;
           } else {
             skippedTags.push(key);
@@ -36779,6 +36811,99 @@ var init_handlers = __esm({
 });
 
 // src/runtime/chat/truncate-object.ts
+function truncateObject(value, maxChars) {
+  let currentSize = 0;
+  function truncateValue(val) {
+    if (currentSize >= maxChars) {
+      return void 0;
+    }
+    if (val === null || val === void 0) {
+      const size = 4;
+      currentSize += size;
+      return val;
+    }
+    if (typeof val === "boolean") {
+      const size = val ? 4 : 5;
+      currentSize += size;
+      return val;
+    }
+    if (typeof val === "number") {
+      const size = String(val).length;
+      currentSize += size;
+      return val;
+    }
+    if (typeof val === "string") {
+      const availableChars2 = maxChars - currentSize;
+      if (availableChars2 <= 0) {
+        return void 0;
+      }
+      if (val.length <= availableChars2) {
+        currentSize += val.length;
+        return val;
+      }
+      const truncated2 = val.slice(0, availableChars2);
+      currentSize += truncated2.length;
+      return truncated2;
+    }
+    if (Array.isArray(val)) {
+      currentSize += 2;
+      const result2 = [];
+      for (let i = 0; i < val.length; i++) {
+        if (currentSize >= maxChars) {
+          break;
+        }
+        if (i > 0) {
+          currentSize += 1;
+        }
+        const truncated2 = truncateValue(val[i]);
+        if (truncated2 !== void 0 || val[i] === void 0) {
+          result2.push(truncated2);
+        } else {
+          break;
+        }
+      }
+      return result2;
+    }
+    if (typeof val === "object") {
+      currentSize += 2;
+      const result2 = {};
+      const entries = Object.entries(val);
+      for (let i = 0; i < entries.length; i++) {
+        if (currentSize >= maxChars) {
+          break;
+        }
+        const [key, value2] = entries[i];
+        if (i > 0) {
+          currentSize += 1;
+        }
+        const keySize = key.length + 3;
+        if (currentSize + keySize >= maxChars) {
+          break;
+        }
+        currentSize += keySize;
+        const truncatedValue = truncateValue(value2);
+        if (truncatedValue !== void 0 || value2 === void 0) {
+          result2[key] = truncatedValue;
+        }
+      }
+      return result2;
+    }
+    const str = String(val);
+    const availableChars = maxChars - currentSize;
+    if (availableChars <= 0) {
+      return void 0;
+    }
+    if (str.length <= availableChars) {
+      currentSize += str.length;
+      return str;
+    }
+    const truncated = str.slice(0, availableChars);
+    currentSize += truncated.length;
+    return truncated;
+  }
+  const result = truncateValue(value);
+  return { result, size: currentSize };
+}
 var init_truncate_object = __esm({
   "src/runtime/chat/truncate-object.ts"() {
     "use strict";
@@ -36788,6 +36913,46 @@ var init_truncate_object = __esm({
 });
 
 // src/runtime/chat/truncate-transcript.ts
+function truncateTranscript(transcript, options) {
+  const { maxSize, maxSizePerItem } = options;
+  const result = [];
+  let totalSize = 0;
+  for (let i = transcript.length - 1; i >= 0; i--) {
+    const item = transcript[i];
+    const itemSize = getItemSize(item);
+    const effectiveSize = maxSizePerItem ? Math.min(itemSize, maxSizePerItem) : itemSize;
+    if (totalSize + effectiveSize > maxSize) {
+      break;
+    }
+    let processedItem = item;
+    if (maxSizePerItem && itemSize > maxSizePerItem) {
+      if ("content" in item && item.content) {
+        processedItem = {
+          ...item,
+          content: item.content.slice(0, maxSizePerItem)
+        };
+      } else if (item.role === "event" && item.payload) {
+        const truncated = truncateObject(item.payload, maxSizePerItem);
+        processedItem = {
+          ...item,
+          payload: truncated.result
+        };
+      }
+    }
+    result.unshift(processedItem);
+    totalSize += effectiveSize;
+  }
+  return result;
+}
+function getItemSize(item) {
+  if ("content" in item && item.content) {
+    return item.content.length;
+  }
+  if (item.role === "event" && item.payload) {
+    return JSON.stringify(item.payload).length;
+  }
+  return 0;
+}
 var init_truncate_transcript = __esm({
   "src/runtime/chat/truncate-transcript.ts"() {
     "use strict";
@@ -37108,12 +37273,13 @@ ${indent}`);
   }
   return value;
 }
-var dedent;
+var dedent, dedent_default;
 var init_dedent = __esm({
   "../../node_modules/dedent/dist/dedent.mjs"() {
     init_define_BUILD();
     init_define_PACKAGE_VERSIONS();
     dedent = createDedent({});
+    dedent_default = dedent;
   }
 });
 
@@ -37128,6 +37294,9 @@ function isEventMessage(event) {
   }
   return false;
 }
+function isMessage(message) {
+  return message !== null && typeof message === "object" && "id" in message && "type" in message && "payload" in message;
+}
 var init_events2 = __esm({
   "src/utilities/events.ts"() {
     "use strict";
@@ -37138,7 +37307,7 @@ var init_events2 = __esm({
 
 // src/runtime/config.ts
 import { limitConfigs as limitConfigs2 } from "@bpinternal/const";
-var Transcript;
+var Transcript, Analysis, Config;
 var init_config = __esm({
   "src/runtime/config.ts"() {
     "use strict";
@@ -37154,12 +37323,23 @@ var init_config = __esm({
       /** Max bytes for a single message in the transcript */
       TRANSCRIPT_ITEM_MAX_BYTES: 1e4
     };
+    Analysis = {
+      /** How frequently the analysis will be run */
+      ANALYSIS_FREQUENCY_CRON: "*/5 * * * *",
+      // Every 5 minutes
+      /** How many conversations to process in parallel */
+      CONCURRENT_ANALYSIS_LIMIT: 5
+    };
+    Config = {
+      Transcript,
+      Analysis
+    };
   }
 });
 
 // src/runtime/chat/components.ts
 import { messages, z as z14 } from "@botpress/sdk";
-var DefaultMessageTypes, TextComponent, AudioComponent, ImageComponent, VideoComponent, LocationComponent, ChoiceComponent, DropdownComponent, CarouselComponent;
+var DefaultMessageTypes, TextComponent, AudioComponent, ImageComponent, VideoComponent, LocationComponent, ChoiceComponent, DropdownComponent, CarouselComponent, BUILT_IN_INTEGRATIONS, DefaultComponents;
 var init_components = __esm({
   "src/runtime/chat/components.ts"() {
     "use strict";
@@ -37445,11 +37625,23 @@ yield <Message>
         })
       }
     });
+    BUILT_IN_INTEGRATIONS = ["webchat", "slack", "teams", "telegram", "whatsapp", "chat"];
+    DefaultComponents = {
+      Audio: AudioComponent,
+      Image: ImageComponent,
+      Video: VideoComponent,
+      Location: LocationComponent,
+      Choice: ChoiceComponent,
+      Dropdown: DropdownComponent,
+      Carousel: CarouselComponent,
+      Text: TextComponent
+    };
   }
 });
 
 // src/runtime/chat/chat.ts
-import { Chat, isAnyComponent as isAnyComponent2 } from "llmz";
+import { Chat as _llmzChat, isAnyComponent as isAnyComponent2 } from "llmz";
+var Chat;
 var init_chat = __esm({
   "src/runtime/chat/chat.ts"() {
     "use strict";
@@ -37463,6 +37655,426 @@ var init_chat = __esm({
     init_adk();
     init_config();
     init_components();
+    init_tracked_tags();
+    Chat = class extends _llmzChat {
+      _transcript;
+      client;
+      conversation;
+      botId;
+      logger;
+      citations;
+      trackedTags;
+      componentRegistry = /* @__PURE__ */ new Map();
+      constructor(context3) {
+        super({
+          components: async () => this.getComponents(),
+          transcript: async () => this.fetchTranscript(),
+          handler: async (message) => this.handle(message)
+        });
+        this.client = context3.client;
+        this.conversation = context3.conversation;
+        this.botId = context3.botId;
+        this.logger = context3.logger;
+        this.citations = context3.citations;
+        this.trackedTags = TrackedTags.create({
+          type: "conversation",
+          client: this.client._inner,
+          id: this.conversation.id,
+          initialTags: this.conversation.tags
+        });
+        if (BUILT_IN_INTEGRATIONS.includes(this.conversation.integration)) {
+          this.registerComponent({ component: DefaultComponents.Audio });
+          this.registerComponent({ component: DefaultComponents.Image });
+          this.registerComponent({ component: DefaultComponents.Video });
+          this.registerComponent({ component: DefaultComponents.Carousel });
+          this.registerComponent({ component: DefaultComponents.Choice });
+          this.registerComponent({ component: DefaultComponents.Dropdown });
+          this.registerComponent({ component: DefaultComponents.Location });
+        } else {
+          this.registerComponent({ component: DefaultComponents.Text });
+        }
+      }
+      /**
+       * Register a component with an optional handler
+       */
+      registerComponent(registration) {
+        const componentName = registration.component.definition.name.toLowerCase();
+        this.componentRegistry.set(componentName, registration);
+        return this;
+      }
+      /**
+       * Remove a component by name
+       */
+      removeComponent(name) {
+        this.componentRegistry.delete(name.toLowerCase());
+        return this;
+      }
+      /**
+       * Get all registered components
+       */
+      async getComponents() {
+        return Array.from(this.componentRegistry.values()).map((reg) => reg.component);
+      }
+      /**
+       * Clear the entire transcript
+       */
+      async clearTranscript() {
+        this._transcript = [];
+      }
+      /**
+       * Prepend items to the transcript
+       */
+      async prependToTranscript(items) {
+        if (!this._transcript) {
+          throw new Error("Transcript not loaded yet \u2013 please call fetchTranscript() first");
+        }
+        this._transcript = [...items, ...this._transcript];
+      }
+      /**
+       * Get a copy of the current transcript
+       */
+      async getTranscript() {
+        if (!this._transcript) {
+          await this.fetchTranscript();
+        }
+        return [...this._transcript];
+      }
+      /**
+       * Replace the entire transcript
+       */
+      async setTranscript(items) {
+        this._transcript = [...items];
+      }
+      async fetchTranscript() {
+        if (this._transcript) return this._transcript;
+        return await span(
+          "chat.fetchTranscript",
+          {
+            conversationId: this.conversation.id
+          },
+          async () => {
+            const since = this.trackedTags.tags["adkSyncTs"] || "";
+            const fetchUnseenMessages = async () => {
+              return this.client._inner.list.messages({
+                conversationId: this.conversation.id,
+                afterDate: since ? new Date(since).toISOString() : void 0,
+                beforeDate: ""
+              }).collect({ limit: 250 }).then((res) => since ? res.filter((m) => new Date(m.createdAt) > new Date(since)) : res).then((res) => res.sort((a, b) => new Date(a.createdAt).getTime() - new Date(b.createdAt).getTime()));
+            };
+            const fetchTranscriptMessages = async () => {
+              const { state } = await this.client.getOrSetState({
+                id: this.conversation.id,
+                type: "conversation",
+                name: "conversation",
+                payload: { transcript: [] }
+              });
+              this._transcript = state.payload.transcript;
+            };
+            const [unseenMessages] = await Promise.all([fetchUnseenMessages(), fetchTranscriptMessages()]);
+            if (unseenMessages.length > 0) {
+              await Promise.allSettled(
+                unseenMessages.map(async (msg) => {
+                  await this.addMessage(msg);
+                })
+              );
+            }
+            return this._transcript;
+          }
+        );
+      }
+      async compactTranscript() {
+        return await span(
+          "chat.compactTranscript",
+          {
+            conversationId: this.conversation.id
+          },
+          async () => {
+            if (!this._transcript) {
+              throw new Error("Transcript not loaded yet \u2013 please call fetchTranscript() first");
+            }
+            const items = this._transcript?.splice(
+              0,
+              // We want to keep the last N items as higher-precision context
+              Math.max(this._transcript.length - Config.Transcript.SUMMARY_END_PADDING, 0)
+            );
+            try {
+              const summary = await adk.zai.summarize(JSON.stringify(items, null, 2), {
+                length: 250,
+                prompt: dedent_default`
+        You are a transcript summarizer tasked with compressing a long conversation between a user and an AI agent.
+        Your goal is to drastically reduce the transcript length while retaining all key information, decisions, facts, user goals, and outputs.
+
+        Apply the following rules:
+        - Collapse repetitive or verbose exchanges into concise summaries.
+        - Remove fluff, filler words, greetings, small talk, and off-topic digressions.
+        - If multiple turns convey the same intent or clarification, merge them.
+        - Always preserve important questions, answers, decisions, tool calls, results, failures, corrections, and feedback.
+        - Prefer bullet points, numbered lists, or structured sections if it increases clarity.
+        - Assume the summary will be reused for resuming the session or training the assistant, so it must be precise, useful, and unambiguous.
+
+        The final output should feel like a high-value executive summary of a working session, not a chat log.
+        `.trim()
+              });
+              this._transcript?.unshift({
+                id: `summary-${Date.now()}`,
+                role: "summary",
+                content: summary
+              });
+            } catch (err) {
+              this.logger.error("Error compacting transcript", err);
+              this._transcript = [...items ?? [], ...this._transcript];
+            }
+          }
+        );
+      }
+      getRemainingContextSpace() {
+        if (!this._transcript) {
+          throw new Error("Transcript not loaded yet \u2013 please call fetchTranscript() first");
+        }
+        const transcriptSize = JSON.stringify(this._transcript).length;
+        return {
+          messages: Math.max(0, Config.Transcript.SUMMARY_MAX_MESSAGES - this._transcript.length),
+          bytes: Math.max(0, Config.Transcript.SUMMARY_MAX_BYTES - transcriptSize)
+        };
+      }
+      shouldCompactTranscript() {
+        const remaining = this.getRemainingContextSpace();
+        return remaining.bytes <= 0 || remaining.messages <= 0;
+      }
+      async saveTranscript() {
+        if (!this._transcript) return;
+        return await span(
+          "chat.saveTranscript",
+          {
+            conversationId: this.conversation.id
+          },
+          async () => {
+            if (this.shouldCompactTranscript()) {
+              await this.compactTranscript();
+            }
+            const truncated = truncateTranscript(this._transcript, {
+              maxSize: Config.Transcript.SUMMARY_MAX_BYTES,
+              maxSizePerItem: Config.Transcript.TRANSCRIPT_ITEM_MAX_BYTES
+            });
+            await this.client.setState({
+              id: this.conversation.id,
+              type: "conversation",
+              name: "conversation",
+              payload: { transcript: truncated }
+            });
+          }
+        );
+      }
+      async sendMessage(message) {
+        return await span(
+          "chat.sendMessage",
+          {
+            conversationId: this.conversation.id,
+            direction: "outgoing",
+            integration: this.conversation.integration || "-",
+            channel: this.conversation.channel || "-",
+            userId: this.botId,
+            botId: this.botId,
+            "message.type": message.type
+          },
+          async (s) => {
+            const [payload, citations] = this.citations.removeCitationsFromObject(message.payload);
+            const { message: created } = await this.client.createMessage({
+              conversationId: this.conversation.id,
+              tags: message.tags || {},
+              userId: this.botId,
+              type: message.type.toLowerCase(),
+              payload: {
+                ...payload,
+                metadata: { citations }
+              }
+            });
+            s.setAttribute("messageId", created.id);
+            await this.addMessage(created);
+            return created;
+          }
+        );
+      }
+      async transformMessage(message) {
+        let clone = structuredClone(message);
+        clone = await this.__temporary__fixTelegramImage(clone);
+        const attachments = clone.type === "image" && clone.payload.imageUrl ? [
+          {
+            type: "image",
+            url: clone.payload.imageUrl
+          }
+        ] : [];
+        if (clone.type === "bloc") {
+          clone.payload.items = clone.payload.items.filter((item) => {
+            if (item.type === "image" && item.payload.imageUrl) {
+              attachments.push({
+                type: "image",
+                url: item.payload.imageUrl
+              });
+              return false;
+            }
+            return true;
+          });
+        }
+        if (message.direction === "outgoing") {
+          return {
+            id: message.id,
+            role: "assistant",
+            content: JSON.stringify(
+              {
+                type: message.type,
+                payload: message.payload
+              },
+              null,
+              2
+            ),
+            createdAt: message.createdAt
+          };
+        }
+        if (message.direction === "incoming") {
+          return {
+            id: message.id,
+            role: "user",
+            content: JSON.stringify(
+              {
+                type: message.type,
+                payload: message.payload
+              },
+              null,
+              2
+            ),
+            createdAt: message.createdAt,
+            attachments
+          };
+        }
+        return null;
+      }
+      async transformEvent(event) {
+        return {
+          id: event.id,
+          role: "event",
+          name: event.type,
+          payload: event.payload,
+          createdAt: event.createdAt
+        };
+      }
+      async handle(message) {
+        return await span(
+          "chat.sendMessage",
+          {
+            conversationId: this.conversation.id,
+            direction: "outgoing",
+            integration: this.conversation.integration || "-",
+            channel: this.conversation.channel || "-",
+            userId: this.botId,
+            botId: this.botId,
+            "message.type": message.type
+          },
+          async () => {
+            if (message.type === "MESSAGE") {
+              message = Message.parse(message);
+              if (typeof message.props.text === "string") {
+                message.children.push(message.props.text);
+              }
+              for (const msg of message.children) {
+                if (isAnyComponent2(msg)) {
+                  await this.handle(msg);
+                } else if (typeof msg === "string" && msg.trim().length) {
+                  await this.sendMessage({
+                    type: "text",
+                    payload: { text: msg }
+                  });
+                }
+              }
+              return;
+            }
+            const registration = this.componentRegistry.get(message.type.toLowerCase());
+            let componentRegistration = registration;
+            if (!componentRegistration) {
+              for (const [_2, reg] of this.componentRegistry) {
+                if (reg.component.definition.aliases?.map((x) => x.toLowerCase()).includes(message.type.toLowerCase())) {
+                  componentRegistration = reg;
+                  break;
+                }
+              }
+            }
+            if (!componentRegistration) {
+              throw new Error(`Could not find component for message type "${message.type}"`);
+            }
+            if (componentRegistration.handler) {
+              await componentRegistration.handler(message);
+              return;
+            }
+            await this.sendMessage({
+              type: componentRegistration.component.definition.name,
+              payload: message.props
+            });
+          }
+        );
+      }
+      /**
+       * This is a temporary workaround as the Content-Type of images on Telegram are "binary/octet-stream"
+       * And OpenAI integration does not support this type. It needs to be "image/jpeg" or "image/png".
+       * This function fetches the image from Telegram, uploads it to the file storage, and replaces the URL in the message.
+       */
+      async __temporary__fixTelegramImage(message) {
+        if (this.conversation.integration !== "telegram") {
+          return message;
+        }
+        const clone = structuredClone(message);
+        if (clone.type === "image" && clone.payload.imageUrl) {
+          const arrayBuffer = await (await fetch(clone.payload.imageUrl)).arrayBuffer();
+          const buffer = Buffer.from(arrayBuffer);
+          const fileName = clone.payload.imageUrl.split("/").pop() || "image.jpg";
+          const { file } = await this.client.uploadFile({
+            key: `telegram/${this.conversation.id}/${clone.id}/${fileName}`,
+            content: buffer,
+            index: false,
+            accessPolicies: ["public_content"],
+            publicContentImmediatelyAccessible: true,
+            expiresAt: new Date(Date.now() + 1e3 * 60 * 60 * 24).toISOString()
+            // 1 day
+          });
+          clone.payload.imageUrl = file.url;
+        }
+        return clone;
+      }
+      async addEvent(event) {
+        if (!isEvent(event)) {
+          return;
+        }
+        const item = await this.transformEvent(event);
+        if (!item || this._transcript?.find((m) => m.id === event.id)) {
+          return;
+        }
+        let insertIndex = this._transcript?.findIndex(
+          (m) => m.createdAt && new Date(m.createdAt) > new Date(event.createdAt)
+        );
+        this._transcript?.splice(
+          insertIndex === -1 || insertIndex === void 0 ? this._transcript.length : insertIndex,
+          0,
+          item
+        );
+      }
+      async addMessage(message) {
+        if (!isMessage(message)) {
+          return;
+        }
+        const item = await this.transformMessage(message);
+        if (!item || this._transcript?.find((m) => m.id === message.id)) {
+          return;
+        }
+        let insertIndex = this._transcript?.findIndex(
+          (m) => m.createdAt && item.createdAt && new Date(m.createdAt) > new Date(item.createdAt)
+        );
+        this._transcript?.splice(
+          insertIndex === -1 || insertIndex === void 0 ? this._transcript.length : insertIndex,
+          0,
+          item
+        );
+        this.trackedTags.tags["adkSyncTs"] = this._transcript.at(-1).createdAt;
+      }
+    };
   }
 });
 
@@ -37594,14 +38206,11 @@ var init_conversation_instance = __esm({
         const mapping = interfaceMappings.getIntegrationAction("typingIndicator", "startTypingIndicator", this.integration);
         if (mapping) {
           const message = context.get("message", { optional: true });
-          if (!message) {
-            return;
-          }
           await this.client.callAction({
             type: mapping,
             input: {
               conversationId: this.id,
-              messageId: message.id
+              messageId: message?.id || ""
             }
           }).catch(() => {
           });
@@ -37614,14 +38223,11 @@ var init_conversation_instance = __esm({
         const mapping = interfaceMappings.getIntegrationAction("typingIndicator", "stopTypingIndicator", this.integration);
         if (mapping) {
           const message = context.get("message", { optional: true });
-          if (!message) {
-            return;
-          }
           await this.client.callAction({
             type: mapping,
             input: {
               conversationId: this.id,
-              messageId: message.id
+              messageId: message?.id || ""
             }
           }).catch(() => {
           });
@@ -37647,6 +38253,7 @@ var init_conversation = __esm({
     init_events2();
     init_conversation_instance();
     init_workflow_instance();
+    init_chat();
     ConversationHandler = Symbol.for("conversation.handler");
     ((Typings8) => {
       Typings8.Primitive = "conversation";
@@ -37661,12 +38268,15 @@ var init_conversation = __esm({
       events;
       /** @internal */
       schema;
+      /** @internal */
+      chatFactory;
       #handler;
       constructor(props) {
         this.channel = props.channel;
         this.events = props.events ?? [];
         this.schema = props.state ?? z16.object({}).passthrough();
         this.#handler = props.handler;
+        this.chatFactory = props.chat ?? (({ context: context3 }) => new Chat(context3));
       }
       /** @internal */
       getDefinition() {
@@ -37804,7 +38414,8 @@ var init_conversation = __esm({
           conversation: conversationInstance,
           state: stateProxy,
           client: client2,
-          execute
+          execute,
+          chat
         });
         controller.abort();
         void startTypingPromise.then(() => conversationInstance.stopTyping().catch(() => {
@@ -37831,7 +38442,6 @@ var init_conversation2 = __esm({
     init_define_PACKAGE_VERSIONS();
     init_runtime2();
     init_conversation();
-    init_chat2();
     init_tracing();
     init_adk();
     init_conversation_matching();
@@ -38026,6 +38636,7 @@ var init_library = __esm({
     init_runtime2();
     init_client();
     init_primitives();
+    init_chat2();
     init_workflow_utils();
     init_events2();
     init_autonomous();