@butlerbot/sdk 0.0.18-alpha.3 → 0.0.18

package/dist/modules/conversation.js

@@ -1,23 +1,15 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Conversation = void 0;
-const eventsource_1 = require("eventsource");
 const config_1 = require("../config");
+const emitter_1 = require("../util/emitter");
+const transport_link_1 = require("./transport_link");
+const transport_sse_1 = require("./transport_sse");
 const url_formatter_1 = require("../util/url_formatter");
 const DEFAULT_CONVO_API_V = "v4";
 class Conversation {
     constructor(config) {
-        var _a, _b;
-        this.events = new Map();
+        this.events = new emitter_1.Emitter();
         this.convoId = config.convoId;
         this.chatApiV = (config.chatApiV || DEFAULT_CONVO_API_V);
         const serverUrl = config.serverUrl || config_1.CONFIG.server;
@@ -25,11 +17,27 @@ class Conversation {
         this.endpoints = {
             conversation: serverUrl + (config.convoPath || config.path || config_1.CONFIG.paths.conversation[this.chatApiV].base),
             history: serverUrl + (config.historyPath || config_1.CONFIG.paths.history.chat.v1.base),
-            progressStream: serverUrl + (config.progressStreamPath || ((_a = progressConfig === null || progressConfig === void 0 ? void 0 : progressConfig.stream) !== null && _a !== void 0 ? _a : config_1.CONFIG.paths.progress.v4.stream)),
-            progress: serverUrl + (config.progressPath || ((_b = progressConfig === null || progressConfig === void 0 ? void 0 : progressConfig.base) !== null && _b !== void 0 ? _b : config_1.CONFIG.paths.progress.v4.base)),
+            progressStream: serverUrl + (config.progressStreamPath || (progressConfig?.stream ?? config_1.CONFIG.paths.progress.v4.stream)),
+            progress: serverUrl + (config.progressPath || (progressConfig?.base ?? config_1.CONFIG.paths.progress.v4.base)),
         };
         this.apiKey = config.apiKey;
         this.debug = config.debug || false;
+        if (config.transport && config.transport !== "sse") {
+            this.link = config.transport;
+            this.transport = new transport_link_1.LinkConversationTransport(config.transport, () => ({
+                model: this.options?.model,
+                personality: this.options?.personality,
+                instructions: this.options?.instructions,
+                platform: this.options?.platform,
+            }));
+        }
+        else {
+            this.transport = new transport_sse_1.SSEConversationTransport({
+                endpoint: () => this.endpoints.conversation,
+                apiKey: this.apiKey,
+                debug: this.debug,
+            });
+        }
     }
     // SETTERS
     /**
@@ -67,22 +75,22 @@ class Conversation {
     }
     /** Sets the AI model used for the next interaction, e.g Claude-Sonnet, GPT-4 */
     setModel(model) {
-        this.options = Object.assign(Object.assign({}, this.options), { model });
+        this.options = { ...this.options, model };
         return this;
     }
     /** Sets additional instructions for location-specific context */
     setInstructions(instructions) {
-        this.options = Object.assign(Object.assign({}, this.options), { instructions });
+        this.options = { ...this.options, instructions };
         return this;
     }
     /** Sets the platform where the chat is occurring, used internally for logging - ignore in most contexts */
     setPlatform(platform) {
-        this.options = Object.assign(Object.assign({}, this.options), { platform });
+        this.options = { ...this.options, platform };
         return this;
     }
     /** Sets a custom personality configuration for the AI */
     setPersonality(personality) {
-        this.options = Object.assign(Object.assign({}, this.options), { personality });
+        this.options = { ...this.options, personality };
         return this;
     }
     // GETTERS
@@ -115,53 +123,21 @@ class Conversation {
     }
     /** Gets the current options object */
     getModel() {
-        var _a;
-        return (_a = this.options) === null || _a === void 0 ? void 0 : _a.model;
+        return this.options?.model;
     }
     /** Gets the current location-specific instructions */
     getInstructions() {
-        var _a;
-        return (_a = this.options) === null || _a === void 0 ? void 0 : _a.instructions;
+        return this.options?.instructions;
     }
     /** Gets the current platform */
     getPlatform() {
-        var _a;
-        return (_a = this.options) === null || _a === void 0 ? void 0 : _a.platform;
+        return this.options?.platform;
     }
     /** Gets the current personality configuration */
     getPersonality() {
-        var _a;
-        return (_a = this.options) === null || _a === void 0 ? void 0 : _a.personality;
+        return this.options?.personality;
     }
     // EVENT EMITTER
-    hasEmitter(event) {
-        return this.events.has(event);
-    }
-    addEmitter(event) {
-        if (!this.hasEmitter(event))
-            this.events.set(event, new Map());
-    }
-    removeEmitter(event) {
-        this.events.delete(event);
-    }
-    addListener(event, cb) {
-        if (!this.hasEmitter(event))
-            this.addEmitter(event);
-        const listeners = this.events.get(event);
-        const id = crypto.randomUUID();
-        listeners.set(id, cb);
-        return id;
-    }
-    removeListener(event, id) {
-        const listeners = this.events.get(event);
-        if (listeners)
-            listeners.delete(id);
-    }
-    emit(event, ...args) {
-        const listeners = this.events.get(event);
-        if (listeners)
-            listeners.forEach(listener => listener(...args));
-    }
     /**
      * Fires when the conversation ID is set
      * if convoId is already set when this is called, fires immediately
@@ -169,11 +145,11 @@ class Conversation {
     onConvoId(cb) {
         if (this.convoId)
             cb(this.convoId);
-        return this.addListener("convoId", cb);
+        return this.events.on("convoId", cb);
     }
     /** Removes a convoId listener */
     offConvoId(listenerId) {
-        this.removeListener("convoId", listenerId);
+        this.events.off("convoId", listenerId);
     }
     /**
      * Fires once when the conversation ID is set, then removes the listener.
@@ -184,91 +160,97 @@ class Conversation {
             cb(this.convoId);
             return;
         }
-        const id = this.addListener("convoId", (convoId) => {
-            cb(convoId);
-            this.offConvoId(id);
-        });
-        return id;
-    }
-    // SSE HANDLER
-    handleSSE(url, cb, options = {}) {
-        const sse = new eventsource_1.EventSource(url);
-        sse.addEventListener("message", (event) => {
-            const data = JSON.parse(event.data);
-            const convoId = data.success ? data.data.convoId : undefined;
-            if (convoId && options.onConvoId)
-                options.onConvoId(convoId);
-            cb(data);
-            if (data.data.quitStream)
-                sse.close();
-        });
-        sse.addEventListener("error", (event) => {
-            if (this.debug)
-                console.warn(`[Stream Error: ${url}]`, event);
-        });
-        return sse;
+        return this.events.once("convoId", cb);
     }
     // GETTERS
     /** Fetches the conversation state from the server, including message history and metadata */
-    fetchState() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.convoId)
-                throw new Error("Conversation ID is not set");
-            const url = (0, url_formatter_1.formatURL)(`${this.endpoints.history}/${this.convoId}`, undefined, { apiKey: this.apiKey, debug: this.debug });
-            const response = yield fetch(url);
-            if (!response.ok) {
-                const errorText = yield response.text();
-                throw new Error(`Failed to fetch conversation state: ${response.status} ${response.statusText} - ${errorText}`);
-            }
-            const data = yield response.json();
-            return data;
-        });
+    async fetchState() {
+        if (!this.convoId)
+            throw new Error("Conversation ID is not set");
+        const url = (0, url_formatter_1.formatURL)(`${this.endpoints.history}/${this.convoId}`, undefined, { apiKey: this.apiKey, debug: this.debug });
+        const response = await fetch(url);
+        if (!response.ok) {
+            const errorText = await response.text();
+            throw new Error(`Failed to fetch conversation state: ${response.status} ${response.statusText} - ${errorText}`);
+        }
+        const data = await response.json();
+        return data;
     }
     /** Fetches the conversation progress stream from the server */
     fetchProgressStream(cb) {
         if (!this.convoId)
             throw new Error("Conversation ID is not set");
         const url = (0, url_formatter_1.formatURL)(this.endpoints.progressStream, { chatId: this.convoId }, { apiKey: this.apiKey, debug: this.debug });
-        return this.handleSSE(url, cb);
+        return (0, transport_sse_1.streamSSE)(url, { debug: this.debug, onPayload: (payload) => cb(payload) });
     }
     /**
      * Fetches the conversation progress from the server
      * Returns undefined if no active turn progress
     */
-    fetchProgress(options) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.convoId)
-                throw new Error("Conversation ID is not set");
-            const payload = {
-                chatId: this.convoId,
-            };
-            if ((options === null || options === void 0 ? void 0 : options.includeCompleted) !== undefined)
-                payload["includeCompleted"] = options.includeCompleted;
-            const url = (0, url_formatter_1.formatURL)(this.endpoints.progress, payload, { apiKey: this.apiKey, debug: this.debug });
-            const response = yield fetch(url, { headers: (options === null || options === void 0 ? void 0 : options.lastEventId) ? { "last-event-id": options.lastEventId } : undefined });
-            if (!response.ok) {
-                const errorText = yield response.text();
-                throw new Error(`Failed to fetch conversation progress: ${response.status} ${response.statusText} - ${errorText}`);
-            }
-            if (response.status === 204)
-                return undefined; // No content
-            const data = yield response.json();
-            return data.events;
-        });
+    async fetchProgress(options) {
+        if (!this.convoId)
+            throw new Error("Conversation ID is not set");
+        const payload = {
+            chatId: this.convoId,
+        };
+        if (options?.includeCompleted !== undefined)
+            payload["includeCompleted"] = options.includeCompleted;
+        const url = (0, url_formatter_1.formatURL)(this.endpoints.progress, payload, { apiKey: this.apiKey, debug: this.debug });
+        const response = await fetch(url, { headers: options?.lastEventId ? { "last-event-id": options.lastEventId } : undefined });
+        if (!response.ok) {
+            const errorText = await response.text();
+            throw new Error(`Failed to fetch conversation progress: ${response.status} ${response.statusText} - ${errorText}`);
+        }
+        if (response.status === 204)
+            return undefined; // No content
+        const data = await response.json();
+        return data.events;
     }
     // LIFE CYCLE
     /** Sends a message into the conversation */
     send(message, cb, options) {
-        const payload = Object.assign(Object.assign({ message }, this.options), options // overwrite convos for this call
-        );
-        if (this.convoId)
-            payload.chatId = this.convoId;
-        const url = (0, url_formatter_1.formatURL)(this.endpoints.conversation, payload, { apiKey: this.apiKey, debug: this.debug });
-        return this.handleSSE(url, cb, {
-            onConvoId: (convoId) => {
+        return this.transport.send({
+            message,
+            ...this.options, // options set for convo
+            ...options, // overwrite convo's for this call
+            ...(this.convoId ? { chatId: this.convoId } : {}),
+        }, {
+            payload: (payload) => cb(payload),
+            convoId: (convoId) => {
+                if (this.convoId === convoId)
+                    return;
                 this.convoId = convoId;
-                this.emit("convoId", convoId);
-            }
+                this.events.emit("convoId", convoId);
+            },
+        });
+    }
+    /**
+     * Sends a message and resolves with the finished reply.
+     *
+     * For when you want the answer rather than the stream. Every event still arrives
+     * through `onEvent` if you pass one.
+     */
+    ask(message, options) {
+        return new Promise((resolve, reject) => {
+            const events = [];
+            let text = "";
+            this.send(message, (chunk) => {
+                events.push(chunk);
+                options?.onEvent?.(chunk);
+                if (!chunk.success) {
+                    reject(new Error(chunk.data.message || chunk.data.error || chunk.data.code));
+                    return;
+                }
+                const response = chunk.data.response;
+                const metadata = chunk.data.response.metadata;
+                // Message chunks arrive cumulative, and Alfred's own notices are not part
+                // of the reply, so they are collected but not concatenated into it.
+                if (response.type === "message" && metadata?.participantId !== "system" && response.payload?.message) {
+                    text = response.payload.message;
+                }
+                if (chunk.data.quitStream)
+                    resolve({ text, convoId: this.convoId, events });
+            }, options);
         });
     }
 }

package/dist/modules/transport.d.ts

@@ -0,0 +1,101 @@
+/**
+ * CONVERSATION TRANSPORTS
+ * =======================
+ *
+ * A conversation is the same conversation however it is carried. The transport
+ * only decides how a turn is sent and how its stream comes back — everything a
+ * caller sees, including the payload shape, is identical either way.
+ */
+/** A turn in progress. `close()` stops delivery locally. */
+export type ConversationStream = {
+    /**
+     * Stops listening. The turn itself continues server-side and its reply is still
+     * persisted, on both transports — there is no cancel.
+     */
+    close(): void;
+    /** The underlying EventSource, when the turn is being carried over SSE. */
+    readonly source?: unknown;
+};
+export type TransportTurnRequest = {
+    chatId?: string;
+    message: string;
+    model?: string;
+    instructions?: string;
+    platform?: string;
+    personality?: string;
+};
+export type TransportHandlers = {
+    /** One payload of the stream, already in the shape callers expect. */
+    payload(payload: unknown): void;
+    /** The conversation this turn belongs to, as soon as it is known. */
+    convoId(convoId: string): void;
+};
+export interface ConversationTransport {
+    send(request: TransportTurnRequest, handlers: TransportHandlers): ConversationStream;
+}
+/**
+ * The system message form the HTTP transport uses for a notice.
+ *
+ * Alfred's own remarks — a forced model switch, a tier limit — are not part of
+ * conversation state and won't be in history. Both transports present them the same
+ * way so a consumer needs no special case.
+ */
+export declare function noticePayload(message: string, convoId?: string): {
+    success: true;
+    data: {
+        convoId?: string | undefined;
+        response: {
+            type: string;
+            payload: {
+                message: string;
+                messageId: string;
+                completed: boolean;
+            };
+            metadata: {
+                responseId: string;
+                model: string;
+                modelId: string;
+                timestamp: number;
+                firstTimestamp: number;
+                participantId: string;
+            };
+        };
+    };
+};
+/** The first payload of a turn: which conversation it landed in. */
+export declare function convoStartedPayload(convoId: string): {
+    success: true;
+    data: {
+        response: {
+            type: string;
+            payload: {
+                state: string;
+            };
+        };
+        convoId: string;
+    };
+};
+/** The terminal payload of a turn that produced no completion event of its own. */
+export declare function completedPayload(convoId?: string): {
+    success: true;
+    data: {
+        quitStream: boolean;
+        convoId?: string | undefined;
+        response: {
+            type: string;
+            payload: {
+                completed: boolean;
+            };
+        };
+    };
+};
+export declare function failurePayload(code: string, error: string, message: string, convoId?: string): {
+    success: false;
+    data: {
+        quitStream: boolean;
+        convoId?: string | undefined;
+        code: string;
+        error: string;
+        message: string;
+    };
+};

package/dist/modules/transport.js

@@ -0,0 +1,78 @@
+"use strict";
+/**
+ * CONVERSATION TRANSPORTS
+ * =======================
+ *
+ * A conversation is the same conversation however it is carried. The transport
+ * only decides how a turn is sent and how its stream comes back — everything a
+ * caller sees, including the payload shape, is identical either way.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.noticePayload = noticePayload;
+exports.convoStartedPayload = convoStartedPayload;
+exports.completedPayload = completedPayload;
+exports.failurePayload = failurePayload;
+// =============================================
+// PAYLOAD SHAPES
+// =============================================
+/**
+ * The system message form the HTTP transport uses for a notice.
+ *
+ * Alfred's own remarks — a forced model switch, a tier limit — are not part of
+ * conversation state and won't be in history. Both transports present them the same
+ * way so a consumer needs no special case.
+ */
+function noticePayload(message, convoId) {
+    const messageId = `${Date.now().toString(36)}-${Math.random().toString(36).slice(2)}`;
+    return {
+        success: true,
+        data: {
+            response: {
+                type: "message",
+                payload: { message, messageId, completed: true },
+                metadata: {
+                    responseId: messageId,
+                    model: "System",
+                    modelId: "system",
+                    timestamp: Date.now(),
+                    firstTimestamp: Date.now(),
+                    participantId: "system",
+                },
+            },
+            ...(convoId ? { convoId } : {}),
+        },
+    };
+}
+/** The first payload of a turn: which conversation it landed in. */
+function convoStartedPayload(convoId) {
+    return {
+        success: true,
+        data: {
+            response: { type: "convo_status", payload: { state: "started" } },
+            convoId,
+        },
+    };
+}
+/** The terminal payload of a turn that produced no completion event of its own. */
+function completedPayload(convoId) {
+    return {
+        success: true,
+        data: {
+            response: { type: "response_status", payload: { completed: true } },
+            ...(convoId ? { convoId } : {}),
+            quitStream: true,
+        },
+    };
+}
+function failurePayload(code, error, message, convoId) {
+    return {
+        success: false,
+        data: {
+            code,
+            error,
+            message,
+            ...(convoId ? { convoId } : {}),
+            quitStream: true,
+        },
+    };
+}

package/dist/modules/transport_link.d.ts

@@ -0,0 +1,28 @@
+import type { Link } from "../link/link";
+import { ConversationStream, ConversationTransport, TransportHandlers, TransportTurnRequest } from "./transport";
+export type LinkSessionConfig = {
+    model?: string;
+    personality?: string;
+    instructions?: string;
+    platform?: string;
+};
+/**
+ * Carries a turn over an existing Link connection.
+ *
+ * Sessions are ephemeral: the server drops them when the socket goes, so one is
+ * opened on demand and reopened transparently after a reconnect. The conversation
+ * itself is persisted server-side, so nothing is lost when that happens.
+ */
+export declare class LinkConversationTransport implements ConversationTransport {
+    private readonly link;
+    private readonly config;
+    private sessionId?;
+    private sessionChatId?;
+    constructor(link: Link, config: () => LinkSessionConfig);
+    send(request: TransportTurnRequest, handlers: TransportHandlers): ConversationStream;
+    /** Ends the session, if one is open. The conversation can still be resumed later. */
+    end(): Promise<void>;
+    private runTurn;
+    /** Opens a session, or reuses the open one when it is for the same conversation. */
+    private session;
+}

package/dist/modules/transport_link.js

@@ -0,0 +1,143 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LinkConversationTransport = void 0;
+const protocol_1 = require("../link/protocol");
+const transport_1 = require("./transport");
+/**
+ * Carries a turn over an existing Link connection.
+ *
+ * Sessions are ephemeral: the server drops them when the socket goes, so one is
+ * opened on demand and reopened transparently after a reconnect. The conversation
+ * itself is persisted server-side, so nothing is lost when that happens.
+ */
+class LinkConversationTransport {
+    constructor(link, config) {
+        this.link = link;
+        this.config = config;
+        // A session cannot outlive the connection it was opened on.
+        link.on("disconnect", () => { this.sessionId = undefined; });
+    }
+    send(request, handlers) {
+        let closed = false;
+        const deliver = {
+            payload: (payload) => { if (!closed)
+                handlers.payload(payload); },
+            convoId: (convoId) => { if (!closed)
+                handlers.convoId(convoId); },
+        };
+        void this.runTurn(request, deliver, true).catch((error) => {
+            const failure = error instanceof protocol_1.LinkError
+                ? (0, transport_1.failurePayload)(error.code, error.message, error.message, request.chatId)
+                : (0, transport_1.failurePayload)("link_error", String(error), "I'm afraid the connection to Alfred failed.", request.chatId);
+            deliver.payload(failure);
+        });
+        return { close: () => { closed = true; } };
+    }
+    /** Ends the session, if one is open. The conversation can still be resumed later. */
+    async end() {
+        const sessionId = this.sessionId;
+        if (!sessionId)
+            return;
+        this.sessionId = undefined;
+        await this.link.exchange("conversation.end", { sessionId });
+    }
+    async runTurn(request, handlers, mayRetry) {
+        const sessionId = await this.session(request);
+        let chatId = request.chatId ?? this.sessionChatId;
+        let announcedChatId = false;
+        let sawCompletion = false;
+        const learnChatId = (candidate) => {
+            if (!candidate)
+                return;
+            chatId = candidate;
+            this.sessionChatId = candidate;
+            handlers.convoId(candidate);
+            // Mirrors the HTTP transport's first byte, which tells a client which
+            // conversation it is now in. A brand new conversation only has an id once
+            // its first turn has begun.
+            if (!announcedChatId) {
+                announcedChatId = true;
+                handlers.payload((0, transport_1.convoStartedPayload)(candidate));
+            }
+        };
+        learnChatId(chatId);
+        const done = await this.link.exchange("conversation.chat", {
+            sessionId,
+            message: request.message,
+            ...(request.model ? { model: request.model } : {}),
+            ...(request.instructions ? { instructions: request.instructions } : {}),
+            ...(request.personality ? { personality: request.personality } : {}),
+        }, {
+            // A turn takes as long as it takes; only the transport dying ends it early.
+            timeoutMs: 0,
+            isDone: (frame) => frame.type === "conversation.done",
+            onFrame: (frame) => {
+                if (frame.type === "conversation.event") {
+                    const payload = frame.payload;
+                    learnChatId(payload.chatId);
+                    const event = payload.event;
+                    const final = event.type === "response_status" && Boolean(event.payload?.completed);
+                    if (final)
+                        sawCompletion = true;
+                    handlers.payload({
+                        success: true,
+                        data: {
+                            response: event,
+                            ...(payload.chatId ?? chatId ? { convoId: payload.chatId ?? chatId } : {}),
+                            ...(final ? { quitStream: true } : {}),
+                        },
+                    });
+                    return;
+                }
+                if (frame.type === "conversation.notice") {
+                    const payload = frame.payload;
+                    learnChatId(payload.chatId);
+                    handlers.payload((0, transport_1.noticePayload)(payload.message, payload.chatId ?? chatId));
+                }
+            },
+        });
+        const payload = done.payload;
+        learnChatId(payload.chatId);
+        if (payload.ok) {
+            // Nearly always the pipeline's own completion event has already closed the
+            // stream; this is for the turn that ended without one.
+            if (!sawCompletion)
+                handlers.payload((0, transport_1.completedPayload)(payload.chatId ?? chatId));
+            return;
+        }
+        // The session died with a connection we have since replaced. Reopening it is
+        // invisible to the caller, and the message has not been delivered yet.
+        if (payload.code === "unknown_session" && mayRetry) {
+            this.sessionId = undefined;
+            await this.runTurn(request, handlers, false);
+            return;
+        }
+        handlers.payload((0, transport_1.failurePayload)(
+        // `turn_failed` means the dialogue itself failed, and then `error` holds the
+        // code the HTTP transport would have reported.
+        payload.code === "turn_failed" ? payload.error ?? payload.code : payload.code ?? "link_error", payload.error ?? "The turn failed.", payload.message ?? payload.error ?? "I'm afraid that turn could not be completed.", payload.chatId ?? chatId));
+    }
+    /** Opens a session, or reuses the open one when it is for the same conversation. */
+    async session(request) {
+        const chatId = request.chatId ?? this.sessionChatId;
+        if (this.sessionId && this.sessionChatId === chatId)
+            return this.sessionId;
+        if (this.sessionId)
+            await this.end();
+        const config = this.config();
+        const opened = await this.link.exchange("conversation.start", {
+            ...(chatId ? { chatId } : {}),
+            ...(request.model ?? config.model ? { model: request.model ?? config.model } : {}),
+            ...(request.personality ?? config.personality ? { personality: request.personality ?? config.personality } : {}),
+            ...(request.instructions ?? config.instructions ? { instructions: request.instructions ?? config.instructions } : {}),
+            ...(request.platform ?? config.platform ? { platform: request.platform ?? config.platform } : {}),
+        }, {
+            isDone: (frame) => frame.type === "conversation.open",
+        });
+        const payload = opened.payload;
+        this.sessionId = payload.sessionId;
+        this.sessionChatId = payload.chatId ?? chatId;
+        return payload.sessionId;
+    }
+}
+exports.LinkConversationTransport = LinkConversationTransport;