@elqnt/chat 2.0.7 → 3.0.0

package/dist/transport/index.js

@@ -0,0 +1,875 @@
+"use client";
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// transport/index.ts
+var transport_exports = {};
+__export(transport_exports, {
+  DEFAULT_RETRY_CONFIG: () => DEFAULT_RETRY_CONFIG,
+  calculateRetryInterval: () => calculateRetryInterval,
+  createFetchSSETransport: () => createFetchSSETransport,
+  createLogger: () => createLogger,
+  createSSETransport: () => createSSETransport,
+  createWhatsAppTransport: () => createWhatsAppTransport,
+  mapWhatsAppToChatEvent: () => mapWhatsAppToChatEvent
+});
+module.exports = __toCommonJS(transport_exports);
+
+// transport/types.ts
+function createLogger(debug = false) {
+  return {
+    debug: debug ? console.log.bind(console, "[chat]") : () => {
+    },
+    info: console.info.bind(console, "[chat]"),
+    warn: console.warn.bind(console, "[chat]"),
+    error: console.error.bind(console, "[chat]")
+  };
+}
+var DEFAULT_RETRY_CONFIG = {
+  maxRetries: 10,
+  intervals: [1e3, 2e3, 5e3],
+  backoffMultiplier: 1.5,
+  maxBackoffTime: 3e4
+};
+function calculateRetryInterval(retryCount, config = DEFAULT_RETRY_CONFIG) {
+  const {
+    intervals = DEFAULT_RETRY_CONFIG.intervals,
+    backoffMultiplier = DEFAULT_RETRY_CONFIG.backoffMultiplier,
+    maxBackoffTime = DEFAULT_RETRY_CONFIG.maxBackoffTime
+  } = config;
+  if (retryCount < intervals.length) {
+    return intervals[retryCount];
+  }
+  const baseInterval = intervals[intervals.length - 1] || 5e3;
+  const backoffTime = baseInterval * Math.pow(backoffMultiplier, retryCount - intervals.length + 1);
+  return Math.min(backoffTime, maxBackoffTime);
+}
+
+// transport/sse.ts
+function createSSETransport(options = {}) {
+  const {
+    retryConfig = DEFAULT_RETRY_CONFIG,
+    debug = false,
+    logger = createLogger(debug)
+  } = options;
+  let eventSource;
+  let config;
+  let state = "disconnected";
+  let error;
+  let retryCount = 0;
+  let reconnectTimeout;
+  let intentionalDisconnect = false;
+  const metrics = {
+    latency: 0,
+    messagesSent: 0,
+    messagesReceived: 0,
+    messagesQueued: 0,
+    reconnectCount: 0,
+    transportType: "sse"
+  };
+  const globalHandlers = /* @__PURE__ */ new Set();
+  const typeHandlers = /* @__PURE__ */ new Map();
+  function emit(event) {
+    metrics.messagesReceived++;
+    metrics.lastMessageAt = Date.now();
+    globalHandlers.forEach((handler) => {
+      try {
+        handler(event);
+      } catch (err) {
+        logger.error("Error in message handler:", err);
+      }
+    });
+    const handlers = typeHandlers.get(event.type);
+    if (handlers) {
+      handlers.forEach((handler) => {
+        try {
+          handler(event);
+        } catch (err) {
+          logger.error(`Error in ${event.type} handler:`, err);
+        }
+      });
+    }
+  }
+  async function sendRest(endpoint, body) {
+    if (!config) {
+      throw new Error("Transport not connected");
+    }
+    const url = `${config.baseUrl}/${endpoint}`;
+    logger.debug(`POST ${endpoint}`, body);
+    const response = await fetch(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body)
+    });
+    if (!response.ok) {
+      const errorText = await response.text();
+      throw new Error(`API error: ${response.status} - ${errorText}`);
+    }
+    return response.json();
+  }
+  function handleMessage(event) {
+    if (!event.data || event.data === "") return;
+    try {
+      const data = JSON.parse(event.data);
+      logger.debug("Received:", data.type);
+      emit(data);
+    } catch (err) {
+      logger.error("Failed to parse SSE message:", err);
+    }
+  }
+  function setupEventListeners(es) {
+    es.addEventListener("message", handleMessage);
+    const eventTypes = [
+      "reconnected",
+      "typing",
+      "stopped_typing",
+      "waiting",
+      "waiting_for_agent",
+      "human_agent_joined",
+      "human_agent_left",
+      "chat_ended",
+      "chat_updated",
+      "load_chat_response",
+      "new_chat_created",
+      "show_csat_survey",
+      "csat_response",
+      "user_suggested_actions",
+      "agent_execution_started",
+      "agent_execution_ended",
+      "agent_context_update",
+      "plan_pending_approval",
+      "step_started",
+      "step_completed",
+      "step_failed",
+      "plan_completed",
+      "skills_changed",
+      "summary_update"
+    ];
+    eventTypes.forEach((type) => {
+      es.addEventListener(type, handleMessage);
+    });
+  }
+  function scheduleReconnect() {
+    if (intentionalDisconnect || !config) return;
+    const maxRetries = retryConfig.maxRetries ?? DEFAULT_RETRY_CONFIG.maxRetries;
+    if (retryCount >= maxRetries) {
+      logger.error(`Max retries (${maxRetries}) exceeded`);
+      error = {
+        code: "CONNECTION_FAILED",
+        message: `Max retries (${maxRetries}) exceeded`,
+        retryable: false,
+        timestamp: Date.now()
+      };
+      return;
+    }
+    const interval = calculateRetryInterval(retryCount, retryConfig);
+    retryCount++;
+    metrics.reconnectCount++;
+    logger.info(`Reconnecting in ${interval}ms (attempt ${retryCount})`);
+    state = "reconnecting";
+    reconnectTimeout = setTimeout(() => {
+      if (config) {
+        transport.connect(config).catch((err) => {
+          logger.error("Reconnect failed:", err);
+        });
+      }
+    }, interval);
+  }
+  const transport = {
+    async connect(cfg) {
+      config = cfg;
+      intentionalDisconnect = false;
+      if (eventSource) {
+        eventSource.close();
+        eventSource = void 0;
+      }
+      if (reconnectTimeout) {
+        clearTimeout(reconnectTimeout);
+        reconnectTimeout = void 0;
+      }
+      state = retryCount > 0 ? "reconnecting" : "connecting";
+      return new Promise((resolve, reject) => {
+        const connectionStart = Date.now();
+        const url = `${cfg.baseUrl}/stream?orgId=${cfg.orgId}&userId=${cfg.userId}&clientType=${cfg.clientType}${cfg.chatKey ? `&chatId=${cfg.chatKey}` : ""}`;
+        logger.debug("Connecting to:", url);
+        const es = new EventSource(url);
+        es.onopen = () => {
+          const connectionTime = Date.now() - connectionStart;
+          logger.info(`Connected in ${connectionTime}ms`);
+          state = "connected";
+          error = void 0;
+          retryCount = 0;
+          metrics.connectedAt = Date.now();
+          metrics.latency = connectionTime;
+          setupEventListeners(es);
+          resolve();
+        };
+        es.onerror = () => {
+          if (es.readyState === EventSource.CLOSED) {
+            const sseError = {
+              code: "CONNECTION_FAILED",
+              message: "SSE connection failed",
+              retryable: true,
+              timestamp: Date.now()
+            };
+            error = sseError;
+            metrics.lastError = sseError;
+            state = "disconnected";
+            if (!intentionalDisconnect) {
+              scheduleReconnect();
+            }
+            if (retryCount === 0) {
+              reject(sseError);
+            }
+          }
+        };
+        eventSource = es;
+      });
+    },
+    disconnect(intentional = true) {
+      logger.info("Disconnecting", { intentional });
+      intentionalDisconnect = intentional;
+      if (reconnectTimeout) {
+        clearTimeout(reconnectTimeout);
+        reconnectTimeout = void 0;
+      }
+      if (eventSource) {
+        eventSource.close();
+        eventSource = void 0;
+      }
+      state = "disconnected";
+      retryCount = 0;
+    },
+    async send(event) {
+      if (!config) {
+        throw new Error("Transport not connected");
+      }
+      switch (event.type) {
+        case "message":
+          await sendRest("send", {
+            orgId: event.orgId,
+            chatKey: event.chatKey,
+            userId: event.userId,
+            message: event.message
+          });
+          break;
+        case "typing":
+          await sendRest("typing", {
+            orgId: event.orgId,
+            chatKey: event.chatKey,
+            userId: event.userId,
+            typing: true
+          });
+          break;
+        case "stopped_typing":
+          await sendRest("typing", {
+            orgId: event.orgId,
+            chatKey: event.chatKey,
+            userId: event.userId,
+            typing: false
+          });
+          break;
+        case "load_chat":
+          await sendRest("load", {
+            orgId: event.orgId,
+            chatKey: event.chatKey,
+            userId: event.userId
+          });
+          break;
+        case "new_chat":
+          await sendRest("create", {
+            orgId: event.orgId,
+            userId: event.userId,
+            metadata: event.data
+          });
+          break;
+        case "end_chat":
+          await sendRest("end", {
+            orgId: event.orgId,
+            chatKey: event.chatKey,
+            userId: event.userId,
+            data: event.data
+          });
+          break;
+        default:
+          await sendRest("event", {
+            type: event.type,
+            orgId: event.orgId,
+            chatKey: event.chatKey,
+            userId: event.userId,
+            data: event.data
+          });
+      }
+      metrics.messagesSent++;
+    },
+    async sendMessage(message) {
+      if (!config) {
+        throw new Error("Transport not connected");
+      }
+      await sendRest("send", {
+        orgId: config.orgId,
+        chatKey: config.chatKey,
+        userId: config.userId,
+        message
+      });
+      metrics.messagesSent++;
+    },
+    onMessage(handler) {
+      globalHandlers.add(handler);
+      return () => globalHandlers.delete(handler);
+    },
+    on(eventType, handler) {
+      if (!typeHandlers.has(eventType)) {
+        typeHandlers.set(eventType, /* @__PURE__ */ new Set());
+      }
+      typeHandlers.get(eventType).add(handler);
+      return () => {
+        const handlers = typeHandlers.get(eventType);
+        if (handlers) {
+          handlers.delete(handler);
+          if (handlers.size === 0) {
+            typeHandlers.delete(eventType);
+          }
+        }
+      };
+    },
+    getState() {
+      return state;
+    },
+    getMetrics() {
+      return { ...metrics };
+    },
+    getError() {
+      return error;
+    },
+    clearError() {
+      error = void 0;
+    }
+  };
+  return transport;
+}
+
+// transport/sse-fetch.ts
+function createFetchSSETransport(options = {}) {
+  const {
+    retryConfig = DEFAULT_RETRY_CONFIG,
+    debug = false,
+    logger = createLogger(debug),
+    customFetch = fetch
+  } = options;
+  let abortController;
+  let config;
+  let state = "disconnected";
+  let error;
+  let retryCount = 0;
+  let reconnectTimeout;
+  let intentionalDisconnect = false;
+  const metrics = {
+    latency: 0,
+    messagesSent: 0,
+    messagesReceived: 0,
+    messagesQueued: 0,
+    reconnectCount: 0,
+    transportType: "sse-fetch"
+  };
+  const globalHandlers = /* @__PURE__ */ new Set();
+  const typeHandlers = /* @__PURE__ */ new Map();
+  function emit(event) {
+    metrics.messagesReceived++;
+    metrics.lastMessageAt = Date.now();
+    globalHandlers.forEach((handler) => {
+      try {
+        handler(event);
+      } catch (err) {
+        logger.error("Error in message handler:", err);
+      }
+    });
+    const handlers = typeHandlers.get(event.type);
+    if (handlers) {
+      handlers.forEach((handler) => {
+        try {
+          handler(event);
+        } catch (err) {
+          logger.error(`Error in ${event.type} handler:`, err);
+        }
+      });
+    }
+  }
+  async function sendRest(endpoint, body) {
+    if (!config) {
+      throw new Error("Transport not connected");
+    }
+    const url = `${config.baseUrl}/${endpoint}`;
+    logger.debug(`POST ${endpoint}`, body);
+    const response = await customFetch(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body)
+    });
+    if (!response.ok) {
+      const errorText = await response.text();
+      throw new Error(`API error: ${response.status} - ${errorText}`);
+    }
+    return response.json();
+  }
+  function parseSSEChunk(chunk) {
+    const events = [];
+    const lines = chunk.split("\n");
+    let eventType = "message";
+    let data = "";
+    for (const line of lines) {
+      if (line.startsWith("event:")) {
+        eventType = line.slice(6).trim();
+      } else if (line.startsWith("data:")) {
+        data = line.slice(5).trim();
+      } else if (line === "" && data) {
+        try {
+          const parsed = JSON.parse(data);
+          events.push(parsed);
+        } catch {
+          logger.warn("Failed to parse SSE data:", data);
+        }
+        eventType = "message";
+        data = "";
+      }
+    }
+    return events;
+  }
+  async function startStream(cfg) {
+    const url = `${cfg.baseUrl}/stream?orgId=${cfg.orgId}&userId=${cfg.userId}&clientType=${cfg.clientType}${cfg.chatKey ? `&chatId=${cfg.chatKey}` : ""}`;
+    logger.debug("Connecting to:", url);
+    abortController = new AbortController();
+    const response = await customFetch(url, {
+      method: "GET",
+      headers: {
+        Accept: "text/event-stream",
+        "Cache-Control": "no-cache"
+      },
+      signal: abortController.signal
+    });
+    if (!response.ok) {
+      throw new Error(`Stream connection failed: ${response.status}`);
+    }
+    if (!response.body) {
+      throw new Error("Response body is null - ReadableStream not supported");
+    }
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    const readStream = async () => {
+      try {
+        while (true) {
+          const { done, value } = await reader.read();
+          if (done) {
+            logger.info("Stream ended");
+            break;
+          }
+          buffer += decoder.decode(value, { stream: true });
+          const lastNewline = buffer.lastIndexOf("\n\n");
+          if (lastNewline !== -1) {
+            const complete = buffer.slice(0, lastNewline + 2);
+            buffer = buffer.slice(lastNewline + 2);
+            const events = parseSSEChunk(complete);
+            events.forEach(emit);
+          }
+        }
+      } catch (err) {
+        if (err.name === "AbortError") {
+          logger.debug("Stream aborted");
+          return;
+        }
+        logger.error("Stream error:", err);
+        throw err;
+      }
+      if (!intentionalDisconnect) {
+        state = "disconnected";
+        scheduleReconnect();
+      }
+    };
+    readStream().catch((err) => {
+      if (!intentionalDisconnect) {
+        error = {
+          code: "CONNECTION_FAILED",
+          message: err.message,
+          retryable: true,
+          timestamp: Date.now(),
+          originalError: err
+        };
+        metrics.lastError = error;
+        state = "disconnected";
+        scheduleReconnect();
+      }
+    });
+  }
+  function scheduleReconnect() {
+    if (intentionalDisconnect || !config) return;
+    const maxRetries = retryConfig.maxRetries ?? DEFAULT_RETRY_CONFIG.maxRetries;
+    if (retryCount >= maxRetries) {
+      logger.error(`Max retries (${maxRetries}) exceeded`);
+      error = {
+        code: "CONNECTION_FAILED",
+        message: `Max retries (${maxRetries}) exceeded`,
+        retryable: false,
+        timestamp: Date.now()
+      };
+      return;
+    }
+    const interval = calculateRetryInterval(retryCount, retryConfig);
+    retryCount++;
+    metrics.reconnectCount++;
+    logger.info(`Reconnecting in ${interval}ms (attempt ${retryCount})`);
+    state = "reconnecting";
+    reconnectTimeout = setTimeout(() => {
+      if (config) {
+        transport.connect(config).catch((err) => {
+          logger.error("Reconnect failed:", err);
+        });
+      }
+    }, interval);
+  }
+  const transport = {
+    async connect(cfg) {
+      config = cfg;
+      intentionalDisconnect = false;
+      if (abortController) {
+        abortController.abort();
+        abortController = void 0;
+      }
+      if (reconnectTimeout) {
+        clearTimeout(reconnectTimeout);
+        reconnectTimeout = void 0;
+      }
+      state = retryCount > 0 ? "reconnecting" : "connecting";
+      const connectionStart = Date.now();
+      try {
+        await startStream(cfg);
+        const connectionTime = Date.now() - connectionStart;
+        logger.info(`Connected in ${connectionTime}ms`);
+        state = "connected";
+        error = void 0;
+        retryCount = 0;
+        metrics.connectedAt = Date.now();
+        metrics.latency = connectionTime;
+      } catch (err) {
+        const connectError = {
+          code: "CONNECTION_FAILED",
+          message: err.message,
+          retryable: true,
+          timestamp: Date.now(),
+          originalError: err
+        };
+        error = connectError;
+        metrics.lastError = connectError;
+        state = "disconnected";
+        if (!intentionalDisconnect) {
+          scheduleReconnect();
+        }
+        throw connectError;
+      }
+    },
+    disconnect(intentional = true) {
+      logger.info("Disconnecting", { intentional });
+      intentionalDisconnect = intentional;
+      if (reconnectTimeout) {
+        clearTimeout(reconnectTimeout);
+        reconnectTimeout = void 0;
+      }
+      if (abortController) {
+        abortController.abort();
+        abortController = void 0;
+      }
+      state = "disconnected";
+      retryCount = 0;
+    },
+    async send(event) {
+      if (!config) {
+        throw new Error("Transport not connected");
+      }
+      switch (event.type) {
+        case "message":
+          await sendRest("send", {
+            orgId: event.orgId,
+            chatKey: event.chatKey,
+            userId: event.userId,
+            message: event.message
+          });
+          break;
+        case "typing":
+          await sendRest("typing", {
+            orgId: event.orgId,
+            chatKey: event.chatKey,
+            userId: event.userId,
+            typing: true
+          });
+          break;
+        case "stopped_typing":
+          await sendRest("typing", {
+            orgId: event.orgId,
+            chatKey: event.chatKey,
+            userId: event.userId,
+            typing: false
+          });
+          break;
+        case "load_chat":
+          await sendRest("load", {
+            orgId: event.orgId,
+            chatKey: event.chatKey,
+            userId: event.userId
+          });
+          break;
+        case "new_chat":
+          await sendRest("create", {
+            orgId: event.orgId,
+            userId: event.userId,
+            metadata: event.data
+          });
+          break;
+        case "end_chat":
+          await sendRest("end", {
+            orgId: event.orgId,
+            chatKey: event.chatKey,
+            userId: event.userId,
+            data: event.data
+          });
+          break;
+        default:
+          await sendRest("event", {
+            type: event.type,
+            orgId: event.orgId,
+            chatKey: event.chatKey,
+            userId: event.userId,
+            data: event.data
+          });
+      }
+      metrics.messagesSent++;
+    },
+    async sendMessage(message) {
+      if (!config) {
+        throw new Error("Transport not connected");
+      }
+      await sendRest("send", {
+        orgId: config.orgId,
+        chatKey: config.chatKey,
+        userId: config.userId,
+        message
+      });
+      metrics.messagesSent++;
+    },
+    onMessage(handler) {
+      globalHandlers.add(handler);
+      return () => globalHandlers.delete(handler);
+    },
+    on(eventType, handler) {
+      if (!typeHandlers.has(eventType)) {
+        typeHandlers.set(eventType, /* @__PURE__ */ new Set());
+      }
+      typeHandlers.get(eventType).add(handler);
+      return () => {
+        const handlers = typeHandlers.get(eventType);
+        if (handlers) {
+          handlers.delete(handler);
+          if (handlers.size === 0) {
+            typeHandlers.delete(eventType);
+          }
+        }
+      };
+    },
+    getState() {
+      return state;
+    },
+    getMetrics() {
+      return { ...metrics };
+    },
+    getError() {
+      return error;
+    },
+    clearError() {
+      error = void 0;
+    }
+  };
+  return transport;
+}
+
+// transport/whatsapp.ts
+function createWhatsAppTransport(options = {}) {
+  const { debug = false, logger = createLogger(debug) } = options;
+  let state = "disconnected";
+  let error;
+  let config;
+  const metrics = {
+    latency: 0,
+    messagesSent: 0,
+    messagesReceived: 0,
+    messagesQueued: 0,
+    reconnectCount: 0,
+    transportType: "whatsapp"
+  };
+  const globalHandlers = /* @__PURE__ */ new Set();
+  const typeHandlers = /* @__PURE__ */ new Map();
+  const transport = {
+    async connect(cfg) {
+      logger.warn(
+        "WhatsApp transport is a stub. WhatsApp integration happens via backend webhooks."
+      );
+      logger.info(
+        "See transport/whatsapp.ts for integration documentation."
+      );
+      config = cfg;
+      state = "connected";
+      metrics.connectedAt = Date.now();
+    },
+    disconnect() {
+      state = "disconnected";
+    },
+    async send(event) {
+      if (!config) {
+        throw new Error("Transport not connected");
+      }
+      logger.warn("WhatsApp send is a stub. Implement backend webhook relay.");
+      metrics.messagesSent++;
+    },
+    async sendMessage(message) {
+      if (!config) {
+        throw new Error("Transport not connected");
+      }
+      logger.warn(
+        "WhatsApp sendMessage is a stub. Implement backend webhook relay."
+      );
+      metrics.messagesSent++;
+    },
+    onMessage(handler) {
+      globalHandlers.add(handler);
+      return () => globalHandlers.delete(handler);
+    },
+    on(eventType, handler) {
+      if (!typeHandlers.has(eventType)) {
+        typeHandlers.set(eventType, /* @__PURE__ */ new Set());
+      }
+      typeHandlers.get(eventType).add(handler);
+      return () => {
+        const handlers = typeHandlers.get(eventType);
+        if (handlers) {
+          handlers.delete(handler);
+          if (handlers.size === 0) {
+            typeHandlers.delete(eventType);
+          }
+        }
+      };
+    },
+    getState() {
+      return state;
+    },
+    getMetrics() {
+      return { ...metrics };
+    },
+    getError() {
+      return error;
+    },
+    clearError() {
+      error = void 0;
+    }
+  };
+  return transport;
+}
+function mapWhatsAppToChatEvent(payload, orgId) {
+  const events = [];
+  for (const entry of payload.entry) {
+    for (const change of entry.changes) {
+      const value = change.value;
+      if (value.messages) {
+        for (const msg of value.messages) {
+          const contact = value.contacts?.find((c) => c.wa_id === msg.from);
+          events.push({
+            type: "message",
+            orgId,
+            chatKey: `wa_${msg.from}`,
+            // Use phone number as chat key
+            userId: msg.from,
+            timestamp: parseInt(msg.timestamp) * 1e3,
+            message: {
+              id: msg.id,
+              role: "user",
+              content: msg.text?.body || "",
+              time: parseInt(msg.timestamp) * 1e3,
+              status: "delivered",
+              senderId: msg.from,
+              senderName: contact?.profile.name,
+              createdAt: parseInt(msg.timestamp) * 1e3,
+              // Map attachments if present
+              attachments: mapWhatsAppAttachments(msg)
+            }
+          });
+        }
+      }
+      if (value.statuses) {
+        for (const status of value.statuses) {
+          events.push({
+            type: "message_status_update",
+            orgId,
+            chatKey: `wa_${status.recipient_id}`,
+            userId: status.recipient_id,
+            timestamp: parseInt(status.timestamp) * 1e3,
+            data: {
+              messageId: status.id,
+              status: status.status
+            }
+          });
+        }
+      }
+    }
+  }
+  return events;
+}
+function mapWhatsAppAttachments(msg) {
+  switch (msg.type) {
+    case "image":
+      return msg.image ? [{ type: "image", url: `whatsapp://media/${msg.image.id}` }] : void 0;
+    case "document":
+      return msg.document ? [
+        {
+          type: "document",
+          url: `whatsapp://media/${msg.document.id}`
+        }
+      ] : void 0;
+    case "audio":
+      return msg.audio ? [{ type: "audio", url: `whatsapp://media/${msg.audio.id}` }] : void 0;
+    case "video":
+      return msg.video ? [{ type: "video", url: `whatsapp://media/${msg.video.id}` }] : void 0;
+    case "location":
+      return msg.location ? [
+        {
+          type: "location",
+          url: `geo:${msg.location.latitude},${msg.location.longitude}`
+        }
+      ] : void 0;
+    default:
+      return void 0;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DEFAULT_RETRY_CONFIG,
+  calculateRetryInterval,
+  createFetchSSETransport,
+  createLogger,
+  createSSETransport,
+  createWhatsAppTransport,
+  mapWhatsAppToChatEvent
+});
+//# sourceMappingURL=index.js.map