@ozaiya/openclaw-channel 0.8.0 → 0.8.1

package/dist/src/channel.js

@@ -9,7 +9,7 @@ import fs from "node:fs/promises";
 import path from "node:path";
 import { registerPluginHttpRoute } from "openclaw/plugin-sdk/webhook-ingress";
 import { unwrapGroupKey, decryptMessage, encryptMessage, wrapGroupKey } from "./crypto.js";
-import { sendMessage, probeApi, fetchGroups, addMember, getUserPublicKeys, toggleReaction, editMessage, deleteMessage, pinMessage, unpinMessage, uploadFile, searchUsers, fetchLinkPreview, joinCall, leaveCall, } from "./api.js";
+import { sendMessage, probeApi, fetchGroups, addMember, getUserPublicKeys, toggleReaction, editMessage, deleteMessage, pinMessage, unpinMessage, uploadFile, searchUsers, fetchLinkPreview, joinCall, leaveCall, startPhoneCall, endPhoneCall, updatePhoneCallStatus, } from "./api.js";
 import { botCreateDirect, botCreateGroup } from "./botActions.js";
 import { buildInlineKeyboardSummary, buildLinkPreviewSummary, normalizeMessageText, normalizeToolInlineKeyboardRows, } from "./richContent.js";
 import { normalizeCallbackQueryPayload } from "./callbackQuery.js";
@@ -19,6 +19,7 @@ import { getOzaiyaRuntime } from "./runtime.js";
 import { maybeTranscribeInboundAudio, prependVoiceTranscriptToAgentInput, resolveOzaiyaSttConfig, } from "./transcribeAudio.js";
 import { startGatewayMode } from "./gateway.js";
 import { VoiceCallSession } from "./voiceCall.js";
+import { PhoneCallSession } from "./phoneCall.js";
 const DEFAULT_API_BASE_URL = "https://api.ozai.dev";
 const DEFAULT_WEBHOOK_PATH = "/ozaiya/webhook";
 const DEFAULT_ACCOUNT_ID = "default";
@@ -34,6 +35,10 @@ const unwrappedKeys = new Map();
 const groupToBotAccountId = new Map();
 // Active voice call sessions keyed by callId
 const activeVoiceCalls = new Map();
+// Active phone call sessions keyed by phoneCallId
+const activePhoneCalls = new Map();
+// Map groupId → phoneCallId for active phone calls (for manual mode message routing)
+const groupToActivePhoneCall = new Map();
 // Runtime state tracking
 const runtimeState = new Map();
 function recordState(accountId, patch) {
@@ -348,13 +353,226 @@ async function synthesizeSpeechToMp3(text, deepgramApiKey, ttsModel, log) {
     }
 }
 /**
- * Synthesize voice reply using OpenClaw runtime TTS (supports Volcengine/Edge/OpenAI etc.),
- * falling back to Deepgram if runtime TTS is unavailable.
+ * Synthesize text to speech via Volcengine (火山引擎/豆包) TTS v3 streaming API.
+ * Uses X-Api-Key auth with the unidirectional streaming endpoint.
+ * Returns audio buffer or null on failure.
+ */
+async function synthesizeSpeechVolcengineV3(text, apiKey, voice, encoding, speedRatio, resourceId, log) {
+    const headers = {
+        "Content-Type": "application/json",
+        "X-Api-Key": apiKey,
+        "X-Api-Resource-Id": resourceId,
+        "X-Api-Connect-Id": `tts-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
+    };
+    const body = {
+        user: { uid: "ozaiya-bot" },
+        req_params: { text, speaker: voice, speed_ratio: speedRatio },
+        audio_params: { format: encoding, sample_rate: 24000 },
+    };
+    log?.info?.(`ozaiya: Volcengine TTS v3 request: speaker=${voice} encoding=${encoding} resourceId=${resourceId}`);
+    const res = await fetch("https://openspeech.bytedance.com/api/v3/tts/unidirectional", {
+        method: "POST",
+        headers,
+        body: JSON.stringify(body),
+        signal: AbortSignal.timeout(30_000),
+    });
+    if (!res.ok) {
+        const errText = await res.text().catch(() => "");
+        log?.warn?.(`ozaiya: Volcengine TTS v3 HTTP error: ${res.status} ${errText}`);
+        return null;
+    }
+    // Collect streaming response — line-delimited JSON, each line has { data: "<base64>" }
+    const responseText = await res.text();
+    const audioChunks = [];
+    for (const line of responseText.split("\n")) {
+        const trimmed = line.trim();
+        if (!trimmed)
+            continue;
+        try {
+            const chunk = JSON.parse(trimmed);
+            if (chunk.data) {
+                audioChunks.push(Buffer.from(chunk.data, "base64"));
+            }
+            // Non-success, non-final codes indicate errors
+            if (chunk.code && chunk.code !== 20000000 && chunk.code !== 0) {
+                log?.warn?.(`ozaiya: Volcengine TTS v3 chunk error: code=${chunk.code} message=${chunk.message}`);
+            }
+        }
+        catch {
+            // skip non-JSON lines
+        }
+    }
+    if (audioChunks.length === 0) {
+        log?.warn?.(`ozaiya: Volcengine TTS v3: no audio data in response (${responseText.length} bytes raw)`);
+        return null;
+    }
+    log?.info?.(`ozaiya: Volcengine TTS v3: collected ${audioChunks.length} chunks`);
+    return Buffer.concat(audioChunks);
+}
+/**
+ * Synthesize text to speech via Volcengine (火山引擎/豆包) TTS v1 API.
+ * Uses Bearer;token auth (legacy).
+ * Returns audio buffer or null on failure.
+ */
+async function synthesizeSpeechVolcengineV1(text, config, voice, encoding, speedRatio, log) {
+    const cluster = config.cluster ?? "volcano_tts";
+    const reqId = `tts-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+    const payload = {
+        app: {
+            appid: config.appId ?? "",
+            token: config.accessToken ?? "",
+            cluster,
+        },
+        user: { uid: "ozaiya-bot" },
+        audio: {
+            voice_type: voice,
+            encoding,
+            speed_ratio: speedRatio,
+        },
+        request: {
+            reqid: reqId,
+            text,
+            operation: "query",
+        },
+    };
+    const headers = {
+        "Content-Type": "application/json",
+        Authorization: `Bearer;${config.accessToken}`,
+    };
+    const res = await fetch("https://openspeech.bytedance.com/api/v1/tts", {
+        method: "POST",
+        headers,
+        body: JSON.stringify(payload),
+        signal: AbortSignal.timeout(30_000),
+    });
+    if (!res.ok) {
+        log?.warn?.(`ozaiya: Volcengine TTS v1 HTTP error: ${res.status} ${res.statusText}`);
+        return null;
+    }
+    const result = await res.json();
+    if (result.code !== 3000 || !result.data) {
+        log?.warn?.(`ozaiya: Volcengine TTS v1 error: code=${result.code} message=${result.message}`);
+        return null;
+    }
+    return Buffer.from(result.data, "base64");
+}
+/**
+ * Synthesize text to speech via Volcengine AI Gateway (OpenAI-compatible endpoint).
+ * Uses the Ark API Key with Bearer token auth.
+ * Returns audio buffer or null on failure.
+ */
+async function synthesizeSpeechVolcengineGateway(text, arkApiKey, voice, encoding, speedRatio, log) {
+    log?.info?.(`ozaiya: Volcengine AI Gateway TTS request: voice=${voice}`);
+    const res = await fetch("https://ai-gateway.vei.volces.com/v1/audio/speech", {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${arkApiKey}`,
+        },
+        body: JSON.stringify({
+            model: "doubao-tts",
+            input: text,
+            voice,
+            response_format: encoding,
+            speed: speedRatio,
+        }),
+        signal: AbortSignal.timeout(30_000),
+    });
+    if (!res.ok) {
+        const errText = await res.text().catch(() => "");
+        log?.warn?.(`ozaiya: Volcengine AI Gateway TTS HTTP error: ${res.status} ${errText}`);
+        return null;
+    }
+    // Response is raw audio binary
+    const arrayBuffer = await res.arrayBuffer();
+    if (arrayBuffer.byteLength === 0) {
+        log?.warn?.(`ozaiya: Volcengine AI Gateway TTS: empty response`);
+        return null;
+    }
+    log?.info?.(`ozaiya: Volcengine AI Gateway TTS: received ${arrayBuffer.byteLength} bytes`);
+    return Buffer.from(arrayBuffer);
+}
+/**
+ * Synthesize text to speech via Volcengine (火山引擎/豆包) TTS API.
+ * Priority:
+ *   1. arkApiKey → AI Gateway OpenAI-compatible endpoint (simplest, uses Ark API Key)
+ *   2. apiKey → v3 streaming openspeech endpoint (uses speech-specific API Key)
+ *   3. accessToken → v1 non-streaming openspeech endpoint (legacy)
+ * Returns audio buffer or null on failure.
+ */
+async function synthesizeSpeechVolcengine(text, config, log) {
+    try {
+        const voice = config.voice ?? "zh_female_wanwanxiaohe_moon_bigtts";
+        const encoding = config.encoding ?? "mp3";
+        const speedRatio = config.speedRatio ?? 1.0;
+        if (config.arkApiKey) {
+            return await synthesizeSpeechVolcengineGateway(text, config.arkApiKey, voice, encoding, speedRatio, log);
+        }
+        else if (config.apiKey) {
+            const resourceId = config.resourceId ?? "volc.service_type.10029";
+            return await synthesizeSpeechVolcengineV3(text, config.apiKey, voice, encoding, speedRatio, resourceId, log);
+        }
+        else if (config.accessToken) {
+            return await synthesizeSpeechVolcengineV1(text, config, voice, encoding, speedRatio, log);
+        }
+        else {
+            log?.warn?.(`ozaiya: Volcengine TTS: no arkApiKey, apiKey, or accessToken configured`);
+            return null;
+        }
+    }
+    catch (err) {
+        log?.warn?.(`ozaiya: Volcengine TTS failed: ${String(err)}`);
+        return null;
+    }
+}
+/**
+ * Synthesize voice reply. Priority:
+ * 1. Volcengine TTS (if configured — supports Chinese)
+ * 2. OpenClaw runtime TTS (if available — uses configured provider)
+ * 3. Deepgram TTS (fallback — English only)
  */
 async function synthesizeVoiceReply(text, 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
-ctx) {
-    // Try OpenClaw runtime TTS first (uses configured provider: volcano, edge, openai, etc.)
+ctx, voiceOverride) {
+    const ozaiyaChannelCfg = (ctx.cfg?.channels?.ozaiya ?? {});
+    const account = ctx.account;
+    const perBotVoice = account?.voiceConfig;
+    // 0. Per-bot voice config from gateway (highest priority)
+    if (perBotVoice?.provider === 'volcengine' && perBotVoice.appId && perBotVoice.accessToken) {
+        ctx.log?.info?.(`ozaiya: using per-bot Volcengine TTS`);
+        const volcCfg = {
+            appId: perBotVoice.appId,
+            accessToken: perBotVoice.accessToken,
+            ...(voiceOverride ? { voice: voiceOverride } : {}),
+        };
+        const buf = await synthesizeSpeechVolcengine(text, volcCfg, ctx.log);
+        if (buf) {
+            return { data: buf, ext: `.${volcCfg.encoding ?? "mp3"}` };
+        }
+        ctx.log?.warn?.(`ozaiya: per-bot Volcengine TTS failed, trying fallbacks`);
+    }
+    if (perBotVoice?.provider === 'deepgram' && perBotVoice.apiKey) {
+        ctx.log?.info?.(`ozaiya: using per-bot Deepgram TTS`);
+        const ttsModel = ozaiyaChannelCfg?.voiceCall?.tts?.model ?? "aura-asteria-en";
+        const mp3Buffer = await synthesizeSpeechToMp3(text, perBotVoice.apiKey, ttsModel, ctx.log);
+        if (mp3Buffer)
+            return { data: mp3Buffer, ext: ".mp3" };
+        ctx.log?.warn?.(`ozaiya: per-bot Deepgram TTS failed, trying fallbacks`);
+    }
+    // 1. Volcengine TTS (preferred for Chinese)
+    if (ozaiyaChannelCfg?.volcengineTts?.arkApiKey || ozaiyaChannelCfg?.volcengineTts?.apiKey || ozaiyaChannelCfg?.volcengineTts?.appId) {
+        const effectiveVolcCfg = voiceOverride
+            ? { ...ozaiyaChannelCfg.volcengineTts, voice: voiceOverride }
+            : ozaiyaChannelCfg.volcengineTts;
+        ctx.log?.info?.(`ozaiya: using Volcengine TTS (voice=${effectiveVolcCfg.voice ?? 'default'})`);
+        const buf = await synthesizeSpeechVolcengine(text, effectiveVolcCfg, ctx.log);
+        if (buf) {
+            const ext = `.${ozaiyaChannelCfg.volcengineTts.encoding ?? "mp3"}`;
+            return { data: buf, ext };
+        }
+        ctx.log?.warn?.(`ozaiya: Volcengine TTS failed, trying fallbacks`);
+    }
+    // 2. OpenClaw runtime TTS (edge, openai, elevenlabs etc.)
     try {
         const runtime = getOzaiyaRuntime();
         if (runtime.tts?.textToSpeech) {
@@ -376,8 +594,7 @@ ctx) {
     catch (err) {
         ctx.log?.warn?.(`ozaiya: runtime TTS unavailable: ${String(err)}`);
     }
-    // Fallback: Deepgram direct API
-    const ozaiyaChannelCfg = (ctx.cfg?.channels?.ozaiya ?? {});
+    // 3. Deepgram direct API (English fallback)
     const ttsApiKey = ozaiyaChannelCfg?.voiceCall?.deepgramApiKey || process.env.DEEPGRAM_API_KEY || "";
     const ttsModel = ozaiyaChannelCfg?.voiceCall?.tts?.model ?? "aura-asteria-en";
     if (!ttsApiKey)
@@ -718,6 +935,8 @@ export const ozaiyaPlugin = {
             createPinMessageTool(account),
             createSearchUsersTool(account),
             createListGroupsTool(account),
+            createMakePhoneCallTool(account, cfg),
+            createHangUpCallTool(account),
         ];
     }),
     gateway: {
@@ -730,7 +949,7 @@ export const ozaiyaPlugin = {
                 ctx.log?.info(`[gateway] starting gateway mode`);
                 recordState(account.accountId, { running: true, lastStartAt: Date.now() });
                 const ozaiya = resolveConfig(ctx.cfg);
-                const stateDir = ctx.runtime?.state?.resolveStateDir?.() ?? process.env.HOME ?? ".";
+                const stateDir = process.env.OPENCLAW_STATE_DIR ?? ctx.runtime?.state?.resolveStateDir?.() ?? process.env.HOME ?? ".";
                 // Track per-bot unregister functions for hot-reload
                 const botUnregisters = new Map();
                 const startBotHandler = (botAccount) => {
@@ -858,6 +1077,12 @@ export const ozaiyaPlugin = {
                     session.disconnect().catch(() => { });
                     activeVoiceCalls.delete(callId);
                 }
+                // Disconnect all active phone call sessions
+                for (const [phoneCallId, session] of activePhoneCalls) {
+                    session.disconnect().catch(() => { });
+                    activePhoneCalls.delete(phoneCallId);
+                }
+                groupToActivePhoneCall.clear();
                 for (const id of gatewayBotAccounts.keys()) {
                     recordState(id, { running: false, lastStopAt: Date.now() });
                 }
@@ -1541,6 +1766,227 @@ function createListGroupsTool(account) {
         },
     };
 }
+function createMakePhoneCallTool(account, cfg) {
+    return {
+        label: "Make Phone Call",
+        name: "make_phone_call",
+        ownerOnly: false,
+        description: "Initiate an outbound phone call to a PSTN number via SIP. " +
+            "The call is recorded and the recording + transcript are saved to the chat. " +
+            "In 'auto' mode, you speak directly to the callee via STT/TTS. " +
+            "In 'manual' mode, the callee's speech is transcribed to chat for the user to respond.",
+        parameters: {
+            type: "object",
+            properties: {
+                groupId: {
+                    type: "string",
+                    description: "The group/DM where the call record will be posted.",
+                },
+                phoneNumber: {
+                    type: "string",
+                    description: "E.164 phone number to call (e.g. +8613800138000).",
+                },
+                mode: {
+                    type: "string",
+                    enum: ["auto", "manual"],
+                    description: "auto = AI handles conversation, manual = transcribe to chat for user to reply. Default: auto.",
+                },
+                purpose: {
+                    type: "string",
+                    description: "Brief note about why you're making this call (logged for reference).",
+                },
+            },
+            required: ["groupId", "phoneNumber"],
+        },
+        execute: async (_toolCallId, rawArgs) => {
+            const args = rawArgs;
+            try {
+                const mode = args.mode ?? "auto";
+                const result = await startPhoneCall(account.apiBaseUrl, account.botToken, args.groupId, args.phoneNumber, mode, args.purpose);
+                // Report connected status
+                updatePhoneCallStatus(account.apiBaseUrl, account.botToken, result.phoneCallId, "connected").catch(() => { });
+                const ozaiyaCfg = (cfg?.channels?.ozaiya ?? {});
+                const voiceCallCfg = ozaiyaCfg.voiceCall ?? {};
+                // Override per-bot voice config and pass volcengineTts from channel config
+                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;
+                }
+                // Create PhoneCallSession
+                const session = new PhoneCallSession({
+                    phoneCallId: result.phoneCallId,
+                    groupId: args.groupId,
+                    livekitToken: result.livekitToken,
+                    livekitUrl: result.livekitUrl,
+                    mode,
+                    voiceCallConfig: effectiveVoiceCallCfg,
+                    onTranscript: (text) => {
+                        if (mode === "auto") {
+                            // Auto mode: dispatch to agent, speak reply
+                            void handlePhoneAutoTranscript(text, session, account, cfg, args.groupId);
+                        }
+                        else {
+                            // Manual mode: post to chat as a message
+                            void postPhoneTranscriptToChat(text, account, args.groupId);
+                        }
+                    },
+                    onPhoneHangUp: () => {
+                        // Phone person hung up — end the call
+                        void cleanupPhoneCall(result.phoneCallId, session, account);
+                    },
+                });
+                activePhoneCalls.set(result.phoneCallId, session);
+                groupToActivePhoneCall.set(args.groupId, result.phoneCallId);
+                // Connect to LiveKit
+                await session.connect();
+                return {
+                    content: [{
+                            type: "text",
+                            text: `Phone call initiated (ID: ${result.phoneCallId}). ` +
+                                `Calling ${args.phoneNumber} in ${mode} mode. ` +
+                                `The call is being recorded. Use hang_up_call to end it.`,
+                        }],
+                };
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                return { content: [{ type: "text", text: `Error starting phone call: ${msg}` }] };
+            }
+        },
+    };
+}
+function createHangUpCallTool(account) {
+    return {
+        label: "Hang Up Call",
+        name: "hang_up_call",
+        ownerOnly: false,
+        description: "End an active outbound phone call.",
+        parameters: {
+            type: "object",
+            properties: {
+                phoneCallId: {
+                    type: "string",
+                    description: "The phone call ID returned by make_phone_call.",
+                },
+            },
+            required: ["phoneCallId"],
+        },
+        execute: async (_toolCallId, rawArgs) => {
+            const args = rawArgs;
+            try {
+                const session = activePhoneCalls.get(args.phoneCallId);
+                if (session) {
+                    await cleanupPhoneCall(args.phoneCallId, session, account);
+                }
+                else {
+                    // No local session, still try API
+                    await endPhoneCall(account.apiBaseUrl, account.botToken, args.phoneCallId);
+                }
+                return {
+                    content: [{ type: "text", text: `Phone call ${args.phoneCallId} ended.` }],
+                };
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                return { content: [{ type: "text", text: `Error ending phone call: ${msg}` }] };
+            }
+        },
+    };
+}
+/**
+ * Handle phone transcription in auto mode: dispatch to agent, speak the reply.
+ */
+async function handlePhoneAutoTranscript(text, session, account, cfg, groupId) {
+    if (session.isDisposed)
+        return;
+    const runtime = getOzaiyaRuntime();
+    const ch = runtime.channel;
+    const route = ch.routing.resolveAgentRoute({
+        cfg,
+        channel: "ozaiya",
+        accountId: account.accountId,
+        peer: { kind: "group", id: groupId },
+    });
+    const ozaiyaCfg = (cfg?.channels?.ozaiya ?? {});
+    const voicePrompt = ozaiyaCfg.voiceCall?.agentPrompt ??
+        "[Phone Call] You are in a live phone call. Your response will be spoken aloud via TTS. " +
+            "Rules: respond concisely (1-3 sentences), use natural spoken language, " +
+            "never use markdown/code blocks/bullet lists/URLs/emojis. " +
+            "Do not say \"sure\" or \"of course\" — just answer directly.";
+    const bodyForAgent = `${voicePrompt}\n\n${text}`;
+    const body = `[ozaiya] from: phone caller | at: ${new Date().toISOString()}\n---\n${text}`;
+    const msgCtx = ch.reply.finalizeInboundContext({
+        Body: body,
+        BodyForAgent: bodyForAgent,
+        RawBody: text,
+        CommandBody: text,
+        From: `ozaiya:group:${groupId}`,
+        To: `ozaiya:group:${groupId}`,
+        SessionKey: route.sessionKey,
+        AccountId: route.accountId,
+        ChatType: "group",
+        ConversationLabel: `group:${groupId}`,
+        GroupSubject: groupId,
+        SenderId: "phone-caller",
+        SenderName: "Phone Caller",
+        Provider: "ozaiya",
+        Surface: "ozaiya-phone",
+        MessageSid: `phone-${Date.now()}`,
+        Timestamp: Date.now(),
+        NumFiles: 0,
+        NumMedia: 0,
+        HasFiles: false,
+        CommandAuthorized: true,
+        OriginatingChannel: "ozaiya",
+        OriginatingTo: `ozaiya:group:${groupId}`,
+    });
+    await ch.reply.dispatchReplyWithBufferedBlockDispatcher({
+        ctx: msgCtx,
+        cfg,
+        dispatcherOptions: {
+            deliver: async (replyPayload, _info) => {
+                const replyText = replyPayload.text;
+                if (!replyText?.trim() || session.isDisposed)
+                    return;
+                await session.speakReply(replyText);
+            },
+            onError: (err) => {
+                // eslint-disable-next-line no-console
+                console.warn(`ozaiya: phone call auto-reply error: ${String(err)}`);
+            },
+        },
+    });
+}
+/**
+ * Post phone person's transcribed speech to the chat group (manual mode).
+ */
+async function postPhoneTranscriptToChat(text, account, groupId) {
+    try {
+        const groupKey = unwrappedKeys.get(groupId);
+        if (!groupKey)
+            return;
+        const content = {
+            text: `📞 对方说: ${text}`,
+        };
+        const encrypted = encryptMessage(content, groupKey);
+        await sendMessage(account.apiBaseUrl, account.botToken, groupId, encrypted);
+    }
+    catch {
+        // Fire-and-forget
+    }
+}
+/**
+ * Clean up a phone call session: disconnect, end call via API, remove from maps.
+ */
+async function cleanupPhoneCall(phoneCallId, session, account) {
+    activePhoneCalls.delete(phoneCallId);
+    groupToActivePhoneCall.delete(session.groupId);
+    await session.disconnect();
+    await endPhoneCall(account.apiBaseUrl, account.botToken, phoneCallId, session.transcript).catch(() => { });
+}
 /**
  * Handle an inbound webhook message:
  * 1. Decrypt message content
@@ -1552,7 +1998,7 @@ function createListGroupsTool(account) {
 async function handleInboundMessage(payload, 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 ctx) {
-    const { groupId, groupType = "group", message, replyAllowed = true, voiceReply, voiceReplyPrompt, context } = payload;
+    const { groupId, groupType = "group", message, replyAllowed = true, voiceReply, voiceReplyPrompt, voiceReplyVoice, context } = payload;
     const account = ctx.account;
     // Record inbound activity
     recordState(account.accountId, { lastInboundAt: Date.now() });
@@ -1579,6 +2025,20 @@ ctx) {
         return;
     }
     const messageText = normalizeMessageText(content.text);
+    // Manual mode phone call: if this group has an active phone call in manual mode,
+    // speak the user's text message to the phone via TTS instead of dispatching to agent.
+    const activePhoneCallId = groupToActivePhoneCall.get(groupId);
+    if (activePhoneCallId && messageText) {
+        const phoneSession = activePhoneCalls.get(activePhoneCallId);
+        if (phoneSession && phoneSession.mode === "manual" && !phoneSession.isDisposed) {
+            // Don't intercept bot's own messages (transcriptions posted by the bot)
+            if (message.senderId !== account.accountId) {
+                ctx.log?.info?.(`ozaiya: routing user message to active phone call ${activePhoneCallId} (manual mode)`);
+                phoneSession.speakReply(messageText).catch(() => { });
+                return; // Don't dispatch to agent
+            }
+        }
+    }
     const inboundAttachments = normalizeAttachments(content.files);
     const attachmentSummary = buildAttachmentSummary(inboundAttachments);
     const linkPreviewSummary = buildLinkPreviewSummary(content.linkPreviews);
@@ -1756,13 +2216,13 @@ ctx) {
         dispatcherOptions: {
             deliver: async (replyPayload, _info) => {
                 const replyText = replyPayload.text;
-                ctx.log?.info?.(`ozaiya: deliver called, text length=${replyText?.length ?? 0}, empty=${!replyText?.trim()}, voiceReply=${voiceReply}`);
+                ctx.log?.info?.(`ozaiya: deliver called, text length=${replyText?.length ?? 0}, empty=${!replyText?.trim()}, voiceReply=${voiceReply}, voiceReplyVoice=${voiceReplyVoice ?? 'none'}`);
                 if (!replyText?.trim())
                     return;
                 // Voice reply: synthesize TTS audio and send as voice message
                 if (voiceReply) {
                     ctx.log?.info?.(`ozaiya: voice reply — synthesizing TTS for group ${groupId}`);
-                    const audioBuffer = await synthesizeVoiceReply(replyText, ctx);
+                    const audioBuffer = await synthesizeVoiceReply(replyText, ctx, voiceReplyVoice ?? undefined);
                     if (audioBuffer) {
                         const ext = audioBuffer.ext;
                         const mime = ext === ".mp3" ? "audio/mpeg" : ext === ".opus" ? "audio/ogg" : ext === ".wav" ? "audio/wav" : "audio/mpeg";
@@ -1770,7 +2230,7 @@ ctx) {
                         await sendEncryptedChatContent({
                             account,
                             groupId,
-                            content: { files: [fileInfo] },
+                            content: { text: replyText, files: [fileInfo] },
                             log: ctx.log,
                         });
                         ctx.log?.info?.(`ozaiya: voice reply sent successfully (${ext}, ${audioBuffer.data.length} bytes)`);
@@ -2005,12 +2465,20 @@ ctx) {
             id: payload.groupId,
         },
     });
+    // Override per-bot voice config and pass volcengineTts from channel config
+    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: payload.callId,
         groupId: payload.groupId,
         livekitToken: joinResult.token,
         livekitUrl: joinResult.url,
-        voiceCallConfig: voiceCallCfg,
+        voiceCallConfig: effectiveVoiceCallCfg,
         onTranscript: (text) => {
             // Dispatch transcript to agent and speak the reply
             void handleVoiceTranscript(text, session, route, account, ctx);