roger-roger 0.1.0

package/skills/roger-roger/scripts/tts.mjs

@@ -0,0 +1,275 @@
+// Speech from whichever provider the user picked. Each one knows its own voices and models, where
+// its key usually lives, and how to turn a line of text into a WAV — so everything after synthesis
+// (queueing, the ding, playback) stays the same whoever made the audio.
+//
+// Voices and models are fetched from the provider once a key is there and kept in a small cache,
+// so the panel and `status` can offer real choices without going to the network every time.
+
+import crypto from "node:crypto";
+import fs from "node:fs";
+import path from "node:path";
+import { VOICES, parsePcmMime, rogerRogerHome, scaleWav, speechGain, stripTags, wavFromPcm } from "./lib.mjs";
+import { missingKeyMessage, speechKey } from "./speechkey.mjs";
+
+const TIMEOUT_MS = 45_000;
+
+/** The audio tags in a line (`[positive]`, `[short pause]`), for providers that take them as a style note. */
+const tagsIn = (text) => [...String(text).matchAll(/(?:^|\s)\[([a-z][a-z' -]{0,38})\](?=$|\s|[,.!?;:])/g)].map((m) => m[1]);
+
+async function json(res, who) {
+  const body = await res.json().catch(() => ({}));
+  if (!res.ok) throw new Error(`${who} ${res.status}: ${body?.error?.message ?? body?.detail?.message ?? body?.detail ?? "request failed"}`);
+  return body;
+}
+
+export const PROVIDERS = {
+  gemini: {
+    id: "gemini",
+    label: "Google Gemini",
+    keyVars: ["GEMINI_API_KEY", "GOOGLE_API_KEY"],
+    defaultModel: "gemini-3.1-flash-tts-preview",
+    defaultVoice: "Kore",
+    // Gemini has no voice list endpoint; this is the published set.
+    staticVoices: Object.entries(VOICES).map(([id, description]) => ({ id, name: id, description })),
+    previewVoices: ["Kore", "Puck", "Charon", "Aoede", "Achird", "Sulafat"],
+    async models(key) {
+      const res = await fetch("https://generativelanguage.googleapis.com/v1beta/models?pageSize=1000", {
+        headers: { "x-goog-api-key": key },
+        signal: AbortSignal.timeout(TIMEOUT_MS),
+      });
+      const body = await json(res, "Gemini");
+      return (body.models ?? [])
+        .map((m) => String(m.name ?? "").replace(/^models\//, ""))
+        .filter((id) => /tts/i.test(id))
+        .map((id) => ({ id, name: id }));
+    },
+    async voices() {
+      return this.staticVoices;
+    },
+    // Gemini reads the audio tags itself, so the text goes as written.
+    async synthesize(text, { key, voice, model }) {
+      const res = await fetch(`https://generativelanguage.googleapis.com/v1beta/models/${model}:generateContent`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json", "x-goog-api-key": key },
+        body: JSON.stringify({
+          contents: [{ parts: [{ text }] }],
+          generationConfig: {
+            responseModalities: ["AUDIO"],
+            speechConfig: { voiceConfig: { prebuiltVoiceConfig: { voiceName: voice } } },
+          },
+        }),
+        signal: AbortSignal.timeout(TIMEOUT_MS),
+      });
+      const body = await json(res, "Gemini");
+      const blocked = body?.promptFeedback?.blockReason;
+      if (blocked) throw new Error(`Gemini refused the text (${blocked})`);
+      const data = body?.candidates?.[0]?.content?.parts?.find((p) => p.inlineData)?.inlineData;
+      if (!data?.data) throw new Error("Gemini returned no audio");
+      const { rate, channels } = parsePcmMime(data.mimeType);
+      return wavFromPcm(Buffer.from(data.data, "base64"), rate, channels);
+    },
+  },
+
+  openai: {
+    id: "openai",
+    label: "OpenAI",
+    keyVars: ["OPENAI_API_KEY"],
+    defaultModel: "gpt-4o-mini-tts",
+    defaultVoice: "coral",
+    // No voice list endpoint here either; these are the documented ones.
+    staticVoices: ["alloy", "ash", "ballad", "cedar", "coral", "echo", "fable", "marin", "nova", "onyx", "sage", "shimmer", "verse"]
+      .map((id) => ({ id, name: id })),
+    previewVoices: ["coral", "marin", "cedar", "nova", "ash", "sage"],
+    async models(key) {
+      const res = await fetch("https://api.openai.com/v1/models", {
+        headers: { Authorization: `Bearer ${key}` },
+        signal: AbortSignal.timeout(TIMEOUT_MS),
+      });
+      const body = await json(res, "OpenAI");
+      return (body.data ?? []).map((m) => m.id).filter((id) => /tts/i.test(id)).sort().map((id) => ({ id, name: id }));
+    },
+    async voices() {
+      return this.staticVoices;
+    },
+    // The tags are not read aloud here; the newer models take them as a note on how to say it.
+    async synthesize(text, { key, voice, model }) {
+      const tags = tagsIn(text);
+      const res = await fetch("https://api.openai.com/v1/audio/speech", {
+        method: "POST",
+        headers: { "Content-Type": "application/json", Authorization: `Bearer ${key}` },
+        body: JSON.stringify({
+          model,
+          voice,
+          input: stripTags(text),
+          response_format: "wav",
+          ...(tags.length && !/^tts-1/.test(model) ? { instructions: `Delivery: ${tags.join(", ")}.` } : {}),
+        }),
+        signal: AbortSignal.timeout(TIMEOUT_MS),
+      });
+      if (!res.ok) await json(res, "OpenAI");
+      return Buffer.from(await res.arrayBuffer());
+    },
+  },
+
+  elevenlabs: {
+    id: "elevenlabs",
+    label: "ElevenLabs",
+    keyVars: ["ELEVENLABS_API_KEY", "XI_API_KEY"],
+    defaultModel: "eleven_multilingual_v2",
+    // Voices are the account's own, so there is no sensible default until they have been fetched.
+    defaultVoice: "",
+    staticVoices: [],
+    previewVoices: [],
+    async models(key) {
+      const res = await fetch("https://api.elevenlabs.io/v1/models", { headers: { "xi-api-key": key }, signal: AbortSignal.timeout(TIMEOUT_MS) });
+      const body = await json(res, "ElevenLabs");
+      return (Array.isArray(body) ? body : []).filter((m) => m.can_do_text_to_speech !== false).map((m) => ({ id: m.model_id, name: m.name ?? m.model_id }));
+    },
+    async voices(key) {
+      const res = await fetch("https://api.elevenlabs.io/v1/voices", { headers: { "xi-api-key": key }, signal: AbortSignal.timeout(TIMEOUT_MS) });
+      const body = await json(res, "ElevenLabs");
+      return (body.voices ?? []).map((v) => ({
+        id: v.voice_id,
+        name: v.name ?? v.voice_id,
+        description: [v.labels?.gender, v.labels?.accent, v.labels?.description].filter(Boolean).join(", "),
+      }));
+    },
+    // Only the v3 models read audio tags; the others would say the brackets out loud.
+    async synthesize(text, { key, voice, model }) {
+      if (!voice) throw new Error("no ElevenLabs voice picked yet");
+      const res = await fetch(`https://api.elevenlabs.io/v1/text-to-speech/${encodeURIComponent(voice)}?output_format=pcm_24000`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json", "xi-api-key": key },
+        body: JSON.stringify({ text: /v3/.test(model) ? text : stripTags(text), model_id: model }),
+        signal: AbortSignal.timeout(TIMEOUT_MS),
+      });
+      if (!res.ok) await json(res, "ElevenLabs");
+      return wavFromPcm(Buffer.from(await res.arrayBuffer()), 24_000, 1);
+    },
+  },
+};
+
+export const PROVIDER_IDS = Object.keys(PROVIDERS);
+
+/** The provider a config speaks with; Gemini for anything set up before there was a choice. */
+export const providerOf = (config) => PROVIDERS[config?.speechProvider] ?? PROVIDERS.gemini;
+
+/** The key for the config's provider, and the variable it came from. */
+export const keyFor = (config) => speechKey(config?.speechKeyVar ?? "", providerOf(config).keyVars);
+
+/** Why there is no key, naming the variable to set. */
+export const missingKey = (config) => missingKeyMessage(config?.speechKeyVar ?? "", providerOf(config).keyVars);
+
+/** Text → WAV as the provider made it, before the voice volume is applied. */
+async function synthesizeRaw(text, config) {
+  const provider = providerOf(config);
+  const { value: key } = keyFor(config);
+  if (!key) throw new Error(missingKey(config));
+  return provider.synthesize(text, { key, voice: config.voice || provider.defaultVoice, model: config.model || provider.defaultModel });
+}
+
+/** Text → WAV with the configured provider, voice and model, at the configured volume. */
+export async function synthesize(text, config) {
+  return scaleWav(await synthesizeRaw(text, config), speechGain(config));
+}
+
+// ---------------------------------------------------------------- the test sample
+
+const samplePath = () => path.join(rogerRogerHome(), "test-sample.wav");
+const sampleMetaPath = () => path.join(rogerRogerHome(), "test-sample.json");
+
+/**
+ * Everything that changes what a test would sound like, except the volume (applied afterwards).
+ * The key goes in as a hash, so a rotated key is tested afresh without the key itself being kept.
+ */
+function sampleSignature(text, config) {
+  const provider = providerOf(config);
+  const key = keyFor(config);
+  return crypto.createHash("sha256").update(JSON.stringify([
+    provider.id, config.model || provider.defaultModel, config.voice || provider.defaultVoice, key.name,
+    crypto.createHash("sha256").update(key.value).digest("hex"), text,
+  ])).digest("hex");
+}
+
+/**
+ * The test line at the configured volume. Asking the provider again when nothing about it has
+ * changed costs a round trip and a charge for the same audio, so the last one is kept and replayed;
+ * `cached` says which happened. Anything that would change the sound — provider, model, voice, the
+ * key — makes a new one.
+ */
+export async function testSample(text, config) {
+  const signature = sampleSignature(text, config);
+  try {
+    if (JSON.parse(fs.readFileSync(sampleMetaPath(), "utf8")).signature === signature) {
+      return { wav: scaleWav(fs.readFileSync(samplePath()), speechGain(config)), cached: true };
+    }
+  } catch {
+    // No sample yet, or an unreadable one: make a new one.
+  }
+  const raw = await synthesizeRaw(text, config);
+  try {
+    fs.mkdirSync(rogerRogerHome(), { recursive: true });
+    fs.writeFileSync(samplePath(), raw);
+    fs.writeFileSync(sampleMetaPath(), JSON.stringify({ signature, at: new Date().toISOString() }) + "\n", "utf8");
+  } catch {
+    // A sample that can't be kept is only a slower next test.
+  }
+  return { wav: scaleWav(raw, speechGain(config)), cached: false };
+}
+
+// ---------------------------------------------------------------- the catalog cache
+
+const catalogPath = () => path.join(rogerRogerHome(), "speech-catalog.json");
+
+function readAll() {
+  try {
+    return JSON.parse(fs.readFileSync(catalogPath(), "utf8"));
+  } catch {
+    return {};
+  }
+}
+
+/**
+ * What a provider offers: fetched voices and models if we have them, otherwise what is known
+ * without asking (Gemini's and OpenAI's voices are fixed lists; their models are not).
+ */
+export function catalog(providerId) {
+  const provider = PROVIDERS[providerId] ?? PROVIDERS.gemini;
+  const cached = readAll()[provider.id];
+  return {
+    provider: provider.id,
+    voices: cached?.voices?.length ? cached.voices : provider.staticVoices,
+    models: cached?.models?.length ? cached.models : [{ id: provider.defaultModel, name: provider.defaultModel }],
+    fetchedAt: cached?.fetchedAt ?? null,
+  };
+}
+
+/** Ask the provider what it has, with the configured key, and remember the answer. */
+export async function refreshCatalog(config) {
+  const provider = providerOf(config);
+  const { value: key } = keyFor(config);
+  if (!key) throw new Error(missingKey(config));
+  const [voices, models] = await Promise.all([provider.voices(key), provider.models(key)]);
+  const entry = { voices, models, fetchedAt: new Date().toISOString() };
+  const all = readAll();
+  all[provider.id] = entry;
+  fs.mkdirSync(path.dirname(catalogPath()), { recursive: true });
+  const tmp = `${catalogPath()}.${process.pid}.tmp`;
+  fs.writeFileSync(tmp, JSON.stringify(all, null, 2) + "\n", "utf8");
+  fs.renameSync(tmp, catalogPath());
+  return { provider: provider.id, ...entry };
+}
+
+/** What `applySetup` needs to know about providers, without any of it touching the network. */
+export const SPEECH_SETUP = {
+  ids: PROVIDER_IDS,
+  defaults: Object.fromEntries(Object.values(PROVIDERS).map((p) => [p.id, { voice: p.defaultVoice, model: p.defaultModel }])),
+  findVoice: (providerId, name) => findVoice(providerId, name),
+  knowsVoices: (providerId) => catalog(providerId).voices.length > 0,
+};
+
+/** A voice by id or (case-insensitively) by name, from what the provider is known to offer. */
+export function findVoice(providerId, wanted) {
+  const w = String(wanted ?? "").toLowerCase();
+  return catalog(providerId).voices.find((v) => v.id.toLowerCase() === w || v.name.toLowerCase() === w) ?? null;
+}