openclaw-extension-typex 1.0.19 → 1.0.21

package/dist/client/message.js

@@ -11,13 +11,15 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.stripBotMention = exports.normalizeMessageToText = exports.checkBotMentioned = exports.buildAgentBody = void 0;
 exports.processTypeXMessage = processTypeXMessage;
-const plugin_sdk_1 = require("openclaw/plugin-sdk");
+const reply_history_1 = require("openclaw/plugin-sdk/reply-history");
 const message_helpers_js_1 = require("./message-helpers.js");
 const runtime_js_1 = require("./runtime.js");
 const send_js_1 = require("./send.js");
+const agent_tools_send_js_1 = require("../agent-tools-send.js");
 const types_js_1 = require("./types.js");
 const node_fs_1 = __importDefault(require("node:fs"));
 const node_path_1 = __importDefault(require("node:path"));
+const node_os_1 = __importDefault(require("node:os"));
 // Re-export for convenience
 var message_helpers_js_2 = require("./message-helpers.js");
 Object.defineProperty(exports, "buildAgentBody", { enumerable: true, get: function () { return message_helpers_js_2.buildAgentBody; } });
@@ -25,6 +27,102 @@ Object.defineProperty(exports, "checkBotMentioned", { enumerable: true, get: fun
 Object.defineProperty(exports, "normalizeMessageToText", { enumerable: true, get: function () { return message_helpers_js_2.normalizeMessageToText; } });
 Object.defineProperty(exports, "stripBotMention", { enumerable: true, get: function () { return message_helpers_js_2.stripBotMention; } });
 const CHANNEL_ID = "openclaw-extension-typex";
+function cleanupRecipient(value) {
+    return value
+        .replace(/<[^>]*>/g, " ")
+        .replace(/&nbsp;/gi, " ")
+        .replace(/\s+/g, " ")
+        .trim()
+        .replace(/[，。！？!?,；;:：]+$/g, "")
+        .replace(/<\/?[a-z][^>]*$/i, "")
+        .replace(/(?:<\/?(?:p|li|ul|ol|span|div|br)[^>]*)+$/gi, "")
+        .replace(/^(给|到)/, "")
+        .replace(/(吗|吧|呀|啊)$/g, "")
+        .trim();
+}
+function normalizeIntentSource(value) {
+    return value
+        .replace(/<[^>]*>/g, " ")
+        .replace(/&nbsp;/gi, " ")
+        .replace(/\s+/g, " ")
+        .trim();
+}
+function shouldIncludeGeneratedTextForExplicitSend(text) {
+    return /(生成|写|整理|总结|编|拟|回复|文案|消息|内容|代码|祝福|介绍|说明)/.test(text);
+}
+function shouldIncludeAttachmentsForExplicitSend(text, attachmentPaths) {
+    if (attachmentPaths.length === 0) {
+        return false;
+    }
+    return /(图|图片|照片|附件|文件|发这张|把这张|这个文件|这个附件)/.test(text);
+}
+function resolveMentionTargetName(mentions, appId, fallbackToken) {
+    const visibleMentions = (mentions ?? []).filter((mention) => {
+        const userId = mention.id?.user_id ?? mention.id?.open_id ?? "";
+        return userId && userId !== appId;
+    });
+    if (visibleMentions.length === 1) {
+        return visibleMentions[0].name?.trim() || fallbackToken;
+    }
+    return fallbackToken;
+}
+function detectExplicitSendIntent(params) {
+    const source = normalizeIntentSource(params.text);
+    if (!source) {
+        return null;
+    }
+    const includeGeneratedText = params.attachmentPaths.length === 0 ||
+        shouldIncludeGeneratedTextForExplicitSend(source);
+    const includeAttachments = shouldIncludeAttachmentsForExplicitSend(source, params.attachmentPaths);
+    const sendPatterns = [
+        /(?:帮我|麻烦你|请你|你帮我|你帮忙)?(?:把)?(?:.*?)(?:发给|发送给|转给|转发给|代发给)\s*([^\n，。！？!?,；;]+)/,
+        /(?:帮我|麻烦你|请你|你帮我|你帮忙)?发(?:一条消息|个消息|消息|一句话|一段话|一下)?给\s*([^\n，。！？!?,；;]+)/,
+        /(?:帮我|麻烦你|请你|你帮我|你帮忙)?发.+?给\s*([^\n，。！？!?,；;]+)/,
+        /(?:帮我|麻烦你|请你|你帮我|你帮忙)?把(?:.+?)(?:发|发送|转发)给\s*([^\n，。！？!?,；;]+)/,
+    ];
+    const sendMatch = sendPatterns
+        .map((pattern) => source.match(pattern))
+        .find((match) => Boolean(match?.[1]));
+    if (sendMatch?.[1]) {
+        const rawRecipient = cleanupRecipient(sendMatch[1]);
+        if (!rawRecipient) {
+            return null;
+        }
+        if (params.isGroup) {
+            const pronounTarget = /^(他|她|它|TA|ta|对方)$/.test(rawRecipient)
+                ? resolveMentionTargetName(params.mentions, params.appId, rawRecipient)
+                : rawRecipient;
+            return {
+                kind: "group-send-in-group",
+                memberName: pronounTarget,
+                includeGeneratedText,
+                includeAttachments,
+            };
+        }
+        return {
+            kind: "dm-send-by-name",
+            recipient: rawRecipient,
+            includeGeneratedText,
+            includeAttachments,
+        };
+    }
+    if (params.isGroup) {
+        const hasTellIntent = source.includes("告诉") ||
+            /跟.+?(?:说|讲)/.test(source) ||
+            /对.+?(?:说|讲)/.test(source) ||
+            /让.+?知道/.test(source);
+        if (!hasTellIntent) {
+            return null;
+        }
+        return {
+            kind: "group-send-in-group",
+            memberName: source,
+            includeGeneratedText: true,
+            includeAttachments,
+        };
+    }
+    return null;
+}
 async function processTypeXMessage(client, payload, appId, options = {}) {
     const cfg = options.cfg;
     const accountId = options.accountId ?? appId;
@@ -48,9 +146,9 @@ async function processTypeXMessage(client, payload, appId, options = {}) {
     const chatId = payload.chat_id;
     const senderId = payload.sender_id;
     const senderName = payload.sender_name ?? senderId;
-    const isGroup = payload.chat_type === "group";
+    const isGroup = payload.chat_type === "group" || client.mode === "bot";
     const rawText = (0, message_helpers_js_1.normalizeMessageToText)(payload);
-    logger?.info(`[typex:${accountId}] ${isGroup ? "group" : "DM"} message from ${senderId} in ${chatId}`);
+    logger?.info(`[typex:${accountId}] ${isGroup ? "group" : "DM"} message from ${senderId} in ${chatId} (chat_type=${payload.chat_type ?? "unknown"} mode=${client.mode})`);
     if (!rawText.trim()) {
         logger?.info(`[typex:${accountId}] skipping empty/system message`);
         return;
@@ -82,10 +180,10 @@ async function processTypeXMessage(client, payload, appId, options = {}) {
         if (requireMention && !mentionedBot) {
             logger?.info(`[typex:${accountId}] no @mention — buffering to history`);
             if (chatHistories) {
-                (0, plugin_sdk_1.recordPendingHistoryEntryIfEnabled)({
+                (0, reply_history_1.recordPendingHistoryEntryIfEnabled)({
                     historyMap: chatHistories,
                     historyKey: chatId,
-                    limit: typexCfg?.historyLimit ?? cfg.messages?.groupChat?.historyLimit ?? plugin_sdk_1.DEFAULT_GROUP_HISTORY_LIMIT,
+                    limit: typexCfg?.historyLimit ?? cfg.messages?.groupChat?.historyLimit ?? reply_history_1.DEFAULT_GROUP_HISTORY_LIMIT,
                     entry: {
                         sender: senderId,
                         body: `${senderName}: ${rawText}`,
@@ -183,55 +281,39 @@ async function processTypeXMessage(client, payload, appId, options = {}) {
             });
         }
         if (objectKeys.size > 0) {
-            if (client.mode === "bot") {
-                for (const objectKey of objectKeys) {
-                    logger?.info(`[typex:${accountId}] fetching attachment objectKey=${objectKey}`);
-                    const fileData = await client.fetchFileBuffer(objectKey);
-                    if (fileData) {
-                        const isImage = fileData.mimeType.startsWith("image/");
-                        // Persist to local disk so the agent can open the image via the read tool
-                        // even if this surface can't transport binary attachments to the model.
-                        try {
-                            const extRaw = String(fileData.mimeType ?? "application/octet-stream").split("/")[1] ?? "bin";
-                            const ext = extRaw === "jpeg" ? "jpg" : extRaw;
-                            const outDir = node_path_1.default.join(process.env.HOME ?? ".", ".openclaw", "typex-attachments", String(payload.message_id));
-                            node_fs_1.default.mkdirSync(outDir, { recursive: true });
-                            const baseName = String(objectKey).replace(/[^a-zA-Z0-9._-]+/g, "_");
-                            const outPath = node_path_1.default.join(outDir, `${baseName}.${ext}`);
-                            node_fs_1.default.writeFileSync(outPath, fileData.buffer);
-                            attachmentPaths.push(outPath);
-                            logger?.info?.(`[typex:${accountId}] saved attachment to ${outPath}`);
-                            console.log('saved attachment to', outPath);
-                        }
-                        catch (e) {
-                            const msg = e?.message ?? String(e);
-                            logger?.warn?.(`[typex:${accountId}] failed to persist attachment: ${msg}`);
-                            console.log('failed to persist attachment', msg);
-                            try {
-                                console.log('persist debug', {
-                                    home: process.env.HOME,
-                                    cwd: process.cwd(),
-                                    messageId: payload.message_id,
-                                    objectKey,
-                                    mimeType: fileData.mimeType,
-                                });
-                            }
-                            catch { }
-                        }
-                        attachments.push({
-                            contentType: fileData.mimeType,
-                            mimeType: fileData.mimeType, // Alias
-                            size: fileData.buffer.length,
-                            payload: fileData.buffer.toString("base64"),
-                            data: fileData.buffer.toString("base64"), // Alias
-                            type: isImage ? "image" : "file", // Alias
-                        });
+            for (const objectKey of objectKeys) {
+                logger?.info(`[typex:${accountId}] fetching attachment objectKey=${objectKey}`);
+                const fileData = await client.fetchFileBuffer(objectKey);
+                if (fileData) {
+                    const isImage = fileData.mimeType.startsWith("image/");
+                    // Persist to local disk so the agent can open the image via the read tool
+                    // even if this surface can't transport binary attachments to the model.
+                    try {
+                        const extRaw = String(fileData.mimeType ?? "application/octet-stream").split("/")[1] ?? "bin";
+                        const ext = extRaw === "jpeg" ? "jpg" : extRaw;
+                        const homeDir = node_os_1.default.homedir?.() ?? ".";
+                        // Store TypeX attachments under the OpenClaw workspace so newer
+                        // local-media allowlists can safely expose them to the model.
+                        const outDir = node_path_1.default.join(homeDir, ".openclaw", "workspace", "typex-attachments", String(payload.message_id));
+                        node_fs_1.default.mkdirSync(outDir, { recursive: true });
+                        const baseName = String(objectKey).replace(/[^a-zA-Z0-9._-]+/g, "_");
+                        const outPath = node_path_1.default.join(outDir, `${baseName}.${ext}`);
+                        node_fs_1.default.writeFileSync(outPath, fileData.buffer);
+                        attachmentPaths.push(outPath);
                     }
+                    catch (e) {
+                        const msg = e?.message ?? String(e);
+                        logger?.warn?.(`[typex:${accountId}] failed to persist attachment: ${msg}`);
+                    }
+                    attachments.push({
+                        contentType: fileData.mimeType,
+                        mimeType: fileData.mimeType, // Alias
+                        size: fileData.buffer.length,
+                        payload: fileData.buffer.toString("base64"),
+                        data: fileData.buffer.toString("base64"), // Alias
+                        type: isImage ? "image" : "file", // Alias
+                    });
                 }
-                console.log('processed attachments:', attachments.map(a => ({ type: a.contentType, size: a.size })));
-            }
-            else {
-                logger?.info(`[typex:${accountId}] skipping attachment fetch because mode is not bot`);
             }
         }
     }
@@ -242,6 +324,20 @@ async function processTypeXMessage(client, payload, appId, options = {}) {
     const cleanTextWithAttachments = attachmentPaths.length > 0
         ? `${cleanText}\n\n[TypeX attachments saved locally]\n${attachmentPaths.map(p => `- ${p}`).join("\n")}`
         : cleanText;
+    const contentForAgent = cleanTextWithAttachments;
+    const explicitSendIntent = detectExplicitSendIntent({
+        text: cleanText,
+        isGroup,
+        attachmentPaths,
+        mentions: payload.mentions,
+        appId,
+    });
+    if (explicitSendIntent) {
+        const targetLabel = explicitSendIntent.kind === "dm-send-by-name"
+            ? explicitSendIntent.recipient
+            : explicitSendIntent.memberName;
+        logger?.info(`[typex:${accountId}] detected explicit send intent kind=${explicitSendIntent.kind} target=${targetLabel}`);
+    }
     // ── Session routing ───────────────────────────────────────────────────────
     const peerId = isGroup ? chatId : senderId;
     let route = {};
@@ -257,12 +353,12 @@ async function processTypeXMessage(client, payload, appId, options = {}) {
         logger?.error(`[typex:${accountId}] resolveAgentRoute failed: ${e?.message ?? String(e)}`);
     }
     // ── Build message body ────────────────────────────────────────────────────
-    const historyLimit = typexCfg?.historyLimit ?? cfg?.messages?.groupChat?.historyLimit ?? plugin_sdk_1.DEFAULT_GROUP_HISTORY_LIMIT;
+    const historyLimit = typexCfg?.historyLimit ?? cfg?.messages?.groupChat?.historyLimit ?? reply_history_1.DEFAULT_GROUP_HISTORY_LIMIT;
     const envelopeOptions = channel.reply?.resolveEnvelopeFormatOptions?.(cfg) ?? {};
     const agentBody = (0, message_helpers_js_1.buildAgentBody)({
         messageId: payload.message_id,
         senderLabel: senderName,
-        content: cleanTextWithAttachments,
+        content: contentForAgent,
         quotedContent,
     });
     const envelopeFrom = isGroup ? `${chatId}:${senderId}` : senderId;
@@ -275,7 +371,7 @@ async function processTypeXMessage(client, payload, appId, options = {}) {
     }) ?? agentBody;
     let combinedBody = formattedBody;
     if (isGroup && chatHistories) {
-        combinedBody = (0, plugin_sdk_1.buildPendingHistoryContextFromMap)({
+        combinedBody = (0, reply_history_1.buildPendingHistoryContextFromMap)({
             historyMap: chatHistories,
             historyKey: chatId,
             limit: historyLimit,
@@ -311,6 +407,11 @@ async function processTypeXMessage(client, payload, appId, options = {}) {
         SenderId: senderId,
         Provider: CHANNEL_ID,
         Surface: CHANNEL_ID,
+        DeliveryContext: {
+            channel: CHANNEL_ID,
+            to: typexTo,
+            accountId: route.accountId ?? accountId,
+        },
         MessageSid: payload.message_id,
         ReplyToBody: quotedContent,
         Timestamp: typeof payload.create_time === "number" ? payload.create_time : Date.now(),
@@ -348,9 +449,52 @@ async function processTypeXMessage(client, payload, appId, options = {}) {
                             extractedFromText.push(v);
                         return "";
                     }).trim();
-                    if (extractedFromText.length > 0) {
-                        logger?.info?.(`[typex:${accountId}] extracted outbound media directives: ${extractedFromText.join(", ")}`);
-                        console.log('extracted outbound media directives', extractedFromText);
+                }
+                const generatedText = text?.trim() ?? "";
+                if (explicitSendIntent) {
+                    const targetLabel = explicitSendIntent.kind === "dm-send-by-name"
+                        ? explicitSendIntent.recipient
+                        : explicitSendIntent.memberName;
+                    logger?.info(`[typex:${accountId}] executing explicit send fallback kind=${explicitSendIntent.kind} target=${targetLabel}`);
+                    const hasSendableContent = (explicitSendIntent.includeGeneratedText && generatedText.length > 0) ||
+                        (explicitSendIntent.includeAttachments && attachmentPaths.length > 0);
+                    if (!hasSendableContent) {
+                        return;
+                    }
+                    try {
+                        if (explicitSendIntent.kind === "dm-send-by-name") {
+                            const messageToSend = explicitSendIntent.includeGeneratedText ? generatedText : "";
+                            const mediaPathsToSend = explicitSendIntent.includeAttachments ? attachmentPaths : [];
+                            await (0, agent_tools_send_js_1.executeTypeXSendByName)({
+                                cfg,
+                                accountId,
+                                recipient: explicitSendIntent.recipient,
+                                message: messageToSend,
+                                mediaPaths: mediaPathsToSend,
+                            });
+                            await (0, send_js_1.sendMessageTypeX)(client, chatId, `已代发给 ${explicitSendIntent.recipient}。`, { msgType: types_js_1.TypeXMessageEnum.richText, replyMsgId: payload.message_id });
+                            logger?.info(`[typex:${accountId}] explicit send completed kind=${explicitSendIntent.kind} target=${explicitSendIntent.recipient}`);
+                            return;
+                        }
+                        const messageToSend = explicitSendIntent.includeGeneratedText ? generatedText : "";
+                        const mediaPathsToSend = explicitSendIntent.includeAttachments ? attachmentPaths : [];
+                        await (0, agent_tools_send_js_1.executeTypeXSendInGroup)({
+                            cfg,
+                            accountId,
+                            chatId,
+                            memberName: explicitSendIntent.memberName,
+                            message: messageToSend,
+                            mediaPaths: mediaPathsToSend,
+                        });
+                        await (0, send_js_1.sendMessageTypeX)(client, chatId, `已在群里发送给 ${explicitSendIntent.memberName}。`, { msgType: types_js_1.TypeXMessageEnum.richText, replyMsgId: payload.message_id });
+                        logger?.info(`[typex:${accountId}] explicit send completed kind=${explicitSendIntent.kind} target=${explicitSendIntent.memberName}`);
+                        return;
+                    }
+                    catch (error) {
+                        const message = error?.message ?? String(error);
+                        logger?.warn?.(`[typex:${accountId}] explicit send fallback failed: ${message}`);
+                        await (0, send_js_1.sendMessageTypeX)(client, chatId, `发送失败：${message}`, { msgType: types_js_1.TypeXMessageEnum.richText, replyMsgId: payload.message_id });
+                        return;
                     }
                 }
                 if (text) {
@@ -362,8 +506,6 @@ async function processTypeXMessage(client, payload, appId, options = {}) {
                         ? [rp.mediaUrl]
                         : [];
                 for (const url of [...urls, ...extractedFromText]) {
-                    logger?.info?.(`[typex:${accountId}] sending outbound mediaUrl=${url}`);
-                    console.log('sending outbound mediaUrl', url);
                     await (0, send_js_1.sendMessageTypeX)(client, chatId, {}, { mediaUrl: url, msgType: types_js_1.TypeXMessageEnum.richText, replyMsgId: payload.message_id });
                 }
             },
@@ -375,6 +517,6 @@ async function processTypeXMessage(client, payload, appId, options = {}) {
     });
     // ── Clear group history after dispatch ────────────────────────────────────
     if (isGroup && chatHistories) {
-        (0, plugin_sdk_1.clearHistoryEntriesIfEnabled)({ historyMap: chatHistories, historyKey: chatId, limit: historyLimit });
+        (0, reply_history_1.clearHistoryEntriesIfEnabled)({ historyMap: chatHistories, historyKey: chatId, limit: historyLimit });
     }
 }

package/dist/client/monitor.d.ts

@@ -1,4 +1,5 @@
-import type { OpenClawConfig, RuntimeEnv } from "openclaw/plugin-sdk";
+import type { OpenClawConfig } from "openclaw/plugin-sdk/channel-core";
+import type { RuntimeEnv } from "openclaw/plugin-sdk/runtime-env";
 export type MonitorTypeXOpts = {
     account: unknown;
     runtime: RuntimeEnv;

package/dist/client/monitor.js

@@ -41,12 +41,13 @@ const client_js_1 = require("./client.js");
 const message_js_1 = require("./message.js");
 const runtime_js_1 = require("./runtime.js");
 const POS_STORE_VERSION = 1;
-const OPENCLAW_CONFIG_PATH = process.env.OPENCLAW_CONFIG_PATH || path.join(os.homedir(), ".openclaw", "openclaw.json");
+const OPENCLAW_HOME_DIR = path.join(os.homedir(), ".openclaw");
+const OPENCLAW_CONFIG_PATH = path.join(OPENCLAW_HOME_DIR, "openclaw.json");
 function normalizeAccountIdForFile(accountId) {
     return (accountId || "default").replace(/[^a-z0-9._-]+/gi, "_");
 }
 function resolveTypeXPosStatePath(accountId) {
-    const stateDir = (0, runtime_js_1.getTypeXRuntime)().state.resolveStateDir(process.env, os.homedir);
+    const stateDir = (0, runtime_js_1.getTypeXRuntime)().state.resolveStateDir({}, os.homedir);
     const normalized = normalizeAccountIdForFile(accountId);
     return path.join(stateDir, "typex", `update-pos-${normalized}.json`);
 }
@@ -206,18 +207,46 @@ async function monitorTypeXProvider(opts) {
     // Group history buffer: lives for the entire monitor lifetime.
     const chatHistories = new Map();
     let fatalError = null;
+    let consecutiveFetchFailures = 0;
+    const resolveBackoffMs = (failures) => {
+        if (failures <= 0)
+            return 3000;
+        if (failures === 1)
+            return 10000;
+        if (failures === 2)
+            return 30000;
+        if (failures === 3)
+            return 60000;
+        return 300000;
+    };
+    const isFatalFetchError = (err) => {
+        const message = err instanceof Error ? err.message : String(err);
+        const normalized = message.toLowerCase();
+        return (normalized.includes("non-json response") ||
+            normalized.includes("session auth error") ||
+            normalized.includes("http 401") ||
+            normalized.includes("http 403") ||
+            normalized.includes("http 404"));
+    };
     // --- Polling Loop ---
     while (!abortSignal.aborted) {
         let messages;
         try {
             messages = await client.fetchMessages(currentPos);
+            consecutiveFetchFailures = 0;
         }
         catch (err) {
-            // fetchMessages threw — this is treated as a fatal error (e.g. auth failure,
-            // bad token, server unreachable). Stop the monitor so we don't spam the API.
-            logger?.error(`[${accountObj.accountId}] Fatal error fetching TypeX messages; stopping monitor: ${err instanceof Error ? err.stack : String(err)}`);
-            fatalError = err instanceof Error ? err : new Error(String(err));
-            break;
+            consecutiveFetchFailures += 1;
+            const backoffMs = resolveBackoffMs(consecutiveFetchFailures);
+            const error = err instanceof Error ? err : new Error(String(err));
+            logger?.error(`[${accountObj.accountId}] Failed to fetch TypeX messages (attempt ${consecutiveFetchFailures}); next retry in ${Math.round(backoffMs / 1000)}s: ${error.message}`);
+            if (isFatalFetchError(error) || consecutiveFetchFailures >= 5) {
+                logger?.error(`[${accountObj.accountId}] Fatal error fetching TypeX messages; stopping monitor to avoid request spam.`);
+                fatalError = error;
+                break;
+            }
+            await new Promise((resolve) => setTimeout(resolve, backoffMs));
+            continue;
         }
         if (messages && messages.length > 0) {
             for (const msg of messages) {

package/dist/client/outbound.d.ts

@@ -1,2 +1,2 @@
-import type { ChannelOutboundAdapter } from "openclaw/plugin-sdk";
+import type { ChannelOutboundAdapter } from "openclaw/plugin-sdk/core";
 export declare const typexOutbound: ChannelOutboundAdapter;

package/dist/client/outbound.js

@@ -3,29 +3,74 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.typexOutbound = void 0;
 const client_js_1 = require("./client.js");
 const send_js_1 = require("./send.js");
+const types_js_1 = require("./types.js");
+function resolveTypeXTarget(rawTarget) {
+    const trimmed = (rawTarget ?? "").trim();
+    if (/^user:\d+$/i.test(trimmed)) {
+        return { chatId: trimmed.replace(/^user:/i, ""), receiverId: trimmed.replace(/^user:/i, "") };
+    }
+    if (/^(?:chat|group):\d+$/i.test(trimmed)) {
+        return { chatId: trimmed.replace(/^(?:chat|group):/i, "") };
+    }
+    return { chatId: trimmed };
+}
 exports.typexOutbound = {
     deliveryMode: "direct",
     // chunker: ... (optional, default might be used or I can skip for MVP)
     chunkerMode: "markdown",
     textChunkLimit: 2000,
+    resolveTarget: ({ to }) => {
+        const trimmed = (to ?? "").trim();
+        if (!trimmed) {
+            return { ok: false, error: new Error("TypeX target is required.") };
+        }
+        if (/^(?:user|chat|group):\d+$/i.test(trimmed) || /^\d+$/.test(trimmed)) {
+            return { ok: true, to: trimmed };
+        }
+        return {
+            ok: false,
+            error: new Error("TypeX target must be a numeric id or a user:/chat:/group: target."),
+        };
+    },
     sendText: async ({ to, text, accountId, cfg }) => {
         const typexCfg = (cfg?.channels?.["openclaw-extension-typex"] ?? {});
         const client = (0, client_js_1.getTypeXClient)(accountId ?? undefined, { typexCfg });
-        const result = await (0, send_js_1.sendMessageTypeX)(client, to, text);
+        const target = resolveTypeXTarget(to);
+        let hasMention = false;
+        const finalText = (text || "").replace(/<at\s+user_id="([^"]+)"(?:>([^<]*)<\/at>|\s*\/>)/g, (match, userId, name) => {
+            hasMention = true;
+            const label = name || userId;
+            return `@${label} `;
+        });
+        const result = await (0, send_js_1.sendMessageTypeX)(client, target.chatId, finalText, {
+            receiverId: target.receiverId,
+            msgType: hasMention ? types_js_1.TypeXMessageEnum.text : undefined,
+        });
         return {
             channel: "openclaw-extension-typex",
             messageId: result?.message_id || "unknown",
-            chatId: to,
+            chatId: target.chatId,
         };
     },
     sendMedia: async ({ to, text, mediaUrl, accountId, cfg }) => {
         const typexCfg = (cfg?.channels?.["openclaw-extension-typex"] ?? {});
         const client = (0, client_js_1.getTypeXClient)(accountId ?? undefined, { typexCfg });
-        const result = await (0, send_js_1.sendMessageTypeX)(client, to, text || "", { mediaUrl });
+        const target = resolveTypeXTarget(to);
+        let hasMention = false;
+        const finalText = (text || "").replace(/<at\s+user_id="([^"]+)"(?:>([^<]*)<\/at>|\s*\/>)/g, (match, userId, name) => {
+            hasMention = true;
+            const label = name || userId;
+            return `@${label} `;
+        });
+        const result = await (0, send_js_1.sendMessageTypeX)(client, target.chatId, finalText, {
+            mediaUrl,
+            receiverId: target.receiverId,
+            msgType: hasMention ? types_js_1.TypeXMessageEnum.text : undefined,
+        });
         return {
             channel: "openclaw-extension-typex",
             messageId: result?.message_id || "unknown",
-            chatId: to,
+            chatId: target.chatId,
         };
     },
 };

package/dist/client/runtime.d.ts

@@ -1,6 +1,6 @@
 /**
  * Global runtime reference for the TypeX plugin.
  */
-import type { PluginRuntime } from "openclaw/plugin-sdk";
+import type { PluginRuntime } from "openclaw/plugin-sdk/channel-core";
 export declare function setTypeXRuntime(next: PluginRuntime): void;
 export declare function getTypeXRuntime(): PluginRuntime;

package/dist/client/send.d.ts

@@ -5,6 +5,13 @@ export type TypeXSendOpts = {
     mediaUrl?: string;
     maxBytes?: number;
     replyMsgId?: string;
+    receiverId?: string;
+    isDelegate?: boolean;
+    atUserIds?: string[];
+    atMentions?: Array<{
+        id: string;
+        name: string;
+    }>;
 };
 /**
  * Send a message via the TypeX client to a specific chat.
@@ -16,6 +23,7 @@ export type TypeXSendOpts = {
 export declare function sendMessageTypeX(client: TypeXClient, chatId: string, content: string | {
     text?: string;
     object_url?: string;
+    thumb_url?: string;
     file_name?: string;
     file_size?: number;
     file_type?: string;

package/dist/client/send.js

@@ -77,6 +77,16 @@ async function sendMessageTypeX(client, chatId, content, opts = {}) {
             finalContent = opts.mediaUrl;
         }
     }
-    const res = await client.sendMessage(chatId, finalContent, msgType, { replyMsgId: opts.replyMsgId });
+    const res = client.mode === "bot"
+        ? await client.sendBotGroupMessage(chatId, finalContent, msgType, {
+            replyMsgId: opts.replyMsgId,
+            atUserIds: opts.atUserIds,
+            atMentions: opts.atMentions,
+        })
+        : opts.isDelegate && opts.receiverId
+            ? await client.sendDelegatedContactMessage(opts.receiverId, finalContent, msgType)
+            : opts.isDelegate
+                ? await client.sendDelegatedChatMessage(chatId, finalContent, msgType)
+                : await client.sendUserChatMessage(chatId, finalContent, msgType);
     return res;
 }

package/dist/client/types.d.ts

@@ -1,4 +1,4 @@
-import { WizardPrompter } from "openclaw/plugin-sdk";
+import type { WizardPrompter } from "openclaw/plugin-sdk/setup";
 export declare enum TypeXMessageEnum {
     text = 0,
     image = 1,
@@ -73,3 +73,19 @@ export interface TypeXMessageEntry {
     /** Monotonic position cursor used by the polling loop. */
     position: number;
 }
+export interface TypeXFeedSearchEntry {
+    id: string;
+    chat_id: string;
+    name?: string;
+}
+export interface TypeXContactSearchEntry {
+    friend_id: string;
+    name?: string;
+}
+export interface TypeXGroupMemberEntry {
+    user_id: string;
+    name?: string;
+    avatar?: string;
+    member_role?: number;
+    joined_at?: number;
+}

package/dist/config-schema.d.ts

@@ -7,9 +7,10 @@ export declare const TypeXConfigSchema: z.ZodObject<{
     botName: z.ZodOptional<z.ZodString>;
     markdown: z.ZodOptional<z.ZodObject<{
         tables: z.ZodOptional<z.ZodEnum<{
+            code: "code";
             off: "off";
             bullets: "bullets";
-            code: "code";
+            block: "block";
         }>>;
     }, z.core.$strict>>;
     allowFrom: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
@@ -36,9 +37,10 @@ export declare const TypeXConfigSchema: z.ZodObject<{
         botName: z.ZodOptional<z.ZodString>;
         markdown: z.ZodOptional<z.ZodObject<{
             tables: z.ZodOptional<z.ZodEnum<{
+                code: "code";
                 off: "off";
                 bullets: "bullets";
-                code: "code";
+                block: "block";
             }>>;
         }, z.core.$strict>>;
         allowFrom: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;

package/dist/config-schema.js

@@ -1,15 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TypeXConfigSchema = void 0;
-const plugin_sdk_1 = require("openclaw/plugin-sdk");
+const channel_config_schema_1 = require("openclaw/plugin-sdk/channel-config-schema");
 const zod_1 = require("zod");
 const allowFromEntry = zod_1.z.union([zod_1.z.string(), zod_1.z.number()]);
-const toolsBySenderSchema = zod_1.z.record(zod_1.z.string(), plugin_sdk_1.ToolPolicySchema).optional();
+const toolsBySenderSchema = zod_1.z.record(zod_1.z.string(), channel_config_schema_1.ToolPolicySchema).optional();
 // Simplify Group Schema for TypeX MVP
 const TypeXGroupSchema = zod_1.z
     .object({
     enabled: zod_1.z.boolean().optional(),
-    tools: plugin_sdk_1.ToolPolicySchema,
+    tools: channel_config_schema_1.ToolPolicySchema,
     toolsBySender: toolsBySenderSchema,
     systemPrompt: zod_1.z.string().optional(),
 })
@@ -21,7 +21,7 @@ const TypeXAccountSchema = zod_1.z
     appId: zod_1.z.string().optional(),
     appSecret: zod_1.z.string().optional(),
     botName: zod_1.z.string().optional(),
-    markdown: plugin_sdk_1.MarkdownConfigSchema,
+    markdown: channel_config_schema_1.MarkdownConfigSchema,
     // Policy settings
     allowFrom: zod_1.z.array(allowFromEntry).optional(),
     responsePrefix: zod_1.z.string().optional(),