openclaw-extension-typex 1.0.16 → 1.0.18

package/dist/client/client.d.ts

@@ -1,14 +1,52 @@
-import { TypeXMessageEnum, type TypeXClientOptions } from "./types.js";
+import { TypeXMessageEnum, type TypeXClientOptions, type TypeXMessageEntry } from "./types.js";
 export declare class TypeXClient {
     private options;
     private accessToken?;
     private userId?;
     constructor(options: TypeXClientOptions);
+    get mode(): "user" | "bot";
     getAccessToken(): Promise<string>;
     getCurUserId(): Promise<string>;
     fetchQrcodeUrl(): Promise<any>;
     checkLoginStatus(qrcodeId: string): Promise<boolean>;
-    sendMessage(content: string | object, msgType?: TypeXMessageEnum): Promise<any>;
-    fetchMessages(pos: number): Promise<any>;
+    /**
+     * Send a message to a specific chat (group or DM).
+     * @param to  chat_id to send to
+     * @param content  message text or object
+     */
+    sendMessage(to: string, content: string | object, msgType?: TypeXMessageEnum, options?: {
+        replyMsgId?: string;
+    }): Promise<any>;
+    /**
+     * Upload resource for the robot to send.
+     * @param fileName Name of the file
+     * @param fileType "image" | "audio" | "video" | "application"
+     * @param fileContent Buffer or Blob containing the file data
+     * @param chatId Optional chat_id
+     */
+    uploadResource(fileName: string, fileType: "image" | "audio" | "video" | "application", fileContent: Buffer | Blob, chatId?: string): Promise<any>;
+    /**
+     * Fetch messages. Dispatches to user or bot endpoint based on mode.
+     */
+    fetchMessages(pos: number): Promise<TypeXMessageEntry[]>;
+    /** Pull messages for a regular user account (sessionid cookie auth). */
+    private fetchUserMessages;
+    /**
+     * Pull messages for a bot account (Bearer token auth).
+     * TODO: replace /open/bot/message with the actual endpoint path once confirmed.
+     */
+    private fetchBotMessages;
+    /**
+     * Fetch a single message by ID (used to resolve quoted/parent messages).
+     */
+    getMessage(messageId: string): Promise<TypeXMessageEntry | null>;
+    /**
+     * Fetch file binary stream from TypeX using object_key.
+     * Requires Bot Token authentication.
+     */
+    fetchFileBuffer(objectKey: string, size?: string): Promise<{
+        buffer: Buffer;
+        mimeType: string;
+    } | null>;
 }
 export declare function getTypeXClient(accountId?: string, manualOptions?: TypeXClientOptions): TypeXClient;

package/dist/client/client.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TypeXClient = void 0;
 exports.getTypeXClient = getTypeXClient;
+const types_js_1 = require("./types.js");
 const TYPEX_DOMAIN = "https://api-coco.typex.im";
 // const TYPEX_DOMAIN = "https://api-tx.bossjob.net.cn";
 let prompter;
@@ -15,191 +16,300 @@ class TypeXClient {
             this.accessToken = options.token;
         }
     }
+    get mode() {
+        return this.options.mode ?? "user";
+    }
     async getAccessToken() {
-        if (this.accessToken) {
-            return this.accessToken;
-        }
-        return "";
+        return this.accessToken ?? "";
     }
     async getCurUserId() {
-        if (this.userId) {
-            return this.userId;
-        }
-        return "";
+        return this.userId ?? "";
     }
     async fetchQrcodeUrl() {
-        try {
-            const qrResponse = await fetch(`${TYPEX_DOMAIN}/user/qrcode?login_type=open`, {
-                method: "POST",
-                headers: { "Content-Type": "application/json" },
-                body: JSON.stringify({}),
-            });
-            if (!qrResponse.ok) {
-                throw new Error(`Failed to get QR code: ${qrResponse.statusText}`);
-            }
-            const qrResult = await qrResponse.json();
-            if (qrResult.code !== 0 || !qrResult.data) {
-                throw new Error(`Failed to get QR code: ${qrResult.msg}`);
-            }
-            return qrResult.data;
+        const qrResponse = await fetch(`${TYPEX_DOMAIN}/user/qrcode?login_type=open`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({}),
+        });
+        if (!qrResponse.ok) {
+            throw new Error(`Failed to get QR code: ${qrResponse.statusText}`);
         }
-        catch (error) {
-            throw error;
+        const qrResult = await qrResponse.json();
+        if (qrResult.code !== 0 || !qrResult.data) {
+            throw new Error(`Failed to get QR code: ${qrResult.msg}`);
         }
+        return qrResult.data;
     }
     async checkLoginStatus(qrcodeId) {
-        try {
-            const checkRes = await fetch(`${TYPEX_DOMAIN}/open/qrcode/check_auth`, {
-                method: "POST",
-                headers: {
-                    "Content-Type": "application/json",
-                },
-                body: JSON.stringify({
-                    qr_code_id: qrcodeId,
-                }),
-            });
-            const setCookieHeader = checkRes.headers.get("set-cookie");
-            if (setCookieHeader) {
-                const match = setCookieHeader.match(/(sessionid=[^;]+)/);
-                if (match && match[1]) {
-                    this.accessToken = match[1];
-                }
-            }
-            const checkData = await checkRes.json();
-            if (checkData.code === 0) {
-                const { user_id } = checkData.data;
-                this.userId = user_id;
-                return true;
-            }
-            else if (checkData.code === 10001) {
-                return false;
-            }
-            else {
-                return false;
-            }
+        const checkRes = await fetch(`${TYPEX_DOMAIN}/open/qrcode/check_auth`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ qr_code_id: qrcodeId }),
+        });
+        const setCookieHeader = checkRes.headers.get("set-cookie");
+        if (setCookieHeader) {
+            const match = setCookieHeader.match(/(sessionid=[^;]+)/);
+            if (match?.[1])
+                this.accessToken = match[1];
         }
-        catch (error) {
-            throw error;
+        const checkData = await checkRes.json();
+        if (checkData.code === 0) {
+            this.userId = checkData.data.user_id;
+            return true;
         }
+        return false;
     }
-    async sendMessage(content, msgType = 0) {
-        console.info("msgType: ", msgType);
+    /**
+     * Send a message to a specific chat (group or DM).
+     * @param to  chat_id to send to
+     * @param content  message text or object
+     */
+    async sendMessage(to, content, msgType = 0, options = {}) {
         const token = this.accessToken;
-        if (!token) {
+        if (!token)
             throw new Error("TypeXClient: Not authenticated.");
-        }
         let finalContent = content;
         if (typeof content === "object") {
             try {
                 finalContent = JSON.stringify(content);
             }
-            catch (e) {
-                if (e instanceof Error) {
-                    if (prompter)
-                        prompter.note("Failed to stringify message content");
-                    else
-                        console.log("Failed to stringify message content");
-                }
+            catch {
                 finalContent = String(content);
             }
         }
         if (prompter)
-            prompter.note(`TypeXClient sending message: content=${typeof finalContent === "string" ? finalContent : JSON.stringify(finalContent)}`);
+            prompter.note(`TypeXClient sending to ${to}: ${String(finalContent).slice(0, 80)}`);
         else
-            console.log(`TypeXClient sending message: content=${typeof finalContent === "string" ? finalContent : JSON.stringify(finalContent)}`);
+            console.log(`TypeXClient sending to ${to}: ${String(finalContent).slice(0, 80)}`);
+        const isBot = this.mode === "bot";
+        const endpoint = isBot ? "/open/robot/send_message" : "/open/claw/send_message";
+        let payloadStr;
+        if (isBot) {
+            let botContentObj;
+            if (msgType === types_js_1.TypeXMessageEnum.text || msgType === types_js_1.TypeXMessageEnum.richText) {
+                // According to docs, text type content format: {"text":"test"}
+                // Assuming content or finalContent holds the actual string text.
+                botContentObj = {
+                    text: typeof content === "string" ? content : (typeof finalContent === "string" ? finalContent : JSON.stringify(content))
+                };
+                // Ensure msgType is 0 when sending to `/open/robot/send_message` since 8 might not be supported natively by robot API
+                msgType = types_js_1.TypeXMessageEnum.text;
+            }
+            else {
+                // Image or File object payload for bot
+                botContentObj = typeof finalContent === "string" ? { text: finalContent } : content;
+            }
+            payloadStr = JSON.stringify({
+                chat_id: to,
+                content: botContentObj,
+                msg_type: msgType,
+                reply_msg_id: options.replyMsgId || "0",
+            });
+        }
+        else {
+            payloadStr = JSON.stringify({
+                chat_id: to,
+                content: { text: finalContent },
+                msg_type: msgType,
+            });
+        }
+        const response = await fetch(`${TYPEX_DOMAIN}${endpoint}`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                ...(isBot ? { Authorization: `Bearer ${token}` } : { Cookie: token }),
+            },
+            body: payloadStr,
+        });
+        const bodyText = await response.text();
+        let resJson;
         try {
-            const url = `${TYPEX_DOMAIN}/open/claw/send_message`;
-            const response = await fetch(url, {
+            resJson = JSON.parse(bodyText);
+        }
+        catch (e) {
+            throw new Error(`Send message failed (invalid JSON): HTTP ${response.status} - ${bodyText}`);
+        }
+        if (resJson.code !== 0) {
+            throw new Error(`Send message failed: [${resJson.code}] ${resJson.msg || resJson.message}`);
+        }
+        return resJson.data || { message_id: `msg_${Date.now()}` };
+    }
+    /**
+     * Upload resource for the robot to send.
+     * @param fileName Name of the file
+     * @param fileType "image" | "audio" | "video" | "application"
+     * @param fileContent Buffer or Blob containing the file data
+     * @param chatId Optional chat_id
+     */
+    async uploadResource(fileName, fileType, fileContent, chatId) {
+        if (this.mode !== "bot" || !this.accessToken) {
+            throw new Error("TypeXClient: uploadResource requires bot mode and an access token.");
+        }
+        const formData = new FormData();
+        if (chatId)
+            formData.append("chat_id", chatId);
+        formData.append("file_name", fileName);
+        formData.append("file_type", fileType);
+        // Node.js fetch implementation of FormData requires a Blob-like object for files.
+        // By providing a Blob we ensure it correctly adds boundaries and content types per form part.
+        const blob = fileContent instanceof Buffer ? new Blob([fileContent]) : fileContent;
+        formData.append("file_content", blob, fileName);
+        const response = await fetch(`${TYPEX_DOMAIN}/open/robot/upload`, {
+            method: "POST",
+            headers: {
+                Authorization: `Bearer ${this.accessToken}`
+                // Note: fetch will automatically set the Content-Type boundary
+            },
+            body: formData,
+        });
+        const resJson = await response.json();
+        if (resJson.code !== 0) {
+            throw new Error(`Upload resource failed: [${resJson.code}] ${resJson.msg || resJson.message}`);
+        }
+        return resJson.data;
+    }
+    /**
+     * Fetch messages. Dispatches to user or bot endpoint based on mode.
+     */
+    async fetchMessages(pos) {
+        return this.mode === "bot"
+            ? this.fetchBotMessages()
+            : this.fetchUserMessages(pos);
+    }
+    /** Pull messages for a regular user account (sessionid cookie auth). */
+    async fetchUserMessages(pos) {
+        if (!this.accessToken)
+            return [];
+        try {
+            const response = await fetch(`${TYPEX_DOMAIN}/open/claw/message`, {
                 method: "POST",
-                headers: {
-                    "Content-Type": "application/json",
-                    Cookie: token,
-                },
-                body: JSON.stringify({
-                    content: {
-                        text: finalContent,
-                    },
-                    msg_type: msgType,
-                }),
+                headers: { Cookie: this.accessToken, "Content-Type": "application/json" },
+                body: JSON.stringify({ pos }),
             });
+            if (response.status === 401) {
+                throw new Error("Unauthorized: 401 Token is invalid or expired.");
+            }
+            if (!response.ok) {
+                throw new Error(`HTTP Error: ${response.status}`);
+            }
             const resJson = await response.json();
             if (resJson.code !== 0) {
-                throw new Error(`Send message failed: [${resJson.code}] ${resJson.message}`);
+                throw new Error(`API Error: code ${resJson.code}, message: ${resJson.msg}`);
             }
-            if (prompter)
-                prompter.note("Message sent successfully", resJson.data);
-            else
-                console.log("Message sent successfully", JSON.stringify(resJson.data));
-            return (resJson.data || {
-                message_id: `msg_${Date.now()}`,
-            });
+            return Array.isArray(resJson.data) ? resJson.data : [];
         }
-        catch (error) {
-            if (prompter)
-                prompter.note(`Error sending message to TypeX API: ${error}`);
-            else
-                console.log(`Error sending message to TypeX API: ${error}`);
-            throw error;
+        catch (e) {
+            if (e instanceof Error && e.message.includes("Unauthorized")) {
+                throw e;
+            }
+            console.log(`Fetch messages error: ${e}`);
+            return [];
         }
     }
-    async fetchMessages(pos) {
-        if (!this.accessToken) {
-            if (prompter)
-                prompter.note("TypeXClient: No token, skipping fetch.");
-            else
-                console.log("TypeXClient: No token, skipping fetch.");
+    /**
+     * Pull messages for a bot account (Bearer token auth).
+     * TODO: replace /open/bot/message with the actual endpoint path once confirmed.
+     */
+    async fetchBotMessages() {
+        if (!this.accessToken)
             return [];
-        }
         try {
-            const url = `${TYPEX_DOMAIN}/open/claw/message`;
-            if (prompter)
-                prompter.note(`Fetching messages from pos: ${pos}`);
-            // else console.log(`Fetching messages from pos: ${pos}`);
-            const response = await fetch(url, {
+            const response = await fetch(`${TYPEX_DOMAIN}/open/robot/message/pull`, {
                 method: "POST",
-                headers: {
-                    Cookie: this.accessToken,
-                    "Content-Type": "application/json",
-                },
-                body: JSON.stringify({ pos: pos }),
+                headers: { Authorization: `Bearer ${this.accessToken}`, "Content-Type": "application/json" },
+                body: JSON.stringify({ limit: 5 }),
             });
+            if (response.status === 401) {
+                throw new Error("Unauthorized: 401 Bot Token is invalid or expired.");
+            }
+            if (!response.ok) {
+                throw new Error(`HTTP Error: ${response.status}`);
+            }
             const resJson = await response.json();
             if (resJson.code !== 0) {
-                if (prompter)
-                    prompter.note(`Fetch failed with code ${resJson.code}: ${resJson.message}`);
-                else
-                    console.log(`Fetch failed with code ${resJson.code}: ${resJson.message}`);
                 return [];
             }
-            if (Array.isArray(resJson.data)) {
-                return resJson.data;
+            return Array.isArray(resJson.data?.messages) ? resJson.data.messages : [];
+        }
+        catch (e) {
+            if (e instanceof Error && e.message.includes("Unauthorized")) {
+                throw e;
             }
+            console.log(`Bot fetch messages error: ${e}`);
             return [];
         }
+    }
+    /**
+     * Fetch a single message by ID (used to resolve quoted/parent messages).
+     */
+    async getMessage(messageId) {
+        if (!this.accessToken)
+            return null;
+        try {
+            const isBot = this.mode === "bot";
+            const response = await fetch(`${TYPEX_DOMAIN}/open/claw/message/${messageId}`, {
+                method: "GET",
+                headers: isBot
+                    ? { Authorization: `Bearer ${this.accessToken}`, "Content-Type": "application/json" }
+                    : { Cookie: this.accessToken, "Content-Type": "application/json" },
+            });
+            const resJson = await response.json();
+            return resJson.code === 0 && resJson.data ? resJson.data : null;
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * Fetch file binary stream from TypeX using object_key.
+     * Requires Bot Token authentication.
+     */
+    async fetchFileBuffer(objectKey, size) {
+        if (!this.accessToken || this.mode !== "bot")
+            return null;
+        try {
+            const query = new URLSearchParams({ object_key: objectKey });
+            if (size)
+                query.append("size", size);
+            const url = `${TYPEX_DOMAIN}/open/robot/chat/file?${query.toString()}`;
+            const response = await fetch(url, {
+                method: "GET",
+                headers: { Authorization: `Bearer ${this.accessToken}` },
+            });
+            if (!response.ok) {
+                console.log(`fetchFileBuffer failed with status: ${response.status} ${response.statusText} for url: ${url}`);
+                return null;
+            }
+            const arrayBuffer = await response.arrayBuffer();
+            const buffer = Buffer.from(arrayBuffer);
+            const mimeType = response.headers.get("content-type") ?? "application/octet-stream";
+            return { buffer, mimeType };
+        }
         catch (e) {
-            if (prompter)
-                prompter.note(`Fetch messages network error: ${e}`);
-            else
-                console.log(`Fetch messages network error: ${e}`);
-            return [];
+            console.log(`fetchFileBuffer error: ${e}`);
+            return null;
         }
     }
 }
 exports.TypeXClient = TypeXClient;
 function getTypeXClient(accountId, manualOptions) {
     const typexCfg = (manualOptions?.typexCfg ?? {});
-    const clawPrompter = manualOptions?.prompter;
-    if (clawPrompter) {
-        prompter = clawPrompter;
-    }
+    if (manualOptions?.prompter)
+        prompter = manualOptions.prompter;
     let token = manualOptions?.token;
+    let mode = manualOptions?.mode ?? "user";
     if (accountId && typexCfg.accounts?.[accountId]) {
-        token = typexCfg.accounts[accountId].token;
+        const acctCfg = typexCfg.accounts[accountId];
+        token = token ?? acctCfg.token;
+        if (acctCfg.mode === "bot" || acctCfg.mode === "user")
+            mode = acctCfg.mode;
     }
+    // Config check: outbound sends should fail only when we truly lack credentials.
+    // Historically this was a stub that always threw, which broke outbound delivery.
     if (!manualOptions?.skipConfigCheck) {
-        throw new Error("TypeX not configured yet.");
+        if (!token?.trim()) {
+            throw new Error("TypeX not configured: missing token. Run the TypeX onboarding (QR login / bot token) or set channels.openclaw-extension-typex.accounts.<accountId>.token");
+        }
     }
-    return new TypeXClient({
-        token: token,
-    });
+    return new TypeXClient({ token, mode });
 }

package/dist/client/message-helpers.d.ts

@@ -0,0 +1,24 @@
+/**
+ * message-helpers.ts
+ *
+ * Pure, stateless helper functions for TypeX message processing.
+ * All functions are free of side-effects and easy to unit-test.
+ */
+import { type TypeXMessageEntry, type TypeXMention } from "./types.js";
+export declare function normalizeMessageToText(msg: TypeXMessageEntry): string;
+export declare function checkBotMentioned(msg: TypeXMessageEntry, botId?: string): boolean;
+export declare function stripBotMention(text: string, mentions?: TypeXMention[]): string;
+export type TypeXGroupConfig = {
+    enabled?: boolean;
+    requireMention?: boolean;
+    allowFrom?: Array<string | number>;
+};
+export declare function resolveGroupConfig(typexCfg: Record<string, any>, groupId: string): TypeXGroupConfig | undefined;
+export declare function normalizeAllowEntry(raw: string): string;
+export declare function isAllowedBySenderId(allowFrom: Array<string | number>, senderId: string): boolean;
+export declare function buildAgentBody(params: {
+    messageId: string;
+    senderLabel: string;
+    content: string;
+    quotedContent?: string;
+}): string;

package/dist/client/message-helpers.js

@@ -0,0 +1,125 @@
+"use strict";
+/**
+ * message-helpers.ts
+ *
+ * Pure, stateless helper functions for TypeX message processing.
+ * All functions are free of side-effects and easy to unit-test.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeMessageToText = normalizeMessageToText;
+exports.checkBotMentioned = checkBotMentioned;
+exports.stripBotMention = stripBotMention;
+exports.resolveGroupConfig = resolveGroupConfig;
+exports.normalizeAllowEntry = normalizeAllowEntry;
+exports.isAllowedBySenderId = isAllowedBySenderId;
+exports.buildAgentBody = buildAgentBody;
+const types_js_1 = require("./types.js");
+// ---------------------------------------------------------------------------
+// Message content normalisation
+// ---------------------------------------------------------------------------
+function normalizeMessageToText(msg) {
+    const typeNum = Number(msg.msg_type);
+    switch (typeNum) {
+        case types_js_1.TypeXMessageEnum.text:
+        case types_js_1.TypeXMessageEnum.richText: {
+            const parsedContent = typeof msg.content === "string" ? JSON.parse(msg.content) : msg.content;
+            return parsedContent.text ?? parsedContent.preview_text ?? "";
+        }
+        case types_js_1.TypeXMessageEnum.image:
+        case types_js_1.TypeXMessageEnum.photoCollageMsg: {
+            const parsedContent = typeof msg.content === "string" ? JSON.parse(msg.content) : msg.content;
+            const text = (parsedContent.text ?? parsedContent.preview_text ?? "").trim();
+            return text ? `${text} <media:image>` : "<media:image>";
+        }
+        case types_js_1.TypeXMessageEnum.file:
+        case types_js_1.TypeXMessageEnum.fileGroup:
+            return msg.content.file_name ? `<media:file:${msg.content.file_name}>` : "<media:file>";
+        case types_js_1.TypeXMessageEnum.video:
+            return "<media:video>";
+        case types_js_1.TypeXMessageEnum.emoji:
+            return "<media:sticker>";
+        case types_js_1.TypeXMessageEnum.newCard: {
+            const card = msg.content.card;
+            if (!card)
+                return "[Card message]";
+            try {
+                const raw = typeof card === "string" ? card : JSON.stringify(card);
+                const parsed = JSON.parse(raw);
+                const title = parsed.header?.title ?? parsed.title ?? "";
+                const body = parsed.body ?? parsed.content ?? parsed.text ?? "";
+                const parts = [title, body].map((p) => String(p ?? "").trim()).filter(Boolean);
+                return parts.length > 0 ? parts.join("\n") : "[Card message]";
+            }
+            catch {
+                return "[Card message]";
+            }
+        }
+        case types_js_1.TypeXMessageEnum.forward: {
+            const items = msg.content.items ?? [];
+            if (items.length === 0)
+                return "[Merged and Forwarded Messages]";
+            const lines = ["[Merged and Forwarded Messages]"];
+            const limit = Math.min(items.length, 50);
+            for (let i = 0; i < limit; i++) {
+                const item = items[i];
+                const itemText = item.content?.text?.trim() ?? `[type: ${item.msg_type ?? "unknown"}]`;
+                const sender = item.sender?.name ?? item.sender?.id ?? "unknown";
+                lines.push(`- ${sender}: ${itemText}`);
+            }
+            if (items.length > 50)
+                lines.push(`... and ${items.length - 50} more messages`);
+            return lines.join("\n");
+        }
+        case types_js_1.TypeXMessageEnum.mentioned:
+        case types_js_1.TypeXMessageEnum.custom:
+        case types_js_1.TypeXMessageEnum.via:
+            return msg.content.text ?? `[Message type: ${typeNum}]`;
+        default:
+            return `[Unsupported message type: ${msg.msg_type}]`;
+    }
+}
+// ---------------------------------------------------------------------------
+// @mention helpers
+// ---------------------------------------------------------------------------
+function checkBotMentioned(msg, botId) {
+    if (!botId)
+        return false;
+    return (msg.mentions ?? []).some((m) => m.id.open_id === botId || m.id.user_id === botId);
+}
+function stripBotMention(text, mentions) {
+    if (!mentions || mentions.length === 0)
+        return text;
+    let result = text;
+    for (const mention of mentions) {
+        result = result.replace(new RegExp(`@${escapeRegExp(mention.name)}\\s*`, "g"), "");
+        if (mention.key)
+            result = result.replace(new RegExp(escapeRegExp(mention.key), "g"), "");
+    }
+    return result.trim();
+}
+function escapeRegExp(s) {
+    return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function resolveGroupConfig(typexCfg, groupId) {
+    const groups = typexCfg?.groups ?? {};
+    return groups[groupId] ?? groups["*"];
+}
+function normalizeAllowEntry(raw) {
+    return raw.trim().toLowerCase().replace(/^typex:/i, "");
+}
+function isAllowedBySenderId(allowFrom, senderId) {
+    const norm = allowFrom.map((e) => normalizeAllowEntry(String(e))).filter(Boolean);
+    if (norm.includes("*"))
+        return true;
+    return norm.includes(normalizeAllowEntry(senderId));
+}
+// ---------------------------------------------------------------------------
+// Agent message body builder
+// ---------------------------------------------------------------------------
+function buildAgentBody(params) {
+    const { messageId, senderLabel, content, quotedContent } = params;
+    let body = content;
+    if (quotedContent)
+        body = `[Replying to: "${quotedContent}"]\n\n${body}`;
+    return `[message_id: ${messageId}]\n${senderLabel}: ${body}`;
+}

package/dist/client/message.d.ts

@@ -1,16 +1,23 @@
+/**
+ * message.ts
+ *
+ * Main message dispatch orchestrator for the TypeX standalone plugin.
+ * Pure helpers live in ./message-helpers.ts.
+ */
+import type { HistoryEntry, OpenClawConfig } from "openclaw/plugin-sdk";
 import type { TypeXClient } from "./client.js";
 import { type TypeXMessageEntry } from "./types.js";
-import type { OpenClawConfig } from "openclaw/plugin-sdk";
 export type ProcessTypeXMessageOptions = {
-    /** Full OpenClaw gateway config (needed for bindings/routing). */
     cfg?: OpenClawConfig;
     accountId?: string;
     botName?: string;
     typexCfg?: Record<string, any>;
+    chatHistories?: Map<string, HistoryEntry[]>;
     logger?: {
         warn: (msg: string) => void;
         info: (msg: string) => void;
         error: (msg: string) => void;
-    } | undefined;
+    };
 };
+export { buildAgentBody, checkBotMentioned, normalizeMessageToText, stripBotMention } from "./message-helpers.js";
 export declare function processTypeXMessage(client: TypeXClient, payload: TypeXMessageEntry, appId: string, options?: ProcessTypeXMessageOptions): Promise<void>;