nixamp 0.23.5 → 0.23.6

package/README.md

@@ -314,14 +314,22 @@ which case the words wait in the box for Send. A wrong line is taken down
 with its ✕.
 
 **On the phone, too.** Every live room has a six-digit code on the party
-line (see below), and when anybody is on the phone in a room, each trollbox
-line is read aloud to them: "chovy says: …", in a voice that is theirs as
-far as a machine can manage. The Account panel sets it: a woman's voice, a
-man's, any, or a provider voice id; or an OpenProfile URL, whose `Voice`,
-`Gender` or `Pronouns` decide. Nothing set picks one from the account, so
-the same person is always the same voice. The voices are Telnyx's Kokoro
-ones, open weights, no bill beyond the call; `NIXAMP_VOICE_FEMALE` and
-`NIXAMP_VOICE_MALE` swap in others (an ElevenLabs id, say).
+line (see below), and only when somebody is on the phone in a room, each
+trollbox line is read aloud to them: "chovy says: …", in a voice that is
+theirs as far as a machine can manage, and different from everybody
+else's in the room. The Account panel (or `nixamp profile`, or the
+`profile_set` MCP tool) sets it: a woman's voice, a man's, any, or a voice
+id; or an OpenProfile URL, whose `Voice`, `Gender` or `Pronouns` decide.
+Given a sex, the account picks one voice from that sex's pool and keeps
+it; given nothing, one from the whole pool. `nixamp voices` lists them.
+
+Two pools. Telnyx's Kokoro voices are an open-weights model with no bill
+beyond the call: eleven women, eight men. ElevenLabs reads better and bills
+per character: when the Telnyx account holds an integration secret named
+`elevenlabs` with the ElevenLabs key, nixamp.com finds it on its own and
+uses ElevenLabs' premade voices by their labelled gender; `NIXAMP_TTS=kokoro`
+keeps the free ones regardless. `NIXAMP_VOICES_FEMALE` / `NIXAMP_VOICES_MALE`
+(comma lists of Telnyx voice ids) replace either pool outright.
 The ear is [Whisper](https://github.com/openai/whisper) run through
 [Transformers.js](https://github.com/huggingface/transformers.js), an
 Apache-2.0 library carrying MIT-licensed models, on nixamp.com's own CPU.

package/dist/main.js

@@ -62,6 +62,8 @@ const HELP = `nixamp — it really whips the terminal's ass.
   nixamp mcp                     speak Model Context Protocol on stdin, for an agent
   nixamp transcribe FILE [--say SERVER]  the words in a recording, and into a trollbox
   nixamp transcript --channel ID [--follow]  what a channel is saying, as it says it
+  nixamp profile [--handle H] [--voice V] [--profile URL]  who the rooms know you as
+  nixamp voices                  the voices a line is read in on the phone
   nixamp opendir list|add|remove  folders found on the web, published for everyone
   nixamp update [version]        re-run the installer, keeping your choices
   nixamp uninstall [--yes]       remove everything the installer created
@@ -242,7 +244,8 @@ It offers the watch party tools: list them, read one, put one on the air,
 say where playback is, end it. And the room tools: transcribe a recording
 (transcribe_audio, which can post the words straight into a trollbox), say a
 line in a room (trollbox_say), read a room (trollbox_read), read what a
-channel is saying (transcript_read). It acts as
+channel is saying (transcript_read), and who you are in the rooms and how
+you sound on the phone (profile_get, profile_set, voices_list). It acts as
 whoever this machine is signed in as, so \`nixamp login\` (or NIXAMP_TOKEN)
 comes first.
 
@@ -263,6 +266,20 @@ sign-in (\`nixamp login\`) and nothing else. Up to a minute at a time.
 
 The same ear is behind the microphone button in every nixamp.com trollbox,
 and behind the transcribe_audio tool of \`nixamp mcp\`.
+`,
+    profile: `nixamp profile — who the rooms know you as.
+
+  nixamp profile                       your handle, voice and OpenProfile
+  nixamp profile --handle chovy        the name on every line you say
+  nixamp profile --voice female        the voice your lines are read in on the phone:
+                                       female, male, any, or a voice id (see \`nixamp voices\`)
+  nixamp profile --profile URL         your OpenProfile.md; its Voice, Gender or Pronouns
+                                       decide the voice when you set none here
+  nixamp voices                        the voices this nixamp.com reads lines in
+
+When somebody is on the phone in a live room, every trollbox line is read to
+them in the author's voice: the one set here, else the OpenProfile's, else
+one picked for the account and kept. Two people in a room are two voices.
 `,
     transcript: `nixamp transcript — what a channel is saying, written down.
 
@@ -473,6 +490,16 @@ export async function main() {
         process.exitCode = await party(rest);
         return;
     }
+    if (first === "profile" || first === "persona") {
+        const { profile } = await import("./profile.js");
+        process.exitCode = await profile(rest);
+        return;
+    }
+    if (first === "voices") {
+        const { voices } = await import("./profile.js");
+        process.exitCode = await voices(rest);
+        return;
+    }
     if (first === "transcript" || first === "captions") {
         const { transcript } = await import("./transcript.js");
         process.exitCode = await transcript(rest);

package/dist/mcp.js

@@ -22,6 +22,7 @@ import { clock } from "./party.js";
 import { readSession } from "./session.js";
 import { askToHear, wavOf } from "./transcribe.js";
 import { readTranscript } from "./transcript.js";
+import { personaLines, readPersona, readVoices, writePersona } from "./profile.js";
 export const PROTOCOL_VERSION = "2025-06-18";
 const STRING = { type: "string" };
 export const TOOLS = [
@@ -119,6 +120,28 @@ export const TOOLS = [
             required: ["url"],
         },
     },
+    {
+        name: "profile_get",
+        description: "Who the rooms know this account as: its handle, the voice its trollbox lines are read in on the phone, the OpenProfile URL, and the voice that would be used right now.",
+        inputSchema: { type: "object", properties: {} },
+    },
+    {
+        name: "profile_set",
+        description: "Set this account's handle, the voice its lines are read in on the phone (female, male, any, or a voice id from voices_list), and/or its OpenProfile URL (whose Voice, Gender or Pronouns pick the voice when none is set). Any one may be given alone.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                handle: { ...STRING, description: "Letters, digits and hyphens, 2 to 30 characters." },
+                voice: { ...STRING, description: "female, male, any, or a voice id such as ElevenLabs.pNInz6obpgDQGcFmaJgB." },
+                profile: { ...STRING, description: "The URL of an OpenProfile.md, or an empty string to clear it." },
+            },
+        },
+    },
+    {
+        name: "voices_list",
+        description: "The voices trollbox lines can be read in on the phone: the provider in use and the women's and men's voice ids.",
+        inputSchema: { type: "object", properties: {} },
+    },
     {
         name: "trollbox_read",
         description: "The recent lines in a live room's trollbox, oldest first: who said what, and when.",
@@ -289,6 +312,33 @@ export async function callTool(name, args, options = {}) {
             }
             return text(got.answer.recent.map((line) => `${new Date(line.at).toISOString()}  ${line.text}`).join("\n"));
         }
+        if (name === "profile_get") {
+            const answer = await readPersona(session, send);
+            if (!answer.ok)
+                return failed(answer.error);
+            return text(personaLines(answer.body).join("\n"));
+        }
+        if (name === "profile_set") {
+            const wanted = {};
+            if (typeof args["handle"] === "string")
+                wanted.handle = args["handle"];
+            if (typeof args["voice"] === "string")
+                wanted.voice = args["voice"];
+            if (typeof args["profile"] === "string")
+                wanted.profile = args["profile"];
+            if (Object.keys(wanted).length === 0)
+                return failed("Set what? Pass handle, voice and/or profile.");
+            const answer = await writePersona(session, wanted, send);
+            if (!answer.ok)
+                return failed(answer.error);
+            return text(personaLines(answer.body).join("\n"));
+        }
+        if (name === "voices_list") {
+            const answer = await readVoices(session, send);
+            if (!answer.ok)
+                return failed(answer.error);
+            return text([`Voices: ${answer.body.provider}.`, "Women:", ...answer.body.female.map((one) => `  ${one}`), "Men:", ...answer.body.male.map((one) => `  ${one}`)].join("\n"));
+        }
         if (name === "trollbox_read") {
             if (!server)
                 return failed("Which room? Pass the server's address.");

package/dist/partyline.d.ts

@@ -261,7 +261,9 @@ export declare class PartyLine {
      * voice of whoever typed them. False when nobody is on the phone there,
      * which is most of the time and costs nothing.
      */
-    say(code: string, text: string, voice: string): Promise<boolean>;
+    say(code: string, text: string, voice: string, settings?: {
+        api_key_ref: string;
+    }): Promise<boolean>;
     /** Whether anybody is on the phone in a room, before a line is worth reading. */
     hasCallers(code: string): boolean;
     /**

package/dist/partyline.js

@@ -589,7 +589,7 @@ export class PartyLine {
      * voice of whoever typed them. False when nobody is on the phone there,
      * which is most of the time and costs nothing.
      */
-    async say(code, text, voice) {
+    async say(code, text, voice, settings) {
         const room = this.rooms.get(code);
         if (!room || room.conferenceId === null || room.callers === 0)
             return false;
@@ -599,6 +599,8 @@ export class PartyLine {
         const answer = await this.request(`/conferences/${encodeURIComponent(room.conferenceId)}/actions/speak`, {
             payload: said,
             voice: voice || this.voice,
+            // An ElevenLabs voice needs the key Telnyx holds for it, by name.
+            ...(settings ? { voice_settings: settings } : {}),
         });
         return answer !== null;
     }

package/dist/profile.d.ts

@@ -0,0 +1,45 @@
+/**
+ * `nixamp profile` and `nixamp voices` -- who the rooms know you as, from
+ * the terminal, and the voices a line can be read in.
+ *
+ * The same route the Account panel uses (`/api/v1/me/handle`), signed in
+ * as this machine is. The MCP tools of the same names are these functions
+ * with a different front.
+ */
+import { type Session } from "./session.ts";
+export interface Persona {
+    handle: string;
+    voice: string;
+    profile: string;
+    chosen: boolean;
+    /** The voice a line of theirs would be read in right now. */
+    spoken?: string;
+}
+export interface Pools {
+    provider: string;
+    female: string[];
+    male: string[];
+}
+export type Answer<T> = {
+    ok: true;
+    body: T;
+} | {
+    ok: false;
+    status: number;
+    error: string;
+};
+export declare function readPersona(session: Pick<Session, "site" | "token">, fetcher?: typeof fetch): Promise<Answer<Persona>>;
+export declare function writePersona(session: Pick<Session, "site" | "token">, wanted: {
+    handle?: string;
+    voice?: string;
+    profile?: string;
+}, fetcher?: typeof fetch): Promise<Answer<Persona>>;
+export declare function readVoices(session: Pick<Session, "site" | "token">, fetcher?: typeof fetch): Promise<Answer<Pools>>;
+/** A persona, as the terminal says it. */
+export declare function personaLines(persona: Persona): string[];
+export interface ProfileDeps {
+    fetcher?: typeof fetch;
+    session?: Pick<Session, "site" | "token"> | null;
+}
+export declare function profile(argv: string[], deps?: ProfileDeps): Promise<number>;
+export declare function voices(argv: string[], deps?: ProfileDeps): Promise<number>;

package/dist/profile.js

@@ -0,0 +1,148 @@
+/**
+ * `nixamp profile` and `nixamp voices` -- who the rooms know you as, from
+ * the terminal, and the voices a line can be read in.
+ *
+ * The same route the Account panel uses (`/api/v1/me/handle`), signed in
+ * as this machine is. The MCP tools of the same names are these functions
+ * with a different front.
+ */
+import { readSession } from "./session.js";
+const HELP = `nixamp profile — who the rooms know you as.
+
+  nixamp profile                       your handle, voice and OpenProfile
+  nixamp profile --handle chovy        the name on every line you say
+  nixamp profile --voice female        the voice your lines are read in on the phone:
+                                       female, male, any, or a voice id (see \`nixamp voices\`)
+  nixamp profile --profile URL         your OpenProfile.md; its Voice, Gender or Pronouns
+                                       decide the voice when you set none here
+  nixamp profile --json                as JSON
+  nixamp voices                        the voices this nixamp.com reads lines in
+
+When somebody is on the phone in a live room, every trollbox line is read
+to them in the author's voice: the one set here, else the OpenProfile's,
+else one picked for the account and kept. Two people in a room are two
+different voices.
+`;
+function headers(session) {
+    return { authorization: `Bearer ${session.token}`, "content-type": "application/json" };
+}
+export async function readPersona(session, fetcher = fetch) {
+    try {
+        const response = await fetcher(`${session.site.replace(/\/+$/, "")}/api/v1/me/handle`, { headers: headers(session) });
+        const body = (await response.json().catch(() => ({})));
+        if (!response.ok)
+            return { ok: false, status: response.status, error: body.error ?? `nixamp answered ${response.status}` };
+        return { ok: true, body };
+    }
+    catch (error) {
+        return { ok: false, status: 0, error: `could not reach ${session.site}: ${error.message}` };
+    }
+}
+export async function writePersona(session, wanted, fetcher = fetch) {
+    try {
+        const response = await fetcher(`${session.site.replace(/\/+$/, "")}/api/v1/me/handle`, {
+            method: "PUT",
+            headers: headers(session),
+            body: JSON.stringify(wanted),
+        });
+        const body = (await response.json().catch(() => ({})));
+        if (!response.ok)
+            return { ok: false, status: response.status, error: body.error ?? `nixamp answered ${response.status}` };
+        return { ok: true, body };
+    }
+    catch (error) {
+        return { ok: false, status: 0, error: `could not reach ${session.site}: ${error.message}` };
+    }
+}
+export async function readVoices(session, fetcher = fetch) {
+    try {
+        const response = await fetcher(`${session.site.replace(/\/+$/, "")}/api/v1/voices`, { headers: headers(session) });
+        const body = (await response.json().catch(() => ({})));
+        if (!response.ok)
+            return { ok: false, status: response.status, error: body.error ?? `nixamp answered ${response.status}` };
+        return { ok: true, body };
+    }
+    catch (error) {
+        return { ok: false, status: 0, error: `could not reach ${session.site}: ${error.message}` };
+    }
+}
+/** A persona, as the terminal says it. */
+export function personaLines(persona) {
+    const voice = persona.voice === "female" ? "a woman's voice"
+        : persona.voice === "male" ? "a man's voice"
+            : persona.voice ? `the voice ${persona.voice}`
+                : persona.profile ? "whatever your OpenProfile says, else one picked for you"
+                    : "one picked for you";
+    return [
+        persona.chosen ? `You are ${persona.handle} in every room.` : `Rooms call you ${persona.handle} until you pick a handle (--handle).`,
+        `On the phone your lines are read in ${voice}${persona.spoken ? ` (${persona.spoken})` : ""}.`,
+        persona.profile ? `OpenProfile: ${persona.profile}` : "No OpenProfile set (--profile URL).",
+    ];
+}
+function flag(argv, name) {
+    const at = argv.indexOf(name);
+    return at === -1 ? undefined : argv[at + 1];
+}
+export async function profile(argv, deps = {}) {
+    if (argv.includes("--help") || argv.includes("-h") || argv[0] === "help") {
+        console.log(HELP);
+        return 0;
+    }
+    const session = deps.session === undefined ? readSession() : deps.session;
+    if (session === null) {
+        console.error("nixamp: not signed in. Try `nixamp login`.");
+        return 1;
+    }
+    const fetcher = deps.fetcher ?? fetch;
+    const wanted = {};
+    for (const [name, key] of [["--handle", "handle"], ["--voice", "voice"], ["--profile", "profile"]]) {
+        if (argv.includes(name)) {
+            const value = flag(argv, name);
+            if (value === undefined || value.startsWith("--")) {
+                console.error(`nixamp: ${name} needs a value.`);
+                return 64;
+            }
+            wanted[key] = value;
+        }
+    }
+    const answer = Object.keys(wanted).length > 0 ? await writePersona(session, wanted, fetcher) : await readPersona(session, fetcher);
+    if (!answer.ok) {
+        console.error(`nixamp: ${answer.error}`);
+        return 1;
+    }
+    if (argv.includes("--json")) {
+        console.log(JSON.stringify(answer.body, null, 2));
+        return 0;
+    }
+    for (const line of personaLines(answer.body))
+        console.log(line);
+    return 0;
+}
+export async function voices(argv, deps = {}) {
+    if (argv.includes("--help") || argv.includes("-h")) {
+        console.log(HELP);
+        return 0;
+    }
+    const session = deps.session === undefined ? readSession() : deps.session;
+    if (session === null) {
+        console.error("nixamp: not signed in. Try `nixamp login`.");
+        return 1;
+    }
+    const answer = await readVoices(session, deps.fetcher ?? fetch);
+    if (!answer.ok) {
+        console.error(`nixamp: ${answer.error}`);
+        return 1;
+    }
+    if (argv.includes("--json")) {
+        console.log(JSON.stringify(answer.body, null, 2));
+        return 0;
+    }
+    console.log(`Voices: ${answer.body.provider}. Set one with \`nixamp profile --voice <id>\`, or --voice female/male to be given one of these and keep it.`);
+    console.log("  Women:");
+    for (const one of answer.body.female)
+        console.log(`    ${one}`);
+    console.log("  Men:");
+    for (const one of answer.body.male)
+        console.log(`    ${one}`);
+    return 0;
+}

package/dist/server.d.ts

@@ -32,7 +32,7 @@ import { Rooms } from "./rooms.ts";
 import { Trollbox } from "./trollbox.ts";
 import { Speech } from "./speech.ts";
 import { Captions } from "./captions.ts";
-import { Profiles } from "./voices.ts";
+import { Profiles, Voices } from "./voices.ts";
 import { type Codecs } from "./audio.ts";
 import { type Tools, type Track } from "./audio.ts";
 import { type Command, type RemoteTrack, type Snapshot } from "./protocol.ts";
@@ -701,6 +701,8 @@ export interface HandlerOptions {
     speech?: Speech;
     /** Other people's OpenProfiles, for the voice their lines are read in. */
     profiles?: Profiles;
+    /** The voices lines are read in: ElevenLabs when Telnyx holds the key, Kokoro otherwise. */
+    voices?: Voices;
     /** Tickets: a paid pass to one event's room. Absent means every show is free. */
     tickets?: Tickets;
     /**

package/dist/server.js

@@ -67,7 +67,7 @@ import { Rooms } from "./rooms.js";
 import { Trollbox, TrollboxError, fallbackHandle, roomFor } from "./trollbox.js";
 import { MAX_BYTES as SPEECH_BYTES, Speech, SpeechError, isWav, languageOf } from "./speech.js";
 import { Captions } from "./captions.js";
-import { Profiles, spokenLine, telnyxVoiceFor, voicesFromEnv } from "./voices.js";
+import { Profiles, Voices, spokenLine, spokenVoiceFor } from "./voices.js";
 import { confirm, DEFAULT_DIRECTORY, Publisher } from "./publish.js";
 import { applyRemoteConfig, createPaywall, FREE_LISTENERS, paywallFromEnv, } from "./paywall.js";
 import { isRemote, isTransportStream, playsInBrowser, sourceLabel } from "./sources.js";
@@ -2212,10 +2212,26 @@ export function createHandler(engine, options) {
             void (async () => {
                 const persona = (await options.handles?.persona(authorId)) ?? { handle, voice: "", profile: "" };
                 const profile = persona.profile && options.profiles ? await options.profiles.voiceOf(persona.profile) : null;
-                const voice = telnyxVoiceFor({ userId: authorId, voice: persona.voice, profile }, voicesFromEnv());
-                await partyLine.say(code, spokenLine(handle, body), voice);
+                const pools = options.voices ? await options.voices.pools() : { provider: "kokoro", female: [], male: [] };
+                const spoken = spokenVoiceFor({ userId: authorId, voice: persona.voice, profile }, pools);
+                await partyLine.say(code, spokenLine(handle, body), spoken.voice, spoken.settings);
             })().catch(() => undefined);
         };
+        /*
+         * The voices a line can be read in, for whoever wants to pick one by
+         * id: which provider, and the women's and the men's pools. Signed in,
+         * like the profile it feeds.
+         */
+        if (path === "/api/v1/voices" && options.accounts) {
+            const who = await options.accounts.whoIs(tokenFrom(request.headers));
+            if (who === null) {
+                json(response, 401, { error: "not signed in" });
+                return;
+            }
+            const pools = options.voices ? await options.voices.pools() : { provider: "kokoro", female: [], male: [] };
+            json(response, 200, { provider: pools.provider, female: pools.female, male: pools.male });
+            return;
+        }
         /*
          * The trollbox: the chat for one live room, keyed by the server and
          * the channel so every viewer of a stream is in the same box whichever
@@ -2366,7 +2382,12 @@ export function createHandler(engine, options) {
             // be sent alone; what is not sent is kept.
             if (request.method === "GET") {
                 const persona = await handles.persona(who.id);
-                json(response, 200, { ...persona, handle: persona.handle || fallbackHandle(who.id), chosen: persona.handle !== "" });
+                // And the voice a line of theirs would be read in right now, so the
+                // panel and the CLI can say it rather than describe the rule.
+                const pools = options.voices ? await options.voices.pools() : null;
+                const profile = persona.profile && options.profiles ? await options.profiles.voiceOf(persona.profile) : null;
+                const spoken = pools ? spokenVoiceFor({ userId: who.id, voice: persona.voice, profile }, pools).voice : "";
+                json(response, 200, { ...persona, handle: persona.handle || fallbackHandle(who.id), chosen: persona.handle !== "", spoken });
                 return;
             }
             if (request.method === "PUT" || request.method === "POST") {
@@ -5224,8 +5245,14 @@ export async function serve(argv, version = "0.1.0") {
         ...(rooms ? { rooms } : {}),
         ...(trollbox ? { trollbox } : {}),
         ...(speech ? { speech } : {}),
-        // Other people's OpenProfiles, read for the voice a line is spoken in.
+        // Other people's OpenProfiles, read for the voice a line is spoken in,
+        // and the voices to speak in: ElevenLabs when the Telnyx account holds
+        // the key for it (an integration secret named "elevenlabs"), Kokoro
+        // otherwise. Nothing to configure on the deployment for either.
         ...(accounts ? { profiles: new Profiles() } : {}),
+        ...(accounts && process.env["TELNYX_API_KEY"]
+            ? { voices: new Voices({ telnyxApiKey: process.env["TELNYX_API_KEY"], onEvent: (message) => console.log(message) }) }
+            : {}),
         ...(tickets ? { tickets } : {}),
         ...(authServer ? { authServer } : {}),
         ...(parties ? { parties } : {}),

package/dist/voices.d.ts

@@ -1,6 +1,33 @@
 export type VoiceKind = "female" | "male" | "";
-/** Kokoro, through Telnyx: af_heart is the default woman, am_adam the default man. */
+/** Kokoro through Telnyx: American English, the women then the men. Free. */
+export declare const KOKORO_FEMALE: string[];
+export declare const KOKORO_MALE: string[];
+/**
+ * ElevenLabs' premade voices, as `ElevenLabs.<voice id>`, by the gender
+ * ElevenLabs labels them with (read off the account on 2026-09-13). The
+ * names are for whoever reads this file; Telnyx only ever sees the id.
+ */
+export declare const ELEVENLABS_FEMALE: string[];
+export declare const ELEVENLABS_MALE: string[];
+/** Kept for the tests and anybody who wants one voice per sex: the first of each pool. */
 export declare const DEFAULT_VOICES: Record<Exclude<VoiceKind, "">, string>;
+/** The voices to choose among, and what Telnyx needs to speak them. */
+export interface VoicePools {
+    provider: "kokoro" | "elevenlabs" | "custom";
+    female: string[];
+    male: string[];
+    /** Sent as `voice_settings` on an ElevenLabs voice: the integration secret holding the key. */
+    settings?: {
+        api_key_ref: string;
+    };
+}
+/** What a speak command is told: the voice, and the settings that voice needs, if any. */
+export interface SpokenVoice {
+    voice: string;
+    settings?: {
+        api_key_ref: string;
+    };
+}
 /** The word a person used for themselves, as a voice: female, male, or nothing to go on. */
 export declare function voiceKindOf(value: unknown): VoiceKind;
 export interface ProfileVoice {
@@ -16,18 +43,54 @@ export interface ProfileVoice {
  */
 export declare function readProfileVoice(markdown: string): ProfileVoice;
 /**
- * The Telnyx voice for somebody, from what is known about them. A voice
- * named outright (`ElevenLabs.…`, `Telnyx.KokoroTTS.…`, `Polly.…`) is used
- * as written; a sex picks the configured voice for it; nothing at all
- * picks one by the account id, so it stays the same tomorrow.
+ * The voice for somebody, from what is known about them. A voice named
+ * outright (`ElevenLabs.…`, `Telnyx.KokoroTTS.…`, `Polly.…`) is used as
+ * written; a sex picks from that sex's pool by the account id; nothing at
+ * all picks from both pools the same way, so it stays the same tomorrow.
+ * Settings ride along when the voice is an ElevenLabs one and the pools
+ * know the secret.
  */
 export declare function telnyxVoiceFor(who: {
     userId: string;
     voice?: string;
     profile?: ProfileVoice | null;
-}, voices?: Record<Exclude<VoiceKind, "">, string>): string;
-/** The voices to use per sex, from the environment when it says so. */
+}, pools?: VoicePools | Record<Exclude<VoiceKind, "">, string>): string;
+export declare function spokenVoiceFor(who: {
+    userId: string;
+    voice?: string;
+    profile?: ProfileVoice | null;
+}, pools: VoicePools): SpokenVoice;
+/** The voices to use per sex, from the environment when it says so. Kept for one-voice callers. */
 export declare function voicesFromEnv(env?: NodeJS.ProcessEnv): Record<Exclude<VoiceKind, "">, string>;
+/**
+ * The pools this deployment speaks with. `NIXAMP_VOICES_FEMALE` and
+ * `NIXAMP_VOICES_MALE` (comma lists of Telnyx voice ids) win outright;
+ * `NIXAMP_VOICE_FEMALE` / `NIXAMP_VOICE_MALE` name one voice per sex; else
+ * ElevenLabs when the account holds the secret for it and `NIXAMP_TTS` is
+ * not `kokoro`; else Kokoro, which is free.
+ */
+export declare function poolsFrom(env: NodeJS.ProcessEnv, elevenLabsSecret: string | null): VoicePools;
+/**
+ * Whether Telnyx holds an ElevenLabs key for this account: an integration
+ * secret whose identifier is `elevenlabs` (or what NIXAMP_ELEVENLABS_SECRET
+ * names). Asked once, at the first line, and remembered; no key means the
+ * free voices, and no Railway variable has to be set for either.
+ */
+export declare class Voices {
+    private readonly options;
+    private secret;
+    constructor(options: {
+        telnyxApiKey: string;
+        env?: NodeJS.ProcessEnv;
+        fetcher?: typeof fetch;
+        telnyxApi?: string;
+        onEvent?: (message: string) => void;
+    });
+    private get env();
+    private elevenLabsSecret;
+    /** The pools, resolved once. A failed look at Telnyx is asked again next time. */
+    pools(): Promise<VoicePools>;
+}
 /** What a line sounds like read aloud: who said it, then what. */
 export declare function spokenLine(handle: string, body: string): string;
 /**