@markusylisiurunen/tau 0.3.76 → 0.3.77

package/dist/core/utils/{gemini_speech.js → speech.js}

@@ -1,14 +1,16 @@
 import { z } from "zod";
-const GEMINI_GENERATE_CONTENT_BASE_URL = "https://generativelanguage.googleapis.com/v1beta/models";
-export const GEMINI_SPEECH_PLAYBACK_RATE = 1.15;
-const DEFAULT_GEMINI_SPEECH_REWRITE_MODEL = "gemini-3.8-flash";
-const DEFAULT_GEMINI_SPEECH_REWRITE_THINKING_LEVEL = "low";
-const DEFAULT_GEMINI_SPEECH_TTS_MODEL = "gemini-3.1-flash-tts-preview";
-const DEFAULT_GEMINI_TTS_VOICE_NAME = "Despina";
-export const GEMINI_SPEECH_SAMPLE_RATE_HZ = 24000;
-export const GEMINI_SPEECH_CHANNEL_COUNT = 1;
-export const GEMINI_SPEECH_BITS_PER_SAMPLE = 16;
-const DEFAULT_TTS_MAX_ATTEMPTS = 3;
+const OPENAI_RESPONSES_URL = "https://api.openai.com/v1/responses";
+export const SPEECH_PLAYBACK_RATE = 1.15;
+const SPEECH_REWRITE_MODEL = "gpt-6-luna";
+const ELEVENLABS_BASE_URL = "https://api.elevenlabs.io/v1";
+const SPEECH_MODEL = "eleven_v4_turbo";
+const DEFAULT_VOICE_ID = "QtY3JBOUKEB5xzrRfOKc";
+const FALLBACK_VOICE_ID = "AaOhDHYJ1XLZk74lXhdE";
+const SPEECH_DELIVERY_NOTE = "[Brisk but relaxed, speaking naturally to a colleague] ";
+const SPEECH_REQUEST_TIMEOUT_MS = 120_000;
+export const SPEECH_SAMPLE_RATE_HZ = 24000;
+export const SPEECH_CHANNEL_COUNT = 1;
+export const SPEECH_BITS_PER_SAMPLE = 16;
 const SPEECH_REWRITE_TIMEOUT_MS = 60_000;
 const COMPLETE_TTS_CONCURRENCY = 3;
 const MAX_SPEECH_SEGMENT_SECONDS = 120;
@@ -17,42 +19,18 @@ const MAX_SPEECH_SEGMENT_WEIGHT = MAX_SPEECH_SEGMENT_SECONDS * ESTIMATED_SPEECH_
 const MAX_SPEECH_SOURCE_CHARACTERS = 10_000;
 const MAX_SPOKEN_TEXT_CHARACTERS = 10_000;
 const MAX_SPEECH_PCM_BYTES = 32 * 1024 * 1024;
-const TTS_MAX_OUTPUT_TOKENS = 8192;
-const RETRYABLE_TTS_STATUS_CODES = new Set([408, 429, 500, 502, 503, 504]);
 const errorPayloadSchema = z.object({
     error: z
         .object({
         message: z.string().trim().min(1).optional(),
-        status: z.string().trim().min(1).optional(),
-        code: z.number().int().optional(),
     })
         .optional(),
 });
-class GeminiApiError extends Error {
-    status;
-    constructor(message, status) {
-        super(message);
-        this.name = "GeminiApiError";
-        this.status = status;
-    }
-}
-class GeminiTtsResponseError extends Error {
-    constructor(message) {
-        super(message);
-        this.name = "GeminiTtsResponseError";
-    }
-}
-class GeminiTtsOutputLimitError extends Error {
-    constructor() {
-        super("Gemini TTS reached its output token limit");
-        this.name = "GeminiTtsOutputLimitError";
-    }
-}
-export async function* generateGeminiSpeechAudio(options) {
+export async function* generateSpeechAudio(options) {
     const abortController = createLinkedAbortController(options.signal);
     let completed = false;
     try {
-        const prepared = await prepareGeminiSpeech(options, abortController.signal);
+        const prepared = await prepareSpeech(options, abortController.signal);
         for await (const chunk of synthesizeSpeechAudioSegmentsInOrder({
             ...prepared,
             signal: abortController.signal,
@@ -65,9 +43,9 @@ export async function* generateGeminiSpeechAudio(options) {
                 total: prepared.spokenSegments.length,
                 audio: encodeWaveFile({
                     pcmAudio: chunk.pcmAudio,
-                    sampleRateHz: GEMINI_SPEECH_SAMPLE_RATE_HZ,
-                    channelCount: GEMINI_SPEECH_CHANNEL_COUNT,
-                    bitsPerSample: GEMINI_SPEECH_BITS_PER_SAMPLE,
+                    sampleRateHz: SPEECH_SAMPLE_RATE_HZ,
+                    channelCount: SPEECH_CHANNEL_COUNT,
+                    bitsPerSample: SPEECH_BITS_PER_SAMPLE,
                 }),
                 mimeType: "audio/wav",
             };
@@ -81,12 +59,12 @@ export async function* generateGeminiSpeechAudio(options) {
         abortController.dispose();
     }
 }
-export async function* streamGeminiSpeechPcm(options) {
+export async function* streamSpeechPcm(options) {
     const abortController = createLinkedAbortController(options.signal);
     let completed = false;
     let totalPcmBytes = 0;
     try {
-        const prepared = await prepareGeminiSpeech(options, abortController.signal);
+        const prepared = await prepareSpeech(options, abortController.signal);
         const total = prepared.spokenSegments.length;
         const accountAudio = (audio) => {
             totalPcmBytes += audio.length;
@@ -101,23 +79,16 @@ export async function* streamGeminiSpeechPcm(options) {
             accountAudio,
         }).then((audio) => ({ audio }), (error) => ({ error }));
         let ready = 0;
-        const firstStream = streamSpeechSegmentWithRetries({
+        const firstStream = streamSpeechSegment({
             ...prepared,
             spokenText: prepared.spokenSegments[0],
             signal: abortController.signal,
             initialBufferBytes: Math.max(0, Math.trunc(options.initialBufferBytes ?? 0)),
         });
-        const firstIterator = firstStream[Symbol.asyncIterator]();
-        let nextAudio = firstIterator.next();
         let prefetched = total > 1 ? prefetch(1) : undefined;
-        while (true) {
-            const next = await nextAudio;
-            if (next.done) {
-                break;
-            }
-            accountAudio(next.value);
-            yield { index: 0, total, audio: next.value };
-            nextAudio = firstIterator.next();
+        for await (const audio of firstStream) {
+            accountAudio(audio);
+            yield { index: 0, total, audio };
         }
         ready += 1;
         await options.onSegmentProgress?.({ ready, total });
@@ -126,7 +97,7 @@ export async function* streamGeminiSpeechPcm(options) {
             if ("error" in outcome) {
                 throw outcome.error instanceof Error
                     ? outcome.error
-                    : new Error("Gemini TTS request failed");
+                    : new Error("ElevenLabs speech request failed");
             }
             prefetched = index + 1 < total ? prefetch(index + 1) : undefined;
             yield { index, total, audio: outcome.audio };
@@ -142,7 +113,7 @@ export async function* streamGeminiSpeechPcm(options) {
         abortController.dispose();
     }
 }
-async function prepareGeminiSpeech(options, signal) {
+async function prepareSpeech(options, signal) {
     const sourceText = options.sourceText.trim();
     if (!sourceText) {
         throw new Error("speech source text was empty");
@@ -150,9 +121,13 @@ async function prepareGeminiSpeech(options, signal) {
     if (exceedsUnicodeCharacterLimit(sourceText, MAX_SPEECH_SOURCE_CHARACTERS)) {
         throw new Error("speech source text exceeds 10,000 characters");
     }
-    const apiKey = options.apiKey.trim();
-    if (!apiKey) {
-        throw new Error("missing Gemini API key");
+    const apiKey = options.elevenLabsApiKey.trim();
+    const openAIApiKey = options.openAIApiKey.trim();
+    if (!apiKey || !openAIApiKey) {
+        throw new Error("OpenAI and ElevenLabs API keys are required for speech");
+    }
+    if (options.voiceId !== undefined && !options.voiceId.trim()) {
+        throw new Error("speech voice ID must not be empty");
     }
     const fetchImpl = options.fetchImpl ?? fetch;
     await options.onStageChange?.("rewriting");
@@ -162,8 +137,7 @@ async function prepareGeminiSpeech(options, signal) {
     let spokenText;
     try {
         spokenText = await rewriteTextForSpeech({
-            apiKey,
-            model: options.rewriteModel ?? DEFAULT_GEMINI_SPEECH_REWRITE_MODEL,
+            apiKey: openAIApiKey,
             sourceText,
             fetchImpl,
             signal: rewriteController.signal,
@@ -184,43 +158,62 @@ async function prepareGeminiSpeech(options, signal) {
     }
     const spokenSegments = splitSpeechSegments(spokenText);
     await options.onStageChange?.("generating");
+    const voiceId = await resolveSpeechVoice({
+        apiKey,
+        voiceId: options.voiceId,
+        fetchImpl,
+        signal,
+    });
     await options.onSegmentProgress?.({ ready: 0, total: spokenSegments.length });
     return {
         apiKey,
-        model: options.ttsModel ?? DEFAULT_GEMINI_SPEECH_TTS_MODEL,
-        voiceName: options.voiceName ?? DEFAULT_GEMINI_TTS_VOICE_NAME,
+        voiceId,
         spokenSegments,
         fetchImpl,
-        maxAttempts: options.maxTtsAttempts ?? DEFAULT_TTS_MAX_ATTEMPTS,
     };
 }
 async function rewriteTextForSpeech(args) {
-    const payload = await requestGeminiGenerateContent({
-        apiKey: args.apiKey,
-        model: args.model,
-        fetchImpl: args.fetchImpl,
-        signal: args.signal,
-        body: {
-            contents: [
-                {
-                    parts: [
-                        {
-                            text: buildSpeechRewritePrompt(args.sourceText),
-                        },
-                    ],
-                },
-            ],
-            generationConfig: {
-                thinkingConfig: {
-                    thinkingLevel: DEFAULT_GEMINI_SPEECH_REWRITE_THINKING_LEVEL,
-                },
-            },
+    const response = await args.fetchImpl(OPENAI_RESPONSES_URL, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${args.apiKey}`,
         },
+        body: JSON.stringify({
+            model: SPEECH_REWRITE_MODEL,
+            input: buildSpeechRewritePrompt(args.sourceText),
+            reasoning: { effort: "none" },
+            store: false,
+        }),
+        signal: args.signal,
     });
-    const rewrittenText = extractGeminiText(payload).trim();
-    if (!rewrittenText) {
-        throw new Error("Gemini rewrite returned empty text");
+    const payload = await response.json();
+    if (!response.ok) {
+        const parsed = errorPayloadSchema.safeParse(payload);
+        throw new Error(parsed.success && parsed.data.error?.message
+            ? parsed.data.error.message
+            : `OpenAI speech rewrite failed (HTTP ${response.status})`);
+    }
+    if (!isObject(payload) || payload.status !== "completed" || !Array.isArray(payload.output)) {
+        throw new Error("OpenAI speech rewrite did not complete");
+    }
+    const text = [];
+    for (const item of payload.output) {
+        if (!isObject(item) || item.type !== "message")
+            continue;
+        if (item.status !== "completed" || !Array.isArray(item.content)) {
+            throw new Error("OpenAI speech rewrite returned an incomplete message");
+        }
+        for (const part of item.content) {
+            if (!isObject(part) || part.type !== "output_text" || typeof part.text !== "string") {
+                throw new Error("OpenAI speech rewrite did not return text");
+            }
+            text.push(part.text);
+        }
     }
+    const rewrittenText = text.join("").trim();
+    if (!rewrittenText)
+        throw new Error("OpenAI speech rewrite returned empty text");
     return rewrittenText;
 }
 async function* synthesizeSpeechAudioSegmentsInOrder(args) {
@@ -299,7 +292,7 @@ async function* synthesizeSpeechAudioSegmentsInOrder(args) {
                 continue;
             }
             if (failure !== undefined) {
-                throw failure instanceof Error ? failure : new Error("Gemini TTS request failed");
+                throw failure instanceof Error ? failure : new Error("ElevenLabs speech request failed");
             }
             await waitForWake();
         }
@@ -310,323 +303,120 @@ async function* synthesizeSpeechAudioSegmentsInOrder(args) {
     }
 }
 async function synthesizeSpeechAudioSegment(args) {
-    const maxAttempts = Math.max(1, Math.trunc(args.maxAttempts));
-    let lastError;
-    for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
-        try {
-            const payload = await requestGeminiGenerateContent({
-                apiKey: args.apiKey,
-                model: args.model,
-                fetchImpl: args.fetchImpl,
-                signal: args.signal,
-                body: buildSpeechSynthesisRequest(args.spokenText, args.voiceName),
-            });
-            assertGeminiTtsCompleted(payload);
-            const audioData = extractGeminiInlineAudioData(payload);
-            if (!audioData) {
-                throw new GeminiTtsResponseError("Gemini TTS response did not include audio data");
+    const chunks = [];
+    for await (const audio of requestSpeechStream(args)) {
+        chunks.push(audio);
+    }
+    return Buffer.concat(chunks);
+}
+async function* streamSpeechSegment(args) {
+    const bufferedAudio = [];
+    let bufferedAudioBytes = 0;
+    let emittedAudio = false;
+    for await (const audio of requestSpeechStream(args)) {
+        if (!emittedAudio) {
+            bufferedAudio.push(audio);
+            bufferedAudioBytes += audio.length;
+            if (bufferedAudioBytes < args.initialBufferBytes) {
+                continue;
             }
-            return Buffer.from(audioData, "base64");
+            emittedAudio = true;
+            yield Buffer.concat(bufferedAudio);
+            bufferedAudio.length = 0;
         }
-        catch (error) {
-            lastError = error;
-            if (args.signal?.aborted || !isRetryableTtsError(error) || attempt >= maxAttempts) {
-                throw error;
-            }
-            await waitForRetryDelay(attempt, args.signal);
+        else {
+            yield audio;
         }
     }
-    throw lastError instanceof Error ? lastError : new Error("Gemini TTS request failed");
-}
-async function* streamSpeechSegmentWithRetries(args) {
-    const maxAttempts = Math.max(1, Math.trunc(args.maxAttempts));
-    let lastError;
-    for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
-        const bufferedAudio = [];
-        let bufferedAudioBytes = 0;
-        let emittedAudio = false;
-        try {
-            for await (const audio of requestGeminiSpeechStream(args)) {
-                if (!emittedAudio && bufferedAudioBytes < args.initialBufferBytes) {
-                    bufferedAudio.push(audio);
-                    bufferedAudioBytes += audio.length;
-                    if (bufferedAudioBytes < args.initialBufferBytes) {
-                        continue;
-                    }
-                    emittedAudio = true;
-                    yield Buffer.concat(bufferedAudio);
-                    continue;
-                }
-                emittedAudio = true;
-                yield audio;
-            }
-            if (bufferedAudio.length > 0 && !emittedAudio) {
-                emittedAudio = true;
-                yield Buffer.concat(bufferedAudio);
-            }
-            return;
-        }
-        catch (error) {
-            lastError = error;
-            if (emittedAudio ||
-                args.signal?.aborted ||
-                !isRetryableTtsError(error) ||
-                attempt >= maxAttempts) {
-                throw error;
-            }
-            await waitForRetryDelay(attempt, args.signal);
-        }
+    if (!emittedAudio && bufferedAudio.length > 0) {
+        yield Buffer.concat(bufferedAudio);
     }
-    throw lastError instanceof Error ? lastError : new Error("Gemini TTS request failed");
 }
 async function collectStreamingSpeechSegment(args) {
-    const maxAttempts = Math.max(1, Math.trunc(args.maxAttempts));
-    let lastError;
-    for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
-        const chunks = [];
-        try {
-            for await (const audio of requestGeminiSpeechStream(args)) {
-                chunks.push(audio);
-            }
-        }
-        catch (error) {
-            lastError = error;
-            if (args.signal?.aborted || !isRetryableTtsError(error) || attempt >= maxAttempts) {
-                throw error;
-            }
-            await waitForRetryDelay(attempt, args.signal);
-            continue;
-        }
-        const audio = Buffer.concat(chunks);
+    const chunks = [];
+    for await (const audio of requestSpeechStream(args)) {
         args.accountAudio(audio);
-        return audio;
+        chunks.push(audio);
     }
-    throw lastError instanceof Error ? lastError : new Error("Gemini TTS request failed");
+    return Buffer.concat(chunks);
 }
-async function* requestGeminiSpeechStream(args) {
-    const response = await requestGeminiResponse({
-        apiKey: args.apiKey,
-        model: args.model,
-        method: "streamGenerateContent?alt=sse",
-        fetchImpl: args.fetchImpl,
-        signal: args.signal,
-        body: buildSpeechSynthesisRequest(args.spokenText, args.voiceName),
-    });
-    if (!response.body) {
-        throw new GeminiTtsResponseError("Gemini TTS streaming response did not include a body");
-    }
-    let receivedAudio = false;
-    let completed = false;
-    for await (const payload of parseGeminiSse(response.body)) {
-        const finishReason = getGeminiFinishReason(payload);
-        if (finishReason) {
-            assertGeminiTtsFinishReason(finishReason);
-            completed = finishReason === "STOP";
+async function resolveSpeechVoice(args) {
+    const voiceIds = args.voiceId === undefined ? [DEFAULT_VOICE_ID, FALLBACK_VOICE_ID] : [args.voiceId.trim()];
+    for (const voiceId of voiceIds) {
+        const response = await args.fetchImpl(`${ELEVENLABS_BASE_URL}/voices/${encodeURIComponent(voiceId)}`, {
+            headers: { "xi-api-key": args.apiKey },
+            signal: AbortSignal.any([args.signal, AbortSignal.timeout(SPEECH_REQUEST_TIMEOUT_MS)]),
+        });
+        if (response.ok) {
+            const payload = await response.json();
+            if (!isObject(payload) || payload.voice_id !== voiceId) {
+                throw new Error("ElevenLabs returned invalid voice metadata");
+            }
+            return voiceId;
         }
-        for (const audioData of extractGeminiInlineAudioDataParts(payload)) {
-            receivedAudio = true;
-            yield Buffer.from(audioData, "base64");
+        const payload = await response.json().catch(() => undefined);
+        const detail = isObject(payload) && isObject(payload.detail) ? payload.detail : undefined;
+        const unavailable = (response.status === 400 || response.status === 404) && detail?.status === "voice_not_found";
+        if (!unavailable) {
+            throw new Error(`ElevenLabs voice lookup failed (HTTP ${response.status})`);
         }
     }
-    if (!receivedAudio) {
-        throw new GeminiTtsResponseError("Gemini TTS response did not include audio data");
-    }
-    if (!completed) {
-        throw new GeminiTtsResponseError("Gemini TTS stream ended without a stop response");
-    }
+    throw new Error(args.voiceId === undefined
+        ? "Neither Maisie nor Caleb is available from ElevenLabs"
+        : "The configured ElevenLabs speech voice is unavailable");
 }
-function buildSpeechSynthesisRequest(spokenText, voiceName) {
-    return {
-        contents: [
-            {
-                parts: [
-                    {
-                        text: buildSpeechSynthesisPrompt(spokenText),
-                    },
-                ],
-            },
-        ],
-        generationConfig: {
-            responseModalities: ["AUDIO"],
-            maxOutputTokens: TTS_MAX_OUTPUT_TOKENS,
-            speechConfig: {
-                voiceConfig: {
-                    prebuiltVoiceConfig: {
-                        voiceName,
-                    },
-                },
-            },
-        },
-    };
-}
-async function requestGeminiGenerateContent(args) {
-    const response = await requestGeminiResponse({ ...args, method: "generateContent" });
-    const responseText = await response.text();
-    try {
-        return responseText ? JSON.parse(responseText) : undefined;
-    }
-    catch {
-        return undefined;
-    }
-}
-async function requestGeminiResponse(args) {
-    const response = await args.fetchImpl(`${GEMINI_GENERATE_CONTENT_BASE_URL}/${encodeURIComponent(args.model)}:${args.method}`, {
+async function* requestSpeechStream(args) {
+    const timeout = AbortSignal.timeout(SPEECH_REQUEST_TIMEOUT_MS);
+    const signal = args.signal ? AbortSignal.any([args.signal, timeout]) : timeout;
+    const response = await args.fetchImpl(`${ELEVENLABS_BASE_URL}/text-to-speech/${encodeURIComponent(args.voiceId)}/stream?output_format=pcm_24000`, {
         method: "POST",
-        headers: {
-            "Content-Type": "application/json",
-            "x-goog-api-key": args.apiKey,
-        },
-        body: JSON.stringify(args.body),
-        signal: args.signal,
+        headers: { "Content-Type": "application/json", "xi-api-key": args.apiKey },
+        body: JSON.stringify({
+            model_id: SPEECH_MODEL,
+            text: SPEECH_DELIVERY_NOTE + args.spokenText,
+        }),
+        signal,
     });
-    if (response.ok) {
-        return response;
-    }
-    const responseText = await response.text();
-    let payload;
-    try {
-        payload = responseText ? JSON.parse(responseText) : undefined;
-    }
-    catch {
-        payload = undefined;
-    }
-    const parsed = errorPayloadSchema.safeParse(payload);
-    const fallbackMessage = responseText.trim() || `HTTP ${response.status}`;
-    const message = parsed.success
-        ? (parsed.data.error?.message ?? fallbackMessage)
-        : fallbackMessage;
-    throw new GeminiApiError(message, response.status);
-}
-async function* parseGeminiSse(body) {
-    const reader = body.getReader();
-    const decoder = new TextDecoder();
-    let buffered = "";
+    if (!response.ok) {
+        await response.body?.cancel();
+        throw new Error(`ElevenLabs speech generation failed (HTTP ${response.status})`);
+    }
+    const contentType = response.headers.get("content-type")?.split(";")[0]?.trim();
+    if (contentType !== "audio/pcm" || !response.body) {
+        await response.body?.cancel();
+        throw new Error("ElevenLabs speech response did not include PCM audio");
+    }
+    const reader = response.body.getReader();
+    let totalBytes = 0;
+    let pendingByte = Buffer.alloc(0);
     let completed = false;
     try {
         while (true) {
+            signal.throwIfAborted();
             const { done, value } = await reader.read();
-            buffered += decoder.decode(value, { stream: !done });
-            let boundary = findSseEventBoundary(buffered);
-            while (boundary) {
-                const event = buffered.slice(0, boundary.index);
-                buffered = buffered.slice(boundary.index + boundary.length);
-                const payload = parseSseEvent(event);
-                if (payload !== undefined) {
-                    yield payload;
-                }
-                boundary = findSseEventBoundary(buffered);
-            }
-            if (done) {
-                const payload = parseSseEvent(buffered);
-                if (payload !== undefined) {
-                    yield payload;
-                }
-                completed = true;
-                return;
+            if (done)
+                break;
+            totalBytes += value.length;
+            if (totalBytes > MAX_SPEECH_PCM_BYTES) {
+                throw new Error("generated speech audio exceeds the 32 MiB limit");
             }
+            const audio = Buffer.concat([pendingByte, value]);
+            const alignedLength = audio.length - (audio.length % 2);
+            pendingByte = Buffer.from(audio.subarray(alignedLength));
+            if (alignedLength > 0)
+                yield audio.subarray(0, alignedLength);
+        }
+        if (totalBytes === 0 || pendingByte.length > 0) {
+            throw new Error("ElevenLabs returned empty or incomplete PCM audio");
         }
+        completed = true;
     }
     finally {
-        if (!completed) {
+        if (!completed)
             await reader.cancel().catch(() => { });
-        }
         reader.releaseLock();
     }
 }
-function findSseEventBoundary(text) {
-    const match = /\r?\n\r?\n/u.exec(text);
-    return match ? { index: match.index, length: match[0].length } : undefined;
-}
-function parseSseEvent(event) {
-    const data = event
-        .split(/\r?\n/u)
-        .filter((line) => line.startsWith("data:"))
-        .map((line) => line.slice(5).trimStart())
-        .join("\n")
-        .trim();
-    if (!data || data === "[DONE]") {
-        return undefined;
-    }
-    try {
-        return JSON.parse(data);
-    }
-    catch {
-        throw new GeminiTtsResponseError("Gemini TTS returned malformed streaming data");
-    }
-}
-function extractGeminiText(payload) {
-    if (!isObject(payload) || !Array.isArray(payload.candidates)) {
-        return "";
-    }
-    for (const candidate of payload.candidates) {
-        if (!isObject(candidate) ||
-            !isObject(candidate.content) ||
-            !Array.isArray(candidate.content.parts)) {
-            continue;
-        }
-        const text = candidate.content.parts
-            .map((part) => (isObject(part) && typeof part.text === "string" ? part.text : ""))
-            .join("")
-            .trim();
-        if (text) {
-            return text;
-        }
-    }
-    return "";
-}
-function assertGeminiTtsCompleted(payload) {
-    const finishReason = getGeminiFinishReason(payload);
-    if (finishReason) {
-        assertGeminiTtsFinishReason(finishReason);
-    }
-}
-function assertGeminiTtsFinishReason(finishReason) {
-    if (finishReason === "MAX_TOKENS") {
-        throw new GeminiTtsOutputLimitError();
-    }
-    if (finishReason !== "STOP") {
-        throw new GeminiTtsResponseError(`Gemini TTS stopped with finish reason '${finishReason}'`);
-    }
-}
-function getGeminiFinishReason(payload) {
-    if (!isObject(payload) || !Array.isArray(payload.candidates)) {
-        return undefined;
-    }
-    for (const candidate of payload.candidates) {
-        if (isObject(candidate) && typeof candidate.finishReason === "string") {
-            return candidate.finishReason;
-        }
-    }
-    return undefined;
-}
-function extractGeminiInlineAudioData(payload) {
-    return extractGeminiInlineAudioDataParts(payload)[0];
-}
-function extractGeminiInlineAudioDataParts(payload) {
-    if (!isObject(payload) || !Array.isArray(payload.candidates)) {
-        return [];
-    }
-    const audioData = [];
-    for (const candidate of payload.candidates) {
-        if (!isObject(candidate) ||
-            !isObject(candidate.content) ||
-            !Array.isArray(candidate.content.parts)) {
-            continue;
-        }
-        for (const part of candidate.content.parts) {
-            if (!isObject(part) ||
-                !isObject(part.inlineData) ||
-                typeof part.inlineData.data !== "string") {
-                continue;
-            }
-            const data = part.inlineData.data.trim();
-            if (data) {
-                audioData.push(data);
-            }
-        }
-    }
-    return audioData;
-}
 function buildSpeechRewritePrompt(sourceText) {
     return [
         "Rewrite the assistant response below so it sounds natural when spoken aloud.",
@@ -640,7 +430,7 @@ function buildSpeechRewritePrompt(sourceText) {
         "Rewrite a code identifier only when its literal form would be difficult to follow aloud, and preserve its exact meaning.",
         "",
         "Examples of good rewrites:",
-        '- `src/core/utils/gemini_speech.ts:372` → "gemini_speech.ts, line 372"',
+        '- `src/core/utils/speech.ts:372` → "speech.ts, line 372"',
         '- `src/tui/session_chat_controller.ts:1819-1855` → "session_chat_controller.ts, lines 1819 to 1855"',
         '- `src/core/session/compaction.ts` → "compaction.ts"',
         '- `/Users/markus/.config/tau/config.json` → "the tau config.json in your home directory"',
@@ -751,57 +541,6 @@ function closestSpeechBoundary(candidates, cumulativeWeights, idealWeight) {
 function isSpeechSentenceBoundary(previous, next) {
     return /[。！？]/u.test(previous) || (/[.!?;:]/u.test(previous) && /\s/u.test(next));
 }
-function buildSpeechSynthesisPrompt(spokenText) {
-    return [
-        "Synthesize speech audio for the labeled transcript below.",
-        "Speak only the transcript. Do not speak the instructions or section labels.",
-        "",
-        "### DIRECTOR'S NOTES",
-        "Style: Clear, natural, conversational.",
-        "Pacing: Brisk conversational speed. Keep it clear, confident, and energetic without sounding rushed.",
-        "",
-        "### TRANSCRIPT",
-        spokenText,
-    ].join("\n");
-}
-function isRetryableTtsError(error) {
-    if (error instanceof GeminiTtsOutputLimitError) {
-        return false;
-    }
-    if (error instanceof GeminiTtsResponseError) {
-        return true;
-    }
-    if (error instanceof GeminiApiError) {
-        return error.status !== undefined && RETRYABLE_TTS_STATUS_CODES.has(error.status);
-    }
-    if (error instanceof Error) {
-        return error.name !== "AbortError";
-    }
-    return false;
-}
-async function waitForRetryDelay(attempt, signal) {
-    const durationMs = Math.min(1000, 150 * 2 ** (attempt - 1));
-    await new Promise((resolve, reject) => {
-        const timeout = setTimeout(() => {
-            signal?.removeEventListener("abort", onAbort);
-            resolve();
-        }, durationMs);
-        timeout.unref?.();
-        const onAbort = () => {
-            clearTimeout(timeout);
-            reject(abortError());
-        };
-        if (!signal) {
-            return;
-        }
-        if (signal.aborted) {
-            clearTimeout(timeout);
-            reject(abortError());
-            return;
-        }
-        signal.addEventListener("abort", onAbort, { once: true });
-    });
-}
 function createLinkedAbortController(parent) {
     const controller = new AbortController();
     const onAbort = () => controller.abort(parent?.reason);
@@ -846,4 +585,4 @@ function abortError() {
     error.name = "AbortError";
     return error;
 }
-//# sourceMappingURL=gemini_speech.js.map
+//# sourceMappingURL=speech.js.map