@hexabot-ai/api 3.1.4-alpha.0 → 3.2.0-alpha.0

package/src/channel/lib/Handler.ts

@@ -4,14 +4,21 @@
  * Full terms: see LICENSE.md.
  */
 
+import type {
+  ActionOptions,
+  Attachment,
+  AttachmentRef,
+  Source,
+  StdOutgoingMessageEnvelope,
+} from '@hexabot-ai/types';
+import { StdOutgoingEnvelope } from '@hexabot-ai/types';
 import { Inject, Injectable, OnModuleInit, Type } from '@nestjs/common';
 import { ModuleRef } from '@nestjs/core';
-import { EventEmitter2 } from '@nestjs/event-emitter';
 import { Request, Response } from 'express';
 import mime from 'mime';
 import { v4 as uuidv4 } from 'uuid';
+import z from 'zod';
 
-import { Attachment } from '@/attachment/dto/attachment.dto';
 import { AttachmentService } from '@/attachment/services/attachment.service';
 import {
   AttachmentAccess,
@@ -21,17 +28,22 @@ import {
 } from '@/attachment/types';
 import { MessageInboundEvent } from '@/channel/lib/inbound-events';
 import { SubscriberCreateDto } from '@/chat/dto/subscriber.dto';
-import { StdOutgoingEnvelope } from '@/chat/types/message';
-import type { ActionOptions } from '@/chat/types/options';
-import { I18nService } from '@/i18n';
-import { SettingService } from '@/setting/services/setting.service';
 import { Extension } from '@/utils/generics/extension';
 import { SocketRequest } from '@/websocket/utils/socket-request';
 import { SocketResponse } from '@/websocket/utils/socket-response';
 
-import { ChannelService } from '../channel.service';
+import { ChannelAttachmentService } from '../services/channel-attachment.service';
+import { ChannelRegistry } from '../services/channel-registry.service';
 import { ChannelName } from '../types';
 
+import {
+  ChannelCapabilities,
+  DEFAULT_CHANNEL_CAPABILITIES,
+} from './channel-capabilities';
+import { ChannelEventBus } from './channel-event-bus';
+import { collectExtensionInjectMeta } from './extension-inject.decorator';
+import { UnsupportedOutgoingFormatError } from './outbound';
+
 @Injectable()
 export default abstract class ChannelHandler<
     N extends ChannelName = ChannelName,
@@ -39,25 +51,25 @@ export default abstract class ChannelHandler<
   extends Extension
   implements OnModuleInit
 {
-  @Inject(I18nService)
-  protected readonly i18n: I18nService;
-
-  @Inject(EventEmitter2)
-  protected readonly eventEmitter: EventEmitter2;
-
   @Inject(AttachmentService)
   public readonly attachmentService: AttachmentService;
 
-  @Inject(SettingService)
-  protected readonly settingService: SettingService;
+  @Inject(ChannelAttachmentService)
+  protected readonly channelAttachmentService: ChannelAttachmentService;
 
-  @Inject(ChannelService)
-  protected readonly channelService: ChannelService;
+  @Inject(ChannelRegistry)
+  protected readonly channelRegistry: ChannelRegistry;
+
+  @Inject(ChannelEventBus)
+  protected readonly channelEventBus: ChannelEventBus;
 
   @Inject(ModuleRef)
   private readonly moduleRef: ModuleRef;
 
-  constructor(name: N) {
+  constructor(
+    name: N,
+    private readonly sourceSettingsSchema: z.ZodTypeAny = z.strictObject({}),
+  ) {
     super(name);
   }
 
@@ -67,10 +79,19 @@ export default abstract class ChannelHandler<
 
   async onModuleInit() {
     await super.onModuleInit();
-    this.channelService.setChannel(
+    this.channelRegistry.setChannel(
       this.getName(),
       this as unknown as ChannelHandler<N>,
     );
+
+    const metas = collectExtensionInjectMeta(this);
+    await Promise.all(
+      metas.map(async ({ propertyKey, factory }) => {
+        (this as any)[propertyKey] = await this.createModuleRef(
+          factory(this.getName()),
+        );
+      }),
+    );
   }
 
   protected async createModuleRef<T>(provider: Type<T>): Promise<T> {
@@ -78,14 +99,31 @@ export default abstract class ChannelHandler<
   }
 
   /**
-   * Returns the channel's settings
-   * @returns Channel's settings
+   * Returns the capabilities this channel supports.
+   *
+   * Defaults to all formats enabled with no text length limit. Override in
+   * concrete channel handlers to declare which envelope formats and transport
+   * features the platform actually supports.
    */
-  async getSettings<S extends string = N>() {
-    const settings = await this.settingService.getSettings();
+  getCapabilities(): ChannelCapabilities {
+    return DEFAULT_CHANNEL_CAPABILITIES;
+  }
 
-    // @ts-expect-error workaround typing
-    return settings[this.getName() as keyof Settings] as Settings[S];
+  getSourceSettingsSchema(): z.ZodTypeAny {
+    return this.sourceSettingsSchema;
+  }
+
+  /**
+   * Throws when the envelope's format is not supported by this channel.
+   * The `system` format always throws — it is internal and must never reach
+   * the transport layer.
+   */
+  private assertCapability(envelope: StdOutgoingEnvelope): void {
+    const caps = this.getCapabilities();
+    // caps[system] is undefined (not in ChannelCapabilities) → always throws
+    if (!caps[envelope.type as keyof ChannelCapabilities]) {
+      throw new UnsupportedOutgoingFormatError(envelope.type);
+    }
   }
 
   /**
@@ -97,21 +135,40 @@ export default abstract class ChannelHandler<
   abstract handle(
     req: Request | SocketRequest,
     res: Response | SocketResponse,
+    source: Source,
     workflowId?: string,
   ): any;
 
   /**
    * Send a channel Message to the end user
    * @param event - Incoming event/message being responded to
-   * @param envelope - The message to be sent {format, message}
+   * @param envelope - The message to be sent `{ type, data }`
    * @param options - Might contain additional settings
    * @returns {Promise} - The channel's response, otherwise an error
    
    */
-  abstract sendMessage(
+  async sendMessage(
     event: MessageInboundEvent<N>,
     envelope: StdOutgoingEnvelope,
     options: ActionOptions,
+  ): Promise<{ mid: string }> {
+    this.assertCapability(envelope);
+
+    return this.doSendMessage(
+      event,
+      envelope as StdOutgoingMessageEnvelope,
+      options,
+    );
+  }
+
+  /**
+   * Channel-specific send implementation. Called by `sendMessage` after the
+   * capability guard passes. The `system` format is never passed here.
+   */
+  protected abstract doSendMessage(
+    event: MessageInboundEvent<N>,
+    envelope: StdOutgoingMessageEnvelope,
+    options: ActionOptions,
   ): Promise<{ mid: string }>;
 
   /**
@@ -201,4 +258,22 @@ export default abstract class ChannelHandler<
   public async hasDownloadAccess(attachment: Attachment, _req: Request) {
     return attachment.access === AttachmentAccess.Public;
   }
+
+  /**
+   * Returns a publicly accessible URL for an attachment.
+   *
+   * Default: generates a signed Hexabot download URL
+   * (`/webhook/:sourceRef/download/:name?t=<jwt>`).
+   *
+   * Override in HTTP-based channels (Facebook, WhatsApp, …) when the
+   * messaging platform fetches the URL itself and the JWT-signed scheme
+   * would not be appropriate (e.g. upload the file to the platform's media
+   * API once and return the resulting permanent media URL instead).
+   */
+  public async getAttachmentPublicUrl(
+    sourceId: string,
+    attachment: AttachmentRef,
+  ): Promise<string> {
+    return this.channelAttachmentService.getPublicUrl(sourceId, attachment);
+  }
 }

package/src/channel/lib/__test__/common.mock.ts

@@ -4,28 +4,29 @@
  * Full terms: see LICENSE.md.
  */
 
+import {
+  FileType,
+  ButtonType,
+  OutgoingMessageType,
+  StdOutgoingAttachmentMessageData,
+  StdOutgoingButtonsMessageData,
+  StdOutgoingListMessageData,
+  StdOutgoingQuickRepliesMessageData,
+  StdOutgoingTextMessageData,
+} from '@hexabot-ai/types';
+
 import { AttachmentOrmEntity } from '@/attachment/entities/attachment.entity';
 import {
   AttachmentAccess,
   AttachmentCreatedByRef,
   AttachmentResourceRef,
 } from '@/attachment/types';
-import { FileType } from '@/chat/types/attachment';
-import { ButtonType } from '@/chat/types/button';
-import {
-  OutgoingMessageFormat,
-  StdOutgoingAttachmentMessage,
-  StdOutgoingButtonsMessage,
-  StdOutgoingListMessage,
-  StdOutgoingQuickRepliesMessage,
-  StdOutgoingTextMessage,
-} from '@/chat/types/message';
 
-export const textMessage: StdOutgoingTextMessage = {
+export const textMessage: StdOutgoingTextMessageData = {
   text: 'Hello World',
 };
 
-export const quickRepliesMessage: StdOutgoingQuickRepliesMessage = {
+export const quickRepliesMessage: StdOutgoingQuickRepliesMessageData = {
   text: 'Choose one option',
   quickReplies: [
     {
@@ -39,7 +40,7 @@ export const quickRepliesMessage: StdOutgoingQuickRepliesMessage = {
   ],
 };
 
-export const buttonsMessage: StdOutgoingButtonsMessage = {
+export const buttonsMessage: StdOutgoingButtonsMessageData = {
   text: 'Hit one of these buttons :',
   buttons: [
     {
@@ -57,7 +58,7 @@ export const buttonsMessage: StdOutgoingButtonsMessage = {
   ],
 };
 
-export const urlButtonsMessage: StdOutgoingButtonsMessage = {
+export const urlButtonsMessage: StdOutgoingButtonsMessageData = {
   text: 'Hit one of these buttons :',
   buttons: [
     {
@@ -100,9 +101,9 @@ const attachment: AttachmentOrmEntity = Object.assign(
   },
 );
 
-export const contentMessage: StdOutgoingListMessage = {
+export const contentMessage: StdOutgoingListMessageData = {
   options: {
-    display: OutgoingMessageFormat.list,
+    display: OutgoingMessageType.list,
     fields: {
       title: 'title',
       subtitle: 'desc',
@@ -158,7 +159,7 @@ export const contentMessage: StdOutgoingListMessage = {
   },
 };
 
-export const attachmentMessage: StdOutgoingAttachmentMessage = {
+export const attachmentMessage: StdOutgoingAttachmentMessageData = {
   attachment: {
     type: FileType.image,
     payload: { id: attachment.id },

package/src/channel/lib/__test__/label.mock.ts

@@ -4,7 +4,7 @@
  * Full terms: see LICENSE.md.
  */
 
-import { Label } from '@/chat/dto/label.dto';
+import { Label } from '@hexabot-ai/types';
 
 import { modelInstance } from './base.mock';
 

package/src/channel/lib/__test__/subscriber.mock.ts

@@ -4,7 +4,7 @@
  * Full terms: see LICENSE.md.
  */
 
-import { Subscriber } from '@/chat/dto/subscriber.dto';
+import { Subscriber } from '@hexabot-ai/types';
 
 import { modelInstance } from './base.mock';
 import { customerLabelsMock } from './label.mock';
@@ -27,6 +27,7 @@ export const subscriberInstance: Subscriber = {
   },
   labels: [],
   avatar: null,
+  source: 'aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa',
   ...modelInstance,
 };
 

package/src/channel/lib/channel-capabilities.ts

@@ -0,0 +1,37 @@
+/*
+ * Hexabot — Fair Core License (FCL-1.0-ALv2)
+ * Copyright (c) 2025 Hexastack.
+ * Full terms: see LICENSE.md.
+ */
+
+import { OutgoingMessageType } from '@hexabot-ai/types';
+
+/**
+ * Declares which outgoing message formats and transport features a channel
+ * supports. The base handler uses this at send time to reject envelopes that
+ * would silently fail or throw on the channel side.
+ *
+ * Set `maxTextLength` to 0 to indicate no known limit.
+ */
+export interface ChannelCapabilities {
+  [OutgoingMessageType.text]: boolean;
+  [OutgoingMessageType.quickReply]: boolean;
+  [OutgoingMessageType.buttons]: boolean;
+  [OutgoingMessageType.attachment]: boolean;
+  [OutgoingMessageType.list]: boolean;
+  [OutgoingMessageType.carousel]: boolean;
+  typingIndicator: boolean;
+  maxTextLength: number;
+}
+
+/** Full-featured default — channels override specific fields to restrict. */
+export const DEFAULT_CHANNEL_CAPABILITIES: Readonly<ChannelCapabilities> = {
+  [OutgoingMessageType.text]: true,
+  [OutgoingMessageType.quickReply]: true,
+  [OutgoingMessageType.buttons]: true,
+  [OutgoingMessageType.attachment]: true,
+  [OutgoingMessageType.list]: true,
+  [OutgoingMessageType.carousel]: true,
+  typingIndicator: false,
+  maxTextLength: 0,
+};

package/src/channel/lib/channel-codec.ts

@@ -0,0 +1,48 @@
+/*
+ * Hexabot — Fair Core License (FCL-1.0-ALv2)
+ * Copyright (c) 2025 Hexastack.
+ * Full terms: see LICENSE.md.
+ */
+
+import { StdOutgoingEnvelope } from '@hexabot-ai/types';
+
+import type { ChannelName } from '../types';
+
+import type { ChannelInboundEvent } from './inbound-events/channel-inbound-event';
+
+/**
+ * A channel's complete wire-format contract: inbound parsing and outbound
+ * serialisation in one object.
+ *
+ * Grouping encoder and decoder here makes it clear they are two sides of the
+ * same protocol. Channels that currently provide separate
+ * `ChannelInboundEventDecoder` / `ChannelOutboundMessageEncoder` instances
+ * can satisfy this interface by composing them.
+ *
+ * @typeParam N  - Channel name literal
+ * @typeParam In - Raw inbound payload type (e.g. the platform's webhook body)
+ * @typeParam Out - Encoded outbound message type sent back to the platform
+ * @typeParam Opt - Encode-time options (e.g. `ActionOptions`)
+ */
+export interface ChannelCodec<
+  N extends ChannelName,
+  In = unknown,
+  Out = unknown,
+  Opt = unknown,
+> {
+  /**
+   * Parse a raw inbound payload into one or more typed channel events.
+   *
+   * Returns an array because some platforms batch multiple interactions in a
+   * single webhook call (e.g. Facebook's `entry[].messaging[]` structure).
+   */
+  decode(
+    raw: In,
+    channelAttrs: SubscriberChannelDict[N],
+  ): Promise<ChannelInboundEvent<N>[]> | ChannelInboundEvent<N>[];
+
+  /**
+   * Serialise a standard outgoing envelope into the channel's wire format.
+   */
+  encode(envelope: StdOutgoingEnvelope, options?: Opt): Promise<Out> | Out;
+}

package/src/channel/lib/channel-event-bus.ts

@@ -0,0 +1,70 @@
+/*
+ * Hexabot — Fair Core License (FCL-1.0-ALv2)
+ * Copyright (c) 2025 Hexastack.
+ * Full terms: see LICENSE.md.
+ */
+
+import { StdEventType } from '@hexabot-ai/types';
+import { Injectable } from '@nestjs/common';
+import { EventEmitter2 } from '@nestjs/event-emitter';
+
+import { MessageCreateDto } from '@/chat/dto/message.dto';
+
+import type ChannelInboundEvent from './inbound-events/channel-inbound-event';
+import type MessageInboundEvent from './inbound-events/message-inbound-event';
+
+/**
+ * Canonical event name registry for all chatbot hook integrations.
+ *
+ * Using constants here instead of interpolated strings means a typo becomes a
+ * compile error rather than a silent missed event.
+ */
+export const ChannelHookEvent = {
+  message: 'hook:chatbot:message',
+  sent: 'hook:chatbot:sent',
+  delivery: `hook:chatbot:${StdEventType.delivery}`,
+  read: `hook:chatbot:${StdEventType.read}`,
+  typing: `hook:chatbot:${StdEventType.typing}`,
+  follow: `hook:chatbot:${StdEventType.follow}`,
+  echo: `hook:chatbot:${StdEventType.echo}`,
+  error: `hook:chatbot:${StdEventType.error}`,
+} as const;
+
+export type ChannelHookEventName =
+  (typeof ChannelHookEvent)[keyof typeof ChannelHookEvent];
+
+/**
+ * Typed facade over EventEmitter2 for chatbot hook integration.
+ *
+ * Injected into every ChannelHandler via NestJS DI. Using the facade instead
+ * of raw string-based emitAsync/emit calls makes the integration contract
+ * explicit and compiler-checkable.
+ */
+@Injectable()
+export class ChannelEventBus {
+  constructor(private readonly eventEmitter: EventEmitter2) {}
+
+  /** Dispatch a user-initiated message to the chatbot engine. */
+  async emitMessage(event: MessageInboundEvent): Promise<void> {
+    await this.eventEmitter.emitAsync(ChannelHookEvent.message, event);
+  }
+
+  /**
+   * Record a chatbot-originated message that was synchronised from the client
+   * side (e.g. web widget sending a bot reply for history storage).
+   */
+  emitSent(message: MessageCreateDto, event: MessageInboundEvent): void {
+    this.eventEmitter.emit(ChannelHookEvent.sent, message, event);
+  }
+
+  /**
+   * Dispatch a non-message status event (delivery, read, typing, follow, …).
+   * The hook key is looked up from ChannelHookEvent to avoid interpolated strings.
+   */
+  emitStatusEvent(event: ChannelInboundEvent): void {
+    const type = event.getEventType();
+    const hookKey = `hook:chatbot:${type}` as ChannelHookEventName;
+
+    this.eventEmitter.emit(hookKey, event);
+  }
+}

package/src/channel/lib/extension-inject.decorator.ts

@@ -0,0 +1,67 @@
+/*
+ * Hexabot — Fair Core License (FCL-1.0-ALv2)
+ * Copyright (c) 2025 Hexastack.
+ * Full terms: see LICENSE.md.
+ */
+
+import { Type } from '@nestjs/common';
+
+const EXTENSION_INJECT_META = Symbol('extension:inject');
+
+type ExtensionProviderFactory = (extensionName: string) => Type<any>;
+
+interface ExtensionInjectMeta {
+  propertyKey: string | symbol;
+  factory: ExtensionProviderFactory;
+}
+
+/**
+ * Declare a lazily-instantiated, per-extension provider on a handler property.
+ *
+ * The base ChannelHandler resolves all decorated properties during onModuleInit
+ * via ModuleRef.create(), so the full NestJS DI lifecycle is respected.
+ *
+ * Pass a plain class for providers that don't depend on the extension name:
+ *   @ExtensionInject(WebSessionService)
+ *
+ * Pass an arrow-function factory when the provider type is built from the name:
+ *   @ExtensionInject((name) => createWebOutboundMessageEncoder(name))
+ */
+export function ExtensionInject(
+  ref: Type<any> | ExtensionProviderFactory,
+): PropertyDecorator {
+  // Arrow functions have no .prototype; class constructors always do.
+  const factory: ExtensionProviderFactory = ref.prototype
+    ? () => ref as Type<any>
+    : (ref as ExtensionProviderFactory);
+
+  return (target, propertyKey) => {
+    const existing: ExtensionInjectMeta[] =
+      Reflect.getOwnMetadata(EXTENSION_INJECT_META, target) ?? [];
+    Reflect.defineMetadata(
+      EXTENSION_INJECT_META,
+      [...existing, { propertyKey, factory }],
+      target,
+    );
+  };
+}
+
+/**
+ * Collects all @ExtensionInject() metadata across the full prototype chain of
+ * an instance, from the topmost ancestor down to the concrete class, so that
+ * parent-class providers are instantiated before child-class ones.
+ */
+export function collectExtensionInjectMeta(
+  instance: object,
+): ExtensionInjectMeta[] {
+  const result: ExtensionInjectMeta[] = [];
+  let proto = Object.getPrototypeOf(instance);
+  while (proto && proto !== Object.prototype) {
+    const meta: ExtensionInjectMeta[] =
+      Reflect.getOwnMetadata(EXTENSION_INJECT_META, proto) ?? [];
+    result.unshift(...meta);
+    proto = Object.getPrototypeOf(proto);
+  }
+
+  return result;
+}

package/src/channel/lib/inbound-events/channel-inbound-event-context.ts

@@ -19,6 +19,8 @@ export class ChannelInboundEventContext<
     private eventId: string | null = null,
     private senderForeignId: string | null = null,
     private recipientForeignId: string | null = null,
+    private sourceId: string | null = null,
+    private sourceSettings: Record<string, unknown> = {},
   ) {}
 
   getChannel(): N {
@@ -33,6 +35,22 @@ export class ChannelInboundEventContext<
     return this.channelAttrs as unknown as T;
   }
 
+  getSourceId(): string | null {
+    return this.sourceId;
+  }
+
+  setSourceId(sourceId: string | null): void {
+    this.sourceId = sourceId;
+  }
+
+  getSourceSettings<T = Record<string, unknown>>(): T {
+    return this.sourceSettings as T;
+  }
+
+  setSourceSettings(sourceSettings: Record<string, unknown>): void {
+    this.sourceSettings = sourceSettings;
+  }
+
   getOccurredAt(): Date {
     return this.occurredAt;
   }

package/src/channel/lib/inbound-events/channel-inbound-event.ts

@@ -4,9 +4,9 @@
  * Full terms: see LICENSE.md.
  */
 
-import { Subscriber } from '@/chat';
+import { Subscriber, StdEventType } from '@hexabot-ai/types';
+
 import { SubscriberChannelData } from '@/chat/types/channel';
-import { StdEventType } from '@/chat/types/message';
 import { WorkflowType } from '@/workflow/types';
 
 import { TriggerEventWrapper } from '../../../workflow/lib/trigger-event-wrapper';
@@ -76,6 +76,24 @@ export abstract class ChannelInboundEvent<
     } as SubscriberChannelData<N>;
   }
 
+  setSourceContext(
+    sourceId: string,
+    sourceSettings: Record<string, unknown>,
+  ): void {
+    this.context.setSourceId(sourceId);
+    this.context.setSourceSettings(sourceSettings);
+  }
+
+  getSourceId(): string | null {
+    return this.context.getSourceId();
+  }
+
+  getSourceSettings<
+    T extends Record<string, unknown> = Record<string, unknown>,
+  >(): T {
+    return this.context.getSourceSettings<T>();
+  }
+
   protected requireEventId(): string {
     const eventId = this.context.getEventId();
 
@@ -102,6 +120,22 @@ export abstract class ChannelInboundEvent<
     return senderForeignId;
   }
 
+  /**
+   * Returns the sender's platform identifier, or null for events where the
+   * sender is not the end-user (e.g. delivery receipts whose "sender" is the
+   * bot page / phone number).
+   */
+  getSenderForeignId(): string | null {
+    return this.context.getSenderForeignId();
+  }
+
+  /**
+   * Returns the recipient's platform identifier, or null when not set.
+   */
+  getRecipientForeignId(): string | null {
+    return this.context.getRecipientForeignId();
+  }
+
   protected setSenderForeignId(senderForeignId: string | null): void {
     this.context.setSenderForeignId(senderForeignId);
   }
@@ -113,6 +147,7 @@ export abstract class ChannelInboundEvent<
   getMetadata(): Record<string, unknown> {
     return {
       channel: this.getChannelData(),
+      source_id: this.getSourceId(),
       thread_id: this.getThreadId() ?? null,
     };
   }
@@ -120,6 +155,8 @@ export abstract class ChannelInboundEvent<
   getContextData(): Record<string, unknown> {
     return {
       channel: this.getChannelData(),
+      sourceId: this.getSourceId(),
+      sourceSettings: this.getSourceSettings(),
       initiator: this.getInitiator(),
       threadId: this.getThreadId() ?? null,
     };

package/src/channel/lib/inbound-events/message-inbound-event.ts

@@ -8,8 +8,9 @@ import {
   IncomingMessageType,
   StdEventType,
   StdIncomingMessage,
-} from '@/chat/types/message';
-import { Payload } from '@/chat/types/quick-reply';
+  Payload,
+} from '@hexabot-ai/types';
+
 import { ConversationalWorkflowInput } from '@/workflow/schemas/workflow-input-schemas';
 
 import { ChannelName } from '../../types';
@@ -55,12 +56,16 @@ export abstract class MessageInboundEvent<
   getText(): string {
     const message = this.getMessage();
 
-    if ('text' in message) {
-      return message.text;
+    if (
+      message.type === IncomingMessageType.text ||
+      message.type === IncomingMessageType.postback ||
+      message.type === IncomingMessageType.quickReply
+    ) {
+      return message.data.text;
     }
 
-    if ('serialized_text' in message) {
-      return message.serialized_text;
+    if (message.type === IncomingMessageType.attachment) {
+      return message.data.serializedText;
     }
 
     return '';