@poolzin/pool-bot 2026.2.25 → 2026.2.26

package/dist/tts/tts.js

@@ -1,20 +1,18 @@
+import { randomBytes } from "node:crypto";
 import { existsSync, mkdirSync, readFileSync, writeFileSync, mkdtempSync, rmSync, renameSync, unlinkSync, } from "node:fs";
-import { tmpdir } from "node:os";
 import path from "node:path";
-import { completeSimple } from "@mariozechner/pi-ai";
-import { EdgeTTS } from "node-edge-tts";
 import { normalizeChannelId } from "../channels/plugins/index.js";
 import { logVerbose } from "../globals.js";
+import { resolvePreferredPoolbotTmpDir } from "../infra/tmp-poolbot-dir.js";
+import { stripMarkdown } from "../line/markdown-to-line.js";
 import { isVoiceCompatibleAudio } from "../media/audio.js";
 import { CONFIG_DIR, resolveUserPath } from "../utils.js";
-import { getApiKeyForModel, requireApiKey } from "../agents/model-auth.js";
-import { buildModelAliasIndex, resolveDefaultModelForAgent, resolveModelRefFromString, } from "../agents/model-selection.js";
-import { resolveModel } from "../agents/pi-embedded-runner/model.js";
+import { edgeTTS, elevenLabsTTS, inferEdgeExtension, isValidOpenAIModel, isValidOpenAIVoice, isValidVoiceId, OPENAI_TTS_MODELS, OPENAI_TTS_VOICES, openaiTTS, parseTtsDirectives, scheduleCleanup, summarizeText, } from "./tts-core.js";
+export { OPENAI_TTS_MODELS, OPENAI_TTS_VOICES } from "./tts-core.js";
 const DEFAULT_TIMEOUT_MS = 30_000;
 const DEFAULT_TTS_MAX_LENGTH = 1500;
 const DEFAULT_TTS_SUMMARIZE = true;
 const DEFAULT_MAX_TEXT_LENGTH = 4096;
-const TEMP_FILE_CLEANUP_DELAY_MS = 5 * 60 * 1000; // 5 minutes
 const DEFAULT_ELEVENLABS_BASE_URL = "https://api.elevenlabs.io";
 const DEFAULT_ELEVENLABS_VOICE_ID = "pMsXgVXv3BLzUgSXRplE";
 const DEFAULT_ELEVENLABS_MODEL_ID = "eleven_multilingual_v2";
@@ -51,8 +49,9 @@ const TELEPHONY_OUTPUT = {
 const TTS_AUTO_MODES = new Set(["off", "always", "inbound", "tagged"]);
 let lastTtsAttempt;
 export function normalizeTtsAutoMode(value) {
-    if (typeof value !== "string")
+    if (typeof value !== "string") {
         return undefined;
+    }
     const normalized = value.trim().toLowerCase();
     if (TTS_AUTO_MODES.has(normalized)) {
         return normalized;
@@ -73,11 +72,12 @@ function resolveModelOverridePolicy(overrides) {
             allowSeed: false,
         };
     }
-    const allow = (value) => value ?? true;
+    const allow = (value, defaultValue = true) => value ?? defaultValue;
     return {
         enabled: true,
         allowText: allow(overrides?.allowText),
-        allowProvider: allow(overrides?.allowProvider),
+        // Provider switching is higher-impact than voice/style tweaks; keep opt-in.
+        allowProvider: allow(overrides?.allowProvider, false),
         allowVoice: allow(overrides?.allowVoice),
         allowModelId: allow(overrides?.allowModelId),
         allowVoiceSettings: allow(overrides?.allowVoiceSettings),
@@ -139,17 +139,20 @@ export function resolveTtsConfig(cfg) {
     };
 }
 export function resolveTtsPrefsPath(config) {
-    if (config.prefsPath?.trim())
+    if (config.prefsPath?.trim()) {
         return resolveUserPath(config.prefsPath.trim());
-    const envPath = process.env.POOLBOT_TTS_PREFS?.trim() || process.env.CLAWDBOT_TTS_PREFS?.trim();
-    if (envPath)
+    }
+    const envPath = process.env.POOLBOT_TTS_PREFS?.trim();
+    if (envPath) {
         return resolveUserPath(envPath);
+    }
     return path.join(CONFIG_DIR, "settings", "tts.json");
 }
 function resolveTtsAutoModeFromPrefs(prefs) {
     const auto = normalizeTtsAutoMode(prefs.tts?.auto);
-    if (auto)
+    if (auto) {
         return auto;
+    }
     if (typeof prefs.tts?.enabled === "boolean") {
         return prefs.tts.enabled ? "always" : "off";
     }
@@ -157,19 +160,22 @@ function resolveTtsAutoModeFromPrefs(prefs) {
 }
 export function resolveTtsAutoMode(params) {
     const sessionAuto = normalizeTtsAutoMode(params.sessionAuto);
-    if (sessionAuto)
+    if (sessionAuto) {
         return sessionAuto;
+    }
     const prefsAuto = resolveTtsAutoModeFromPrefs(readPrefs(params.prefsPath));
-    if (prefsAuto)
+    if (prefsAuto) {
         return prefsAuto;
+    }
     return params.config.auto;
 }
 export function buildTtsSystemPromptHint(cfg) {
     const config = resolveTtsConfig(cfg);
     const prefsPath = resolveTtsPrefsPath(config);
     const autoMode = resolveTtsAutoMode({ config, prefsPath });
-    if (autoMode === "off")
+    if (autoMode === "off") {
         return undefined;
+    }
     const maxLength = getTtsMaxLength(prefsPath);
     const summarize = isSummarizationEnabled(prefsPath) ? "on" : "off";
     const autoHint = autoMode === "inbound"
@@ -188,8 +194,9 @@ export function buildTtsSystemPromptHint(cfg) {
 }
 function readPrefs(prefsPath) {
     try {
-        if (!existsSync(prefsPath))
+        if (!existsSync(prefsPath)) {
             return {};
+        }
         return JSON.parse(readFileSync(prefsPath, "utf8"));
     }
     catch {
@@ -197,8 +204,8 @@ function readPrefs(prefsPath) {
     }
 }
 function atomicWriteFileSync(filePath, content) {
-    const tmpPath = `${filePath}.tmp.${Date.now()}.${Math.random().toString(36).slice(2)}`;
-    writeFileSync(tmpPath, content);
+    const tmpPath = `${filePath}.tmp.${Date.now()}.${randomBytes(8).toString("hex")}`;
+    writeFileSync(tmpPath, content, { mode: 0o600 });
     try {
         renameSync(tmpPath, filePath);
     }
@@ -234,14 +241,18 @@ export function setTtsEnabled(prefsPath, enabled) {
 }
 export function getTtsProvider(config, prefsPath) {
     const prefs = readPrefs(prefsPath);
-    if (prefs.tts?.provider)
+    if (prefs.tts?.provider) {
         return prefs.tts.provider;
-    if (config.providerSource === "config")
+    }
+    if (config.providerSource === "config") {
         return config.provider;
-    if (resolveTtsApiKey(config, "openai"))
+    }
+    if (resolveTtsApiKey(config, "openai")) {
         return "openai";
-    if (resolveTtsApiKey(config, "elevenlabs"))
+    }
+    if (resolveTtsApiKey(config, "elevenlabs")) {
         return "elevenlabs";
+    }
     return "edge";
 }
 export function setTtsProvider(prefsPath, provider) {
@@ -274,8 +285,9 @@ export function setLastTtsAttempt(entry) {
     lastTtsAttempt = entry;
 }
 function resolveOutputFormat(channelId) {
-    if (channelId === "telegram")
+    if (channelId === "telegram") {
         return TELEGRAM_OUTPUT;
+    }
     return DEFAULT_OUTPUT;
 }
 function resolveChannelId(channel) {
@@ -298,518 +310,17 @@ export function resolveTtsProviderOrder(primary) {
     return [primary, ...TTS_PROVIDERS.filter((provider) => provider !== primary)];
 }
 export function isTtsProviderConfigured(config, provider) {
-    if (provider === "edge")
+    if (provider === "edge") {
         return config.edge.enabled;
-    return Boolean(resolveTtsApiKey(config, provider));
-}
-function isValidVoiceId(voiceId) {
-    return /^[a-zA-Z0-9]{10,40}$/.test(voiceId);
-}
-function normalizeElevenLabsBaseUrl(baseUrl) {
-    const trimmed = baseUrl.trim();
-    if (!trimmed)
-        return DEFAULT_ELEVENLABS_BASE_URL;
-    return trimmed.replace(/\/+$/, "");
-}
-function requireInRange(value, min, max, label) {
-    if (!Number.isFinite(value) || value < min || value > max) {
-        throw new Error(`${label} must be between ${min} and ${max}`);
-    }
-}
-function assertElevenLabsVoiceSettings(settings) {
-    requireInRange(settings.stability, 0, 1, "stability");
-    requireInRange(settings.similarityBoost, 0, 1, "similarityBoost");
-    requireInRange(settings.style, 0, 1, "style");
-    requireInRange(settings.speed, 0.5, 2, "speed");
-}
-function normalizeLanguageCode(code) {
-    const trimmed = code?.trim();
-    if (!trimmed)
-        return undefined;
-    const normalized = trimmed.toLowerCase();
-    if (!/^[a-z]{2}$/.test(normalized)) {
-        throw new Error("languageCode must be a 2-letter ISO 639-1 code (e.g. en, de, fr)");
-    }
-    return normalized;
-}
-function normalizeApplyTextNormalization(mode) {
-    const trimmed = mode?.trim();
-    if (!trimmed)
-        return undefined;
-    const normalized = trimmed.toLowerCase();
-    if (normalized === "auto" || normalized === "on" || normalized === "off")
-        return normalized;
-    throw new Error("applyTextNormalization must be one of: auto, on, off");
-}
-function normalizeSeed(seed) {
-    if (seed == null)
-        return undefined;
-    const next = Math.floor(seed);
-    if (!Number.isFinite(next) || next < 0 || next > 4_294_967_295) {
-        throw new Error("seed must be between 0 and 4294967295");
-    }
-    return next;
-}
-function parseBooleanValue(value) {
-    const normalized = value.trim().toLowerCase();
-    if (["true", "1", "yes", "on"].includes(normalized))
-        return true;
-    if (["false", "0", "no", "off"].includes(normalized))
-        return false;
-    return undefined;
-}
-function parseNumberValue(value) {
-    const parsed = Number.parseFloat(value);
-    return Number.isFinite(parsed) ? parsed : undefined;
-}
-function parseTtsDirectives(text, policy) {
-    if (!policy.enabled) {
-        return { cleanedText: text, overrides: {}, warnings: [], hasDirective: false };
-    }
-    const overrides = {};
-    const warnings = [];
-    let cleanedText = text;
-    let hasDirective = false;
-    const blockRegex = /\[\[tts:text\]\]([\s\S]*?)\[\[\/tts:text\]\]/gi;
-    cleanedText = cleanedText.replace(blockRegex, (_match, inner) => {
-        hasDirective = true;
-        if (policy.allowText && overrides.ttsText == null) {
-            overrides.ttsText = inner.trim();
-        }
-        return "";
-    });
-    const directiveRegex = /\[\[tts:([^\]]+)\]\]/gi;
-    cleanedText = cleanedText.replace(directiveRegex, (_match, body) => {
-        hasDirective = true;
-        const tokens = body.split(/\s+/).filter(Boolean);
-        for (const token of tokens) {
-            const eqIndex = token.indexOf("=");
-            if (eqIndex === -1)
-                continue;
-            const rawKey = token.slice(0, eqIndex).trim();
-            const rawValue = token.slice(eqIndex + 1).trim();
-            if (!rawKey || !rawValue)
-                continue;
-            const key = rawKey.toLowerCase();
-            try {
-                switch (key) {
-                    case "provider":
-                        if (!policy.allowProvider)
-                            break;
-                        if (rawValue === "openai" || rawValue === "elevenlabs" || rawValue === "edge") {
-                            overrides.provider = rawValue;
-                        }
-                        else {
-                            warnings.push(`unsupported provider "${rawValue}"`);
-                        }
-                        break;
-                    case "voice":
-                    case "openai_voice":
-                    case "openaivoice":
-                        if (!policy.allowVoice)
-                            break;
-                        if (isValidOpenAIVoice(rawValue)) {
-                            overrides.openai = { ...overrides.openai, voice: rawValue };
-                        }
-                        else {
-                            warnings.push(`invalid OpenAI voice "${rawValue}"`);
-                        }
-                        break;
-                    case "voiceid":
-                    case "voice_id":
-                    case "elevenlabs_voice":
-                    case "elevenlabsvoice":
-                        if (!policy.allowVoice)
-                            break;
-                        if (isValidVoiceId(rawValue)) {
-                            overrides.elevenlabs = { ...overrides.elevenlabs, voiceId: rawValue };
-                        }
-                        else {
-                            warnings.push(`invalid ElevenLabs voiceId "${rawValue}"`);
-                        }
-                        break;
-                    case "model":
-                    case "modelid":
-                    case "model_id":
-                    case "elevenlabs_model":
-                    case "elevenlabsmodel":
-                    case "openai_model":
-                    case "openaimodel":
-                        if (!policy.allowModelId)
-                            break;
-                        if (isValidOpenAIModel(rawValue)) {
-                            overrides.openai = { ...overrides.openai, model: rawValue };
-                        }
-                        else {
-                            overrides.elevenlabs = { ...overrides.elevenlabs, modelId: rawValue };
-                        }
-                        break;
-                    case "stability":
-                        if (!policy.allowVoiceSettings)
-                            break;
-                        {
-                            const value = parseNumberValue(rawValue);
-                            if (value == null) {
-                                warnings.push("invalid stability value");
-                                break;
-                            }
-                            requireInRange(value, 0, 1, "stability");
-                            overrides.elevenlabs = {
-                                ...overrides.elevenlabs,
-                                voiceSettings: { ...overrides.elevenlabs?.voiceSettings, stability: value },
-                            };
-                        }
-                        break;
-                    case "similarity":
-                    case "similarityboost":
-                    case "similarity_boost":
-                        if (!policy.allowVoiceSettings)
-                            break;
-                        {
-                            const value = parseNumberValue(rawValue);
-                            if (value == null) {
-                                warnings.push("invalid similarityBoost value");
-                                break;
-                            }
-                            requireInRange(value, 0, 1, "similarityBoost");
-                            overrides.elevenlabs = {
-                                ...overrides.elevenlabs,
-                                voiceSettings: { ...overrides.elevenlabs?.voiceSettings, similarityBoost: value },
-                            };
-                        }
-                        break;
-                    case "style":
-                        if (!policy.allowVoiceSettings)
-                            break;
-                        {
-                            const value = parseNumberValue(rawValue);
-                            if (value == null) {
-                                warnings.push("invalid style value");
-                                break;
-                            }
-                            requireInRange(value, 0, 1, "style");
-                            overrides.elevenlabs = {
-                                ...overrides.elevenlabs,
-                                voiceSettings: { ...overrides.elevenlabs?.voiceSettings, style: value },
-                            };
-                        }
-                        break;
-                    case "speed":
-                        if (!policy.allowVoiceSettings)
-                            break;
-                        {
-                            const value = parseNumberValue(rawValue);
-                            if (value == null) {
-                                warnings.push("invalid speed value");
-                                break;
-                            }
-                            requireInRange(value, 0.5, 2, "speed");
-                            overrides.elevenlabs = {
-                                ...overrides.elevenlabs,
-                                voiceSettings: { ...overrides.elevenlabs?.voiceSettings, speed: value },
-                            };
-                        }
-                        break;
-                    case "speakerboost":
-                    case "speaker_boost":
-                    case "usespeakerboost":
-                    case "use_speaker_boost":
-                        if (!policy.allowVoiceSettings)
-                            break;
-                        {
-                            const value = parseBooleanValue(rawValue);
-                            if (value == null) {
-                                warnings.push("invalid useSpeakerBoost value");
-                                break;
-                            }
-                            overrides.elevenlabs = {
-                                ...overrides.elevenlabs,
-                                voiceSettings: { ...overrides.elevenlabs?.voiceSettings, useSpeakerBoost: value },
-                            };
-                        }
-                        break;
-                    case "normalize":
-                    case "applytextnormalization":
-                    case "apply_text_normalization":
-                        if (!policy.allowNormalization)
-                            break;
-                        overrides.elevenlabs = {
-                            ...overrides.elevenlabs,
-                            applyTextNormalization: normalizeApplyTextNormalization(rawValue),
-                        };
-                        break;
-                    case "language":
-                    case "languagecode":
-                    case "language_code":
-                        if (!policy.allowNormalization)
-                            break;
-                        overrides.elevenlabs = {
-                            ...overrides.elevenlabs,
-                            languageCode: normalizeLanguageCode(rawValue),
-                        };
-                        break;
-                    case "seed":
-                        if (!policy.allowSeed)
-                            break;
-                        overrides.elevenlabs = {
-                            ...overrides.elevenlabs,
-                            seed: normalizeSeed(Number.parseInt(rawValue, 10)),
-                        };
-                        break;
-                    default:
-                        break;
-                }
-            }
-            catch (err) {
-                warnings.push(err.message);
-            }
-        }
-        return "";
-    });
-    return {
-        cleanedText,
-        ttsText: overrides.ttsText,
-        hasDirective,
-        overrides,
-        warnings,
-    };
-}
-export const OPENAI_TTS_MODELS = ["gpt-4o-mini-tts", "tts-1", "tts-1-hd"];
-/**
- * Custom OpenAI-compatible TTS endpoint.
- * When set, model/voice validation is relaxed to allow non-OpenAI models.
- * Example: OPENAI_TTS_BASE_URL=http://localhost:8880/v1
- *
- * Note: Read at runtime (not module load) to support config.env loading.
- */
-function getOpenAITtsBaseUrl() {
-    return (process.env.OPENAI_TTS_BASE_URL?.trim() || "https://api.openai.com/v1").replace(/\/+$/, "");
-}
-function isCustomOpenAIEndpoint() {
-    return getOpenAITtsBaseUrl() !== "https://api.openai.com/v1";
-}
-export const OPENAI_TTS_VOICES = [
-    "alloy",
-    "ash",
-    "coral",
-    "echo",
-    "fable",
-    "onyx",
-    "nova",
-    "sage",
-    "shimmer",
-];
-function isValidOpenAIModel(model) {
-    // Allow any model when using custom endpoint (e.g., Kokoro, LocalAI)
-    if (isCustomOpenAIEndpoint())
-        return true;
-    return OPENAI_TTS_MODELS.includes(model);
-}
-function isValidOpenAIVoice(voice) {
-    // Allow any voice when using custom endpoint (e.g., Kokoro Chinese voices)
-    if (isCustomOpenAIEndpoint())
-        return true;
-    return OPENAI_TTS_VOICES.includes(voice);
-}
-function resolveSummaryModelRef(cfg, config) {
-    const defaultRef = resolveDefaultModelForAgent({ cfg });
-    const override = config.summaryModel?.trim();
-    if (!override)
-        return { ref: defaultRef, source: "default" };
-    const aliasIndex = buildModelAliasIndex({ cfg, defaultProvider: defaultRef.provider });
-    const resolved = resolveModelRefFromString({
-        raw: override,
-        defaultProvider: defaultRef.provider,
-        aliasIndex,
-    });
-    if (!resolved)
-        return { ref: defaultRef, source: "default" };
-    return { ref: resolved.ref, source: "summaryModel" };
-}
-function isTextContentBlock(block) {
-    return block.type === "text";
-}
-async function summarizeText(params) {
-    const { text, targetLength, cfg, config, timeoutMs } = params;
-    if (targetLength < 100 || targetLength > 10_000) {
-        throw new Error(`Invalid targetLength: ${targetLength}`);
-    }
-    const startTime = Date.now();
-    const { ref } = resolveSummaryModelRef(cfg, config);
-    const resolved = resolveModel(ref.provider, ref.model, undefined, cfg);
-    if (!resolved.model) {
-        throw new Error(resolved.error ?? `Unknown summary model: ${ref.provider}/${ref.model}`);
-    }
-    const apiKey = requireApiKey(await getApiKeyForModel({ model: resolved.model, cfg }), ref.provider);
-    try {
-        const controller = new AbortController();
-        const timeout = setTimeout(() => controller.abort(), timeoutMs);
-        try {
-            const res = await completeSimple(resolved.model, {
-                messages: [
-                    {
-                        role: "user",
-                        content: `You are an assistant that summarizes texts concisely while keeping the most important information. ` +
-                            `Summarize the text to approximately ${targetLength} characters. Maintain the original tone and style. ` +
-                            `Reply only with the summary, without additional explanations.\n\n` +
-                            `<text_to_summarize>\n${text}\n</text_to_summarize>`,
-                        timestamp: Date.now(),
-                    },
-                ],
-            }, {
-                apiKey,
-                maxTokens: Math.ceil(targetLength / 2),
-                temperature: 0.3,
-                signal: controller.signal,
-            });
-            const summary = res.content
-                .filter(isTextContentBlock)
-                .map((block) => block.text.trim())
-                .filter(Boolean)
-                .join(" ")
-                .trim();
-            if (!summary) {
-                throw new Error("No summary returned");
-            }
-            return {
-                summary,
-                latencyMs: Date.now() - startTime,
-                inputLength: text.length,
-                outputLength: summary.length,
-            };
-        }
-        finally {
-            clearTimeout(timeout);
-        }
-    }
-    catch (err) {
-        const error = err;
-        if (error.name === "AbortError") {
-            throw new Error("Summarization timed out", { cause: err });
-        }
-        throw err;
-    }
-}
-function scheduleCleanup(tempDir, delayMs = TEMP_FILE_CLEANUP_DELAY_MS) {
-    const timer = setTimeout(() => {
-        try {
-            rmSync(tempDir, { recursive: true, force: true });
-        }
-        catch {
-            // ignore cleanup errors
-        }
-    }, delayMs);
-    timer.unref();
-}
-async function elevenLabsTTS(params) {
-    const { text, apiKey, baseUrl, voiceId, modelId, outputFormat, seed, applyTextNormalization, languageCode, voiceSettings, timeoutMs, } = params;
-    if (!isValidVoiceId(voiceId)) {
-        throw new Error("Invalid voiceId format");
-    }
-    assertElevenLabsVoiceSettings(voiceSettings);
-    const normalizedLanguage = normalizeLanguageCode(languageCode);
-    const normalizedNormalization = normalizeApplyTextNormalization(applyTextNormalization);
-    const normalizedSeed = normalizeSeed(seed);
-    const controller = new AbortController();
-    const timeout = setTimeout(() => controller.abort(), timeoutMs);
-    try {
-        const url = new URL(`${normalizeElevenLabsBaseUrl(baseUrl)}/v1/text-to-speech/${voiceId}`);
-        if (outputFormat) {
-            url.searchParams.set("output_format", outputFormat);
-        }
-        const response = await fetch(url.toString(), {
-            method: "POST",
-            headers: {
-                "xi-api-key": apiKey,
-                "Content-Type": "application/json",
-                Accept: "audio/mpeg",
-            },
-            body: JSON.stringify({
-                text,
-                model_id: modelId,
-                seed: normalizedSeed,
-                apply_text_normalization: normalizedNormalization,
-                language_code: normalizedLanguage,
-                voice_settings: {
-                    stability: voiceSettings.stability,
-                    similarity_boost: voiceSettings.similarityBoost,
-                    style: voiceSettings.style,
-                    use_speaker_boost: voiceSettings.useSpeakerBoost,
-                    speed: voiceSettings.speed,
-                },
-            }),
-            signal: controller.signal,
-        });
-        if (!response.ok) {
-            throw new Error(`ElevenLabs API error (${response.status})`);
-        }
-        return Buffer.from(await response.arrayBuffer());
-    }
-    finally {
-        clearTimeout(timeout);
-    }
-}
-async function openaiTTS(params) {
-    const { text, apiKey, model, voice, responseFormat, timeoutMs } = params;
-    if (!isValidOpenAIModel(model)) {
-        throw new Error(`Invalid model: ${model}`);
-    }
-    if (!isValidOpenAIVoice(voice)) {
-        throw new Error(`Invalid voice: ${voice}`);
-    }
-    const controller = new AbortController();
-    const timeout = setTimeout(() => controller.abort(), timeoutMs);
-    try {
-        const response = await fetch(`${getOpenAITtsBaseUrl()}/audio/speech`, {
-            method: "POST",
-            headers: {
-                Authorization: `Bearer ${apiKey}`,
-                "Content-Type": "application/json",
-            },
-            body: JSON.stringify({
-                model,
-                input: text,
-                voice,
-                response_format: responseFormat,
-            }),
-            signal: controller.signal,
-        });
-        if (!response.ok) {
-            throw new Error(`OpenAI TTS API error (${response.status})`);
-        }
-        return Buffer.from(await response.arrayBuffer());
-    }
-    finally {
-        clearTimeout(timeout);
     }
+    return Boolean(resolveTtsApiKey(config, provider));
 }
-function inferEdgeExtension(outputFormat) {
-    const normalized = outputFormat.toLowerCase();
-    if (normalized.includes("webm"))
-        return ".webm";
-    if (normalized.includes("ogg"))
-        return ".ogg";
-    if (normalized.includes("opus"))
-        return ".opus";
-    if (normalized.includes("wav") || normalized.includes("riff") || normalized.includes("pcm")) {
-        return ".wav";
+function formatTtsProviderError(provider, err) {
+    const error = err instanceof Error ? err : new Error(String(err));
+    if (error.name === "AbortError") {
+        return `${provider}: request timed out`;
     }
-    return ".mp3";
-}
-async function edgeTTS(params) {
-    const { text, outputPath, config, timeoutMs } = params;
-    const tts = new EdgeTTS({
-        voice: config.voice,
-        lang: config.lang,
-        outputFormat: config.outputFormat,
-        saveSubtitles: config.saveSubtitles,
-        proxy: config.proxy,
-        rate: config.rate,
-        pitch: config.pitch,
-        volume: config.volume,
-        timeout: config.timeoutMs ?? timeoutMs,
-    });
-    await tts.ttsPromise(text, outputPath);
+    return `${provider}: ${error.message}`;
 }
 export async function textToSpeech(params) {
     const config = resolveTtsConfig(params.cfg);
@@ -826,16 +337,18 @@ export async function textToSpeech(params) {
     const overrideProvider = params.overrides?.provider;
     const provider = overrideProvider ?? userProvider;
     const providers = resolveTtsProviderOrder(provider);
-    let lastError;
+    const errors = [];
     for (const provider of providers) {
         const providerStart = Date.now();
         try {
             if (provider === "edge") {
                 if (!config.edge.enabled) {
-                    lastError = "edge: disabled";
+                    errors.push("edge: disabled");
                     continue;
                 }
-                const tempDir = mkdtempSync(path.join(tmpdir(), "tts-"));
+                const tempRoot = resolvePreferredPoolbotTmpDir();
+                mkdirSync(tempRoot, { recursive: true, mode: 0o700 });
+                const tempDir = mkdtempSync(path.join(tempRoot, "tts-"));
                 let edgeOutputFormat = resolveEdgeOutputFormat(config);
                 const fallbackEdgeOutputFormat = edgeOutputFormat !== DEFAULT_EDGE_OUTPUT_FORMAT ? DEFAULT_EDGE_OUTPUT_FORMAT : undefined;
                 const attemptEdgeTts = async (outputFormat) => {
@@ -896,7 +409,7 @@ export async function textToSpeech(params) {
             }
             const apiKey = resolveTtsApiKey(config, provider);
             if (!apiKey) {
-                lastError = `No API key for ${provider}`;
+                errors.push(`${provider}: no API key`);
                 continue;
             }
             let audioBuffer;
@@ -937,7 +450,9 @@ export async function textToSpeech(params) {
                 });
             }
             const latencyMs = Date.now() - providerStart;
-            const tempDir = mkdtempSync(path.join(tmpdir(), "tts-"));
+            const tempRoot = resolvePreferredPoolbotTmpDir();
+            mkdirSync(tempRoot, { recursive: true, mode: 0o700 });
+            const tempDir = mkdtempSync(path.join(tempRoot, "tts-"));
             const audioPath = path.join(tempDir, `voice-${Date.now()}${output.extension}`);
             writeFileSync(audioPath, audioBuffer);
             scheduleCleanup(tempDir);
@@ -951,18 +466,12 @@ export async function textToSpeech(params) {
             };
         }
         catch (err) {
-            const error = err;
-            if (error.name === "AbortError") {
-                lastError = `${provider}: request timed out`;
-            }
-            else {
-                lastError = `${provider}: ${error.message}`;
-            }
+            errors.push(formatTtsProviderError(provider, err));
         }
     }
     return {
         success: false,
-        error: `TTS conversion failed: ${lastError || "no providers available"}`,
+        error: `TTS conversion failed: ${errors.join("; ") || "no providers available"}`,
     };
 }
 export async function textToSpeechTelephony(params) {
@@ -976,17 +485,17 @@ export async function textToSpeechTelephony(params) {
     }
     const userProvider = getTtsProvider(config, prefsPath);
     const providers = resolveTtsProviderOrder(userProvider);
-    let lastError;
+    const errors = [];
     for (const provider of providers) {
         const providerStart = Date.now();
         try {
             if (provider === "edge") {
-                lastError = "edge: unsupported for telephony";
+                errors.push("edge: unsupported for telephony");
                 continue;
             }
             const apiKey = resolveTtsApiKey(config, provider);
             if (!apiKey) {
-                lastError = `No API key for ${provider}`;
+                errors.push(`${provider}: no API key`);
                 continue;
             }
             if (provider === "elevenlabs") {
@@ -1032,18 +541,12 @@ export async function textToSpeechTelephony(params) {
             };
         }
         catch (err) {
-            const error = err;
-            if (error.name === "AbortError") {
-                lastError = `${provider}: request timed out`;
-            }
-            else {
-                lastError = `${provider}: ${error.message}`;
-            }
+            errors.push(formatTtsProviderError(provider, err));
         }
     }
     return {
         success: false,
-        error: `TTS conversion failed: ${lastError || "no providers available"}`,
+        error: `TTS conversion failed: ${errors.join("; ") || "no providers available"}`,
     };
 }
 export async function maybeApplyTtsToPayload(params) {
@@ -1054,8 +557,9 @@ export async function maybeApplyTtsToPayload(params) {
         prefsPath,
         sessionAuto: params.ttsAuto,
     });
-    if (autoMode === "off")
+    if (autoMode === "off") {
         return params.payload;
+    }
     const text = params.payload.text ?? "";
     const directives = parseTtsDirectives(text, config.modelOverrides);
     if (directives.warnings.length > 0) {
@@ -1071,32 +575,37 @@ export async function maybeApplyTtsToPayload(params) {
             ...params.payload,
             text: visibleText.length > 0 ? visibleText : undefined,
         };
-    if (autoMode === "tagged" && !directives.hasDirective)
+    if (autoMode === "tagged" && !directives.hasDirective) {
         return nextPayload;
-    if (autoMode === "inbound" && params.inboundAudio !== true)
+    }
+    if (autoMode === "inbound" && params.inboundAudio !== true) {
         return nextPayload;
+    }
     const mode = config.mode ?? "final";
-    if (mode === "final" && params.kind && params.kind !== "final")
+    if (mode === "final" && params.kind && params.kind !== "final") {
         return nextPayload;
-    if (!ttsText.trim())
+    }
+    if (!ttsText.trim()) {
         return nextPayload;
-    if (params.payload.mediaUrl || (params.payload.mediaUrls?.length ?? 0) > 0)
+    }
+    if (params.payload.mediaUrl || (params.payload.mediaUrls?.length ?? 0) > 0) {
         return nextPayload;
-    if (text.includes("MEDIA:"))
+    }
+    if (text.includes("MEDIA:")) {
         return nextPayload;
-    if (ttsText.trim().length < 10)
+    }
+    if (ttsText.trim().length < 10) {
         return nextPayload;
+    }
     const maxLength = getTtsMaxLength(prefsPath);
     let textForAudio = ttsText.trim();
     let wasSummarized = false;
     if (textForAudio.length > maxLength) {
         if (!isSummarizationEnabled(prefsPath)) {
-            // Truncate text when summarization is disabled
             logVerbose(`TTS: truncating long text (${textForAudio.length} > ${maxLength}), summarization disabled.`);
             textForAudio = `${textForAudio.slice(0, maxLength - 3)}...`;
         }
         else {
-            // Summarize text when enabled
             try {
                 const summary = await summarizeText({
                     text: textForAudio,
@@ -1119,6 +628,10 @@ export async function maybeApplyTtsToPayload(params) {
             }
         }
     }
+    textForAudio = stripMarkdown(textForAudio).trim(); // strip markdown for TTS (### → "hashtag" etc.)
+    if (textForAudio.length < 10) {
+        return nextPayload;
+    }
     const ttsStart = Date.now();
     const result = await textToSpeech({
         text: textForAudio,