@ozaiya/openclaw-channel 0.10.7 → 0.10.9

package/dist/src/channel.js

@@ -22,6 +22,10 @@ import { maybeTranscribeInboundAudio, prependVoiceTranscriptToAgentInput, resolv
 import { startGatewayMode } from "./gateway.js";
 import { VoiceCallSession } from "./voiceCall.js";
 import { PhoneCallSession } from "./phoneCall.js";
+import { summarizeWithYuanbao } from "./yuanbao.js";
+import { summarizeWithDoubao } from "./doubao.js";
+import { fetchXueqiuPost, searchXueqiuPosts } from "./xueqiu.js";
+import { fetchSocialMediaPost, searchSocialMedia, extractSocialMediaContent } from "./socialMedia.js";
 const DEFAULT_API_BASE_URL = "https://api.ozai.dev";
 const DEFAULT_WEBHOOK_PATH = "/ozaiya/webhook";
 const DEFAULT_ACCOUNT_ID = "default";
@@ -710,6 +714,47 @@ async function stageInboundAttachmentsForAgent(params) {
     }
     return staged;
 }
+/**
+ * Build the full set of channel agent tools for a given bot account.
+ * Used by both the plugin's agentTools factory (for OpenClaw tool registration)
+ * and the text-based tool call fallback in deliver().
+ */
+function buildChannelTools(account, cfg) {
+    const resolveForGroup = (groupId) => resolveAccountForGroup(cfg, groupId) ?? account;
+    const tools = [
+        createScheduleMessageTool(account),
+        createSendDirectMessageTool(account),
+        createSendRichMessageTool(account, resolveForGroup),
+        createCreateGroupTool(account),
+        createInviteMemberTool(account),
+        createReactTool(account),
+        createEditMessageTool(account),
+        createDeleteMessageTool(account),
+        createPinMessageTool(account),
+        createSearchUsersTool(account),
+        createListGroupsTool(account),
+        createMakePhoneCallTool(account, cfg),
+        createHangUpCallTool(account),
+        createStartInAppCallTool(account, cfg),
+    ];
+    const imageTool = createGenerateImageTool(account, cfg, resolveForGroup);
+    if (imageTool)
+        tools.push(imageTool);
+    tools.push(createDesktopTool());
+    const xueqiuTool = createFetchXueqiuTool(cfg);
+    if (xueqiuTool)
+        tools.push(xueqiuTool);
+    const xueqiuSearchTool = createSearchXueqiuTool(cfg);
+    if (xueqiuSearchTool)
+        tools.push(xueqiuSearchTool);
+    const scrapeTool = createScrapeSocialMediaTool(cfg);
+    if (scrapeTool)
+        tools.push(scrapeTool);
+    const summarizeTool = createSummarizeUrlTool(cfg);
+    if (summarizeTool)
+        tools.push(summarizeTool);
+    return tools;
+}
 export const ozaiyaPlugin = {
     id: "ozaiya",
     meta: {
@@ -947,28 +992,7 @@ export const ozaiyaPlugin = {
         const account = (gatewayAccount?.botToken?.trim() ? gatewayAccount : null) ?? resolveAccount(cfg);
         if (!account.botToken?.trim())
             return [];
-        const resolveForGroup = (groupId) => resolveAccountForGroup(cfg, groupId) ?? account;
-        const tools = [
-            createScheduleMessageTool(account),
-            createSendDirectMessageTool(account),
-            createSendRichMessageTool(account, resolveForGroup),
-            createCreateGroupTool(account),
-            createInviteMemberTool(account),
-            createReactTool(account),
-            createEditMessageTool(account),
-            createDeleteMessageTool(account),
-            createPinMessageTool(account),
-            createSearchUsersTool(account),
-            createListGroupsTool(account),
-            createMakePhoneCallTool(account, cfg),
-            createHangUpCallTool(account),
-            createStartInAppCallTool(account, cfg),
-        ];
-        const imageTool = createGenerateImageTool(account, cfg, resolveForGroup);
-        if (imageTool)
-            tools.push(imageTool);
-        tools.push(createDesktopTool());
-        return tools;
+        return buildChannelTools(account, cfg);
     }),
     gateway: {
         startAccount: async (ctx) => {
@@ -1154,6 +1178,15 @@ export const ozaiyaPlugin = {
                     if (payload.event === "session.reset") {
                         await handleSessionReset(payload, ctx);
                     }
+                    else if (payload.event === "call.started") {
+                        await handleCallStarted(payload, ctx);
+                    }
+                    else if (payload.event === "call.ended") {
+                        await handleCallEnded(payload, ctx);
+                    }
+                    else if (payload.event === "voice.llm_request") {
+                        return handleVoiceLlmRequest(payload, ctx);
+                    }
                 },
             });
             let unregisterHttp = () => { };
@@ -2101,6 +2134,189 @@ function createHangUpCallTool(account) {
         },
     };
 }
+function createFetchXueqiuTool(cfg) {
+    const ozaiyaCfg = (cfg?.channels?.ozaiya ?? {});
+    const xueqiuCfg = ozaiyaCfg.xueqiu;
+    const socialMediaCfg = ozaiyaCfg.socialMedia;
+    if (!xueqiuCfg && !socialMediaCfg)
+        return null;
+    return {
+        label: "Fetch Xueqiu Post",
+        name: "fetch_xueqiu",
+        ownerOnly: false,
+        description: "Fetch a Xueqiu (雪球) post's content and top comments given its URL. " +
+            "URL format: https://xueqiu.com/{userId}/{postId}. " +
+            "Returns the post title, author, engagement stats, full text, and top comments.",
+        parameters: {
+            type: "object",
+            properties: {
+                url: {
+                    type: "string",
+                    description: "The Xueqiu post URL, e.g. https://xueqiu.com/1234567890/123456789",
+                },
+            },
+            required: ["url"],
+        },
+        execute: async (_toolCallId, rawArgs) => {
+            try {
+                const args = rawArgs;
+                // Try media-fetch-api first
+                if (socialMediaCfg) {
+                    const result = await fetchSocialMediaPost(args.url, socialMediaCfg);
+                    if (result) {
+                        return { content: [{ type: "text", text: result }] };
+                    }
+                }
+                // Fallback to TS implementation
+                if (xueqiuCfg) {
+                    const result = await fetchXueqiuPost(args.url, xueqiuCfg);
+                    if (result) {
+                        return { content: [{ type: "text", text: result }] };
+                    }
+                }
+                return { content: [{ type: "text", text: "Failed to fetch Xueqiu post. The URL may be invalid or the post may not exist." }] };
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                return { content: [{ type: "text", text: `Error fetching Xueqiu post: ${msg}` }] };
+            }
+        },
+    };
+}
+function createSearchXueqiuTool(cfg) {
+    const ozaiyaCfg = (cfg?.channels?.ozaiya ?? {});
+    const xueqiuCfg = ozaiyaCfg.xueqiu;
+    const socialMediaCfg = ozaiyaCfg.socialMedia;
+    if (!xueqiuCfg && !socialMediaCfg)
+        return null;
+    return {
+        label: "Search Xueqiu",
+        name: "search_xueqiu",
+        ownerOnly: false,
+        description: "Search Xueqiu (雪球) for posts matching a keyword or stock name. " +
+            "Use this when the user asks about stocks, investments, or financial topics on Xueqiu. " +
+            "Returns a list of matching posts with authors, dates, excerpts, and URLs. " +
+            "You can then use fetch_xueqiu with a specific URL to get the full post content and comments.",
+        parameters: {
+            type: "object",
+            properties: {
+                query: {
+                    type: "string",
+                    description: "Search keyword — a stock name (e.g. '华特气体'), stock code (e.g. 'SZ002549'), or topic",
+                },
+                count: {
+                    type: "number",
+                    description: "Number of results to return (default: 5, max: 10)",
+                },
+            },
+            required: ["query"],
+        },
+        execute: async (_toolCallId, rawArgs) => {
+            try {
+                const args = rawArgs;
+                const count = Math.min(Math.max(args.count ?? 5, 1), 10);
+                // Try media-fetch-api first
+                if (socialMediaCfg) {
+                    const result = await searchSocialMedia(args.query, "xueqiu", socialMediaCfg, undefined, count);
+                    if (result) {
+                        return { content: [{ type: "text", text: result }] };
+                    }
+                }
+                // Fallback to TS implementation
+                if (xueqiuCfg) {
+                    const result = await searchXueqiuPosts(args.query, xueqiuCfg, undefined, count);
+                    if (result) {
+                        return { content: [{ type: "text", text: result }] };
+                    }
+                }
+                return { content: [{ type: "text", text: `Failed to search Xueqiu for "${args.query}". The service may be temporarily unavailable.` }] };
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                return { content: [{ type: "text", text: `Error searching Xueqiu: ${msg}` }] };
+            }
+        },
+    };
+}
+function createScrapeSocialMediaTool(cfg) {
+    const ozaiyaCfg = (cfg?.channels?.ozaiya ?? {});
+    const socialMediaCfg = ozaiyaCfg.socialMedia;
+    if (!socialMediaCfg)
+        return null;
+    return {
+        label: "Scrape Social Media Post",
+        name: "scrape_social_media",
+        ownerOnly: false,
+        description: "Scrape a social media post via browser automation — returns structured data including title, author, stats, full content text, and top comments. " +
+            "Supports Xiaohongshu (小红书), Douyin (抖音), Bilibili (B站), Weibo (微博), Toutiao (头条), and Xueqiu (雪球) URLs.",
+        parameters: {
+            type: "object",
+            properties: {
+                url: {
+                    type: "string",
+                    description: "The social media post URL, e.g. https://www.xiaohongshu.com/explore/abc123, " +
+                        "https://www.bilibili.com/video/BVxxx, https://m.weibo.cn/detail/xxx, " +
+                        "https://www.douyin.com/video/xxx",
+                },
+            },
+            required: ["url"],
+        },
+        execute: async (_toolCallId, rawArgs) => {
+            try {
+                const args = rawArgs;
+                const result = await fetchSocialMediaPost(args.url, socialMediaCfg);
+                if (!result) {
+                    return { content: [{ type: "text", text: "Failed to fetch social media post. The URL may be invalid or the service is unavailable." }] };
+                }
+                return { content: [{ type: "text", text: result }] };
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                return { content: [{ type: "text", text: `Error fetching social media post: ${msg}` }] };
+            }
+        },
+    };
+}
+function createSummarizeUrlTool(cfg) {
+    const ozaiyaCfg = (cfg?.channels?.ozaiya ?? {});
+    const socialMediaCfg = ozaiyaCfg.socialMedia;
+    if (!socialMediaCfg)
+        return null;
+    return {
+        label: "Summarize URL Content",
+        name: "summarize_url",
+        ownerOnly: false,
+        description: "Summarize a URL's content using an LLM backend (not a scraper). " +
+            "Works with any URL but especially useful for WeChat articles (mp.weixin.qq.com), " +
+            "Toutiao (toutiao.com), Douyin (douyin.com), and other Chinese social media. " +
+            "Use this when scrape_social_media fails or when you need an LLM-generated summary instead of raw structured data.",
+        parameters: {
+            type: "object",
+            properties: {
+                url: {
+                    type: "string",
+                    description: "The URL to summarize, e.g. https://mp.weixin.qq.com/s/xxx, " +
+                        "https://www.toutiao.com/article/xxx, https://www.douyin.com/video/xxx",
+                },
+            },
+            required: ["url"],
+        },
+        execute: async (_toolCallId, rawArgs) => {
+            try {
+                const args = rawArgs;
+                const result = await extractSocialMediaContent(args.url, socialMediaCfg);
+                if (!result) {
+                    return { content: [{ type: "text", text: "Failed to extract content. The URL may be invalid, the backend may be unavailable, or the backend is not configured for this URL type." }] };
+                }
+                return { content: [{ type: "text", text: result }] };
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                return { content: [{ type: "text", text: `Error extracting content: ${msg}` }] };
+            }
+        },
+    };
+}
 /**
  * Handle phone transcription in auto mode: dispatch to agent, speak the reply.
  */
@@ -2245,6 +2461,153 @@ ctx) {
             }
         }
     }
+    // Detect WeChat article URLs and enrich with Yuanbao summary
+    const wechatUrlMatch = messageText?.match(/https?:\/\/mp\.weixin\.qq\.com\/s\/[A-Za-z0-9_-]+/);
+    if (wechatUrlMatch) {
+        const ozaiyaCfg = (ctx.cfg?.channels?.ozaiya ?? {});
+        const yuanbaoCfg = ozaiyaCfg.yuanbao;
+        if (yuanbaoCfg) {
+            ctx.log?.info?.(`ozaiya: detected WeChat article URL, calling Yuanbao for summary`);
+            try {
+                const summary = await summarizeWithYuanbao(wechatUrlMatch[0], yuanbaoCfg, ctx.log);
+                if (summary) {
+                    content.text = `${content.text}\n\n[WeChat Article Summary via Yuanbao]\n${summary}`;
+                }
+            }
+            catch (err) {
+                ctx.log?.warn?.(`ozaiya: Yuanbao summarization failed: ${err}`);
+            }
+        }
+    }
+    // Detect Toutiao URLs — try media-fetch-api first, fallback to Doubao
+    const toutiaoUrlMatch = messageText?.match(/https?:\/\/(?:www\.)?toutiao\.com\/(?:article|video)\/\d+/);
+    if (toutiaoUrlMatch) {
+        const ozaiyaCfg = (ctx.cfg?.channels?.ozaiya ?? {});
+        const socialMediaCfg = ozaiyaCfg.socialMedia;
+        let fetched = false;
+        if (socialMediaCfg) {
+            ctx.log?.info?.(`ozaiya: detected Toutiao URL, fetching via media-fetch-api`);
+            try {
+                const postContent = await fetchSocialMediaPost(toutiaoUrlMatch[0], socialMediaCfg, ctx.log);
+                if (postContent) {
+                    content.text = `${content.text}\n\n${postContent}`;
+                    fetched = true;
+                }
+            }
+            catch (err) {
+                ctx.log?.warn?.(`ozaiya: media-fetch-api Toutiao fetch failed: ${err}`);
+            }
+        }
+        if (!fetched) {
+            const doubaoCfg = ozaiyaCfg.doubao;
+            if (doubaoCfg) {
+                ctx.log?.info?.(`ozaiya: Toutiao media-fetch-api failed, falling back to Doubao`);
+                try {
+                    const summary = await summarizeWithDoubao(toutiaoUrlMatch[0], doubaoCfg, ctx.log);
+                    if (summary) {
+                        content.text = `${content.text}\n\n[Content Summary via Doubao]\n${summary}`;
+                    }
+                }
+                catch (err) {
+                    ctx.log?.warn?.(`ozaiya: Doubao summarization failed: ${err}`);
+                }
+            }
+        }
+    }
+    // Detect Douyin URLs — try media-fetch-api first, fallback to Doubao
+    const douyinUrlMatch = messageText?.match(/https?:\/\/(?:v\.douyin\.com\/[a-zA-Z0-9_\-]+\/?|(?:www\.)?douyin\.com\/(?:video|note)\/\d+)/);
+    if (douyinUrlMatch) {
+        const ozaiyaCfg = (ctx.cfg?.channels?.ozaiya ?? {});
+        const socialMediaCfg = ozaiyaCfg.socialMedia;
+        let fetched = false;
+        if (socialMediaCfg) {
+            ctx.log?.info?.(`ozaiya: detected Douyin URL, fetching via media-fetch-api`);
+            try {
+                const postContent = await fetchSocialMediaPost(douyinUrlMatch[0], socialMediaCfg, ctx.log);
+                if (postContent) {
+                    content.text = `${content.text}\n\n[抖音]\n${postContent}`;
+                    fetched = true;
+                }
+            }
+            catch (err) {
+                ctx.log?.warn?.(`ozaiya: media-fetch-api Douyin fetch failed: ${err}`);
+            }
+        }
+        if (!fetched) {
+            const doubaoCfg = ozaiyaCfg.doubao;
+            if (doubaoCfg) {
+                ctx.log?.info?.(`ozaiya: Douyin media-fetch-api failed, falling back to Doubao`);
+                try {
+                    const summary = await summarizeWithDoubao(douyinUrlMatch[0], doubaoCfg, ctx.log);
+                    if (summary) {
+                        content.text = `${content.text}\n\n[Content Summary via Doubao]\n${summary}`;
+                    }
+                }
+                catch (err) {
+                    ctx.log?.warn?.(`ozaiya: Doubao summarization failed: ${err}`);
+                }
+            }
+        }
+    }
+    // Detect social media URLs (XHS, Bilibili, Weibo) and enrich via media-fetch-api
+    const socialMediaUrlMatch = messageText?.match(/https?:\/\/(?:(?:www\.)?(?:xiaohongshu\.com\/(?:explore|discovery\/item)\/[a-zA-Z0-9]+|xhslink\.com\/[a-zA-Z0-9\/]+)|(?:www\.)?bilibili\.com\/video\/(?:BV[a-zA-Z0-9]+|av\d+)|b23\.tv\/[a-zA-Z0-9]+|(?:www\.)?weibo\.com\/\d+\/[a-zA-Z0-9]+|m\.weibo\.cn\/(?:detail|status)\/\d+)/);
+    if (socialMediaUrlMatch) {
+        const ozaiyaCfg = (ctx.cfg?.channels?.ozaiya ?? {});
+        const socialMediaCfg = ozaiyaCfg.socialMedia;
+        if (socialMediaCfg) {
+            const matchedUrl = socialMediaUrlMatch[0];
+            const platformHint = matchedUrl.includes("bilibili.com") || matchedUrl.includes("b23.tv")
+                ? "B站"
+                : matchedUrl.includes("weibo.c")
+                    ? "微博"
+                    : "小红书";
+            ctx.log?.info?.(`ozaiya: detected ${platformHint} URL, fetching content via media-fetch-api`);
+            try {
+                const postContent = await fetchSocialMediaPost(matchedUrl, socialMediaCfg, ctx.log);
+                if (postContent) {
+                    content.text = `${content.text}\n\n[${platformHint}]\n${postContent}`;
+                }
+            }
+            catch (err) {
+                ctx.log?.warn?.(`ozaiya: social media fetch failed: ${err}`);
+            }
+        }
+    }
+    // Detect Xueqiu post URLs — try media-fetch-api first, fallback to TS CDP implementation
+    const xueqiuUrlMatch = messageText?.match(/https?:\/\/xueqiu\.com\/\d+\/\d+/);
+    if (xueqiuUrlMatch) {
+        const ozaiyaCfg = (ctx.cfg?.channels?.ozaiya ?? {});
+        const socialMediaCfg = ozaiyaCfg.socialMedia;
+        let fetched = false;
+        if (socialMediaCfg) {
+            ctx.log?.info?.(`ozaiya: detected Xueqiu URL, fetching via media-fetch-api`);
+            try {
+                const postContent = await fetchSocialMediaPost(xueqiuUrlMatch[0], socialMediaCfg, ctx.log);
+                if (postContent) {
+                    content.text = `${content.text}\n\n[雪球]\n${postContent}`;
+                    fetched = true;
+                }
+            }
+            catch (err) {
+                ctx.log?.warn?.(`ozaiya: media-fetch-api Xueqiu fetch failed: ${err}`);
+            }
+        }
+        if (!fetched) {
+            const xueqiuCfg = ozaiyaCfg.xueqiu;
+            if (xueqiuCfg) {
+                ctx.log?.info?.(`ozaiya: Xueqiu media-fetch-api unavailable, falling back to TS implementation`);
+                try {
+                    const postContent = await fetchXueqiuPost(xueqiuUrlMatch[0], xueqiuCfg, ctx.log);
+                    if (postContent) {
+                        content.text = `${content.text}\n\n[雪球]\n${postContent}`;
+                    }
+                }
+                catch (err) {
+                    ctx.log?.warn?.(`ozaiya: Xueqiu TS fetch failed: ${err}`);
+                }
+            }
+        }
+    }
     const inboundAttachments = normalizeAttachments(content.files);
     const attachmentSummary = buildAttachmentSummary(inboundAttachments);
     const linkPreviewSummary = buildLinkPreviewSummary(content.linkPreviews);
@@ -2425,6 +2788,13 @@ ctx) {
     }).catch((err) => {
         ctx.log?.warn?.(`ozaiya: failed recording session: ${String(err)}`);
     });
+    // Build channel tools map for text-based tool call fallback.
+    // When a model outputs tool calls as plain text instead of structured API tool_calls,
+    // we match against registered tool names and execute via their .execute() method.
+    // Uses the current bot's account directly (not the factory which re-resolves in gateway mode).
+    const channelTools = buildChannelTools(account, ctx.cfg);
+    const channelToolsByName = new Map(channelTools.map((t) => [t.name, t]));
+    ctx.log?.info?.(`ozaiya: text fallback tools loaded: ${channelToolsByName.size} tools [${[...channelToolsByName.keys()].join(", ")}]`);
     // Dispatch to agent with buffered block dispatcher
     await ch.reply.dispatchReplyWithBufferedBlockDispatcher({
         ctx: msgCtx,
@@ -2435,15 +2805,59 @@ ctx) {
                 ctx.log?.info?.(`ozaiya: deliver called, text length=${replyText?.length ?? 0}, empty=${!replyText?.trim()}, voiceReply=${voiceReply}, voiceReplyVoice=${voiceReplyVoice ?? 'none'}`);
                 if (!replyText?.trim())
                     return;
-                // Handle XML tool calls that some providers return as text instead of API tool_calls.
-                // Parse <function_calls><invoke name="..."><parameter name="...">...</parameter></invoke></function_calls>
-                // and execute matching Ozaiya tools directly.
+                // Generic fallback: intercept tool calls that models output as text
+                // instead of structured API tool_calls. Supports two formats:
+                // 1. JSON function syntax: tool_name({"arg":"value"}) or tool_name({arg: "value"})
+                // 2. XML: <function_calls><invoke name="tool_name"><parameter name="arg">value</parameter></invoke></function_calls>
+                let textToolsExecuted = false;
+                // --- Format 1: JSON function syntax  tool_name({"key":"val"}) ---
+                if (channelToolsByName.size > 0) {
+                    const toolNames = [...channelToolsByName.keys()].map((n) => n.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"));
+                    const jsonFnRegex = new RegExp(`\\b(${toolNames.join("|")})\\s*\\(\\s*(\\{[\\s\\S]*?\\})\\s*\\)`, "g");
+                    let jsonMatch;
+                    while ((jsonMatch = jsonFnRegex.exec(replyText)) !== null) {
+                        const toolName = jsonMatch[1];
+                        const tool = channelToolsByName.get(toolName);
+                        if (!tool)
+                            continue;
+                        // Always strip the tool call text from the message — users should never
+                        // see raw tool_name({...}) syntax even if execution fails.
+                        textToolsExecuted = true;
+                        try {
+                            // Try strict JSON first, then lenient (unquoted keys, trailing commas)
+                            let args;
+                            try {
+                                args = JSON.parse(jsonMatch[2]);
+                            }
+                            catch {
+                                // Handle JS-style object literals: unquoted keys, trailing commas
+                                const lenient = jsonMatch[2]
+                                    .replace(/([{,]\s*)([a-zA-Z_]\w*)\s*:/g, '$1"$2":')
+                                    .replace(/,\s*}/g, "}");
+                                args = JSON.parse(lenient);
+                            }
+                            ctx.log?.info?.(`ozaiya: text fallback — executing ${toolName}(${JSON.stringify(args)})`);
+                            await tool.execute(`text-fallback-${Date.now()}`, args);
+                        }
+                        catch (err) {
+                            ctx.log?.warn?.(`ozaiya: text fallback — ${toolName} failed: ${String(err)}`);
+                        }
+                    }
+                    if (textToolsExecuted) {
+                        replyText = replyText.replace(jsonFnRegex, "").trim();
+                        if (!replyText)
+                            return;
+                    }
+                }
+                // --- Format 2: XML <function_calls> ---
                 if (replyText.includes("<function_calls>") && replyText.includes("<invoke")) {
                     const invokeRegex = /<invoke\s+name="([^"]+)">([\s\S]*?)<\/invoke>/g;
                     let match;
-                    let executedTools = false;
                     while ((match = invokeRegex.exec(replyText)) !== null) {
                         const toolName = match[1];
+                        const tool = channelToolsByName.get(toolName);
+                        if (!tool)
+                            continue;
                         const paramsXml = match[2];
                         const paramRegex = /<parameter\s+name="([^"]+)">([^<]*)<\/parameter>/g;
                         const args = {};
@@ -2451,71 +2865,25 @@ ctx) {
                         while ((pm = paramRegex.exec(paramsXml)) !== null) {
                             args[pm[1]] = pm[2];
                         }
-                        ctx.log?.info?.(`ozaiya: parsed XML tool call: ${toolName}(${JSON.stringify(args)})`);
-                        if (toolName === "start_in_app_call" && args.groupId) {
-                            try {
-                                const callResult = await startCall(account.apiBaseUrl, account.botToken, args.groupId, args.type ?? "voice");
-                                ctx.log?.info?.(`ozaiya: XML tool call executed: start_in_app_call for group ${args.groupId}`);
-                                executedTools = true;
-                                // Connect bot to LiveKit for STT/TTS (standard engine)
-                                if (callResult && callResult.voiceEngine === "standard" && !callResult.joined) {
-                                    if (activeVoiceCalls.has(callResult.callId)) {
-                                        ctx.log?.info?.(`ozaiya: already in call ${callResult.callId}, skipping`);
-                                    }
-                                    else {
-                                        const cfg = ctx.cfg;
-                                        const ozaiyaCfg = (cfg?.channels?.ozaiya ?? {});
-                                        const voiceCallCfg = ozaiyaCfg.voiceCall ?? {};
-                                        if (voiceCallCfg.enabled !== false) {
-                                            const effectiveVoiceCallCfg = { ...voiceCallCfg };
-                                            if (account.voiceConfig?.provider === "deepgram" && account.voiceConfig.apiKey) {
-                                                effectiveVoiceCallCfg.deepgramApiKey = account.voiceConfig.apiKey;
-                                            }
-                                            if (!effectiveVoiceCallCfg.volcengineTts && ozaiyaCfg.volcengineTts) {
-                                                effectiveVoiceCallCfg.volcengineTts = ozaiyaCfg.volcengineTts;
-                                            }
-                                            const session = new VoiceCallSession({
-                                                callId: callResult.callId,
-                                                groupId: args.groupId,
-                                                livekitToken: callResult.token,
-                                                livekitUrl: callResult.url,
-                                                voiceCallConfig: effectiveVoiceCallCfg,
-                                                onTranscript: (text) => {
-                                                    void handleVoiceTranscript(text, session, route, account, { cfg, log: ctx.log });
-                                                },
-                                                log: ctx.log,
-                                            });
-                                            activeVoiceCalls.set(callResult.callId, session);
-                                            try {
-                                                await session.connect();
-                                                ctx.log?.info?.(`ozaiya: bot joined LiveKit room for call ${callResult.callId}`);
-                                            }
-                                            catch (connErr) {
-                                                activeVoiceCalls.delete(callResult.callId);
-                                                await session.disconnect();
-                                                await leaveCall(account.apiBaseUrl, account.botToken, callResult.callId).catch(() => { });
-                                                ctx.log?.warn?.(`ozaiya: failed to join LiveKit: ${String(connErr)}`);
-                                            }
-                                        }
-                                    }
-                                }
-                            }
-                            catch (err) {
-                                ctx.log?.warn?.(`ozaiya: XML tool call failed: ${String(err)}`);
-                            }
+                        ctx.log?.info?.(`ozaiya: text fallback (XML) — executing ${toolName}(${JSON.stringify(args)})`);
+                        try {
+                            await tool.execute(`text-fallback-xml-${Date.now()}`, args);
+                            textToolsExecuted = true;
+                        }
+                        catch (err) {
+                            ctx.log?.warn?.(`ozaiya: text fallback (XML) — ${toolName} failed: ${String(err)}`);
                         }
                     }
-                    // Strip XML function_calls from reply text, keep any remaining text
                     replyText = replyText
                         .replace(/<function_calls>[\s\S]*?<\/function_calls>/g, "")
                         .replace(/<function_results>[\s\S]*?<\/function_results>/g, "")
                         .replace(/\[\[reply_to_current\]\]/g, "")
                         .replace(/NO_REPLY/g, "")
                         .trim();
-                    if (!replyText && executedTools)
-                        return; // Tool executed, no text to send
+                    if (!replyText && textToolsExecuted)
+                        return;
                     if (!replyText)
-                        return; // Nothing left after stripping
+                        return;
                 }
                 // Voice reply: synthesize TTS audio and send as voice message
                 if (voiceReply) {