@gentbajko/slopify 0.6.1 → 0.8.0

package/dist/adapters/tts/elevenlabs.js

@@ -10,9 +10,22 @@ export const elevenLabsBase = "https://api.elevenlabs.io/v1";
 // attempt wrapper measures its 120 s as an idle timeout between chunks only when bytes
 // keep arriving.
 export const elevenLabsModel = "eleven_multilingual_v2";
+export const elevenLabsModels = [
+    { id: "eleven_v3", name: "Eleven v3" },
+    { id: "eleven_multilingual_v2", name: "Eleven Multilingual v2" },
+    { id: "eleven_flash_v2_5", name: "Eleven Flash v2.5" },
+    { id: "eleven_flash_v2", name: "Eleven Flash v2" },
+    { id: "eleven_turbo_v2_5", name: "Eleven Turbo v2.5 (deprecated)" },
+    { id: "eleven_turbo_v2", name: "Eleven Turbo v2 (deprecated)" },
+];
 // mp3 at the port's container, 44.1 kHz, 128 kbps: `kernel/ports/tts.ts` fixes mp3 and the
 // concatenation keeps the provider's own sample rate.
 export const elevenLabsFormat = "mp3_44100_128";
+const modelList = z.array(z.object({
+    model_id: z.string().min(1),
+    name: z.string().optional(),
+    can_do_text_to_speech: z.boolean().optional(),
+}));
 // A wire payload is narrowed, never cast. `detail` is an object on a handled failure and
 // a string on the framework's own; anything else falls back to the raw text.
 const errorBody = z.object({
@@ -25,6 +38,24 @@ export function elevenLabsTts(deps) {
     return {
         id: "elevenlabs",
         capabilities: { streams: true },
+        models: async () => {
+            const response = await deps.fetch(`${elevenLabsBase}/models`, {
+                headers: { "xi-api-key": keyOf(deps) },
+                signal: AbortSignal.timeout(10_000),
+            });
+            if (!response.ok)
+                throw await failure(response);
+            const parsed = modelList.safeParse(safeJson(await response.text()));
+            if (!parsed.success) {
+                throw providerError({
+                    kind: "other",
+                    message: "ElevenLabs' model list was not in the shape this app can read",
+                });
+            }
+            return parsed.data
+                .filter((model) => model.can_do_text_to_speech === true)
+                .map((model) => ({ id: model.model_id, name: model.name || model.model_id }));
+        },
         synthesize: async (req) => {
             const voice = encodeURIComponent(req.voiceId);
             const response = await deps.fetch(`${elevenLabsBase}/text-to-speech/${voice}/stream?output_format=${elevenLabsFormat}`, {
@@ -33,7 +64,7 @@ export function elevenLabsTts(deps) {
                 headers: { "xi-api-key": keyOf(deps), "Content-Type": "application/json" },
                 // No pre-check on length. A text past the model's limit comes
                 // back as the provider's own 400 and that is what the stage shows.
-                body: JSON.stringify({ text: req.text, model_id: elevenLabsModel }),
+                body: JSON.stringify({ text: req.text, model_id: req.model ?? elevenLabsModel }),
             });
             if (!response.ok) {
                 throw await failure(response, req.voiceId);
@@ -75,7 +106,7 @@ async function failure(response, voiceId) {
         kind: kindOf(response.status),
         // A rejected voice ID has to be named, and it is the one part of the
         // request the user chose. It is not secret, unlike everything else on the wire.
-        message: `ElevenLabs answered ${response.status} for voice ${voiceId}: ${message}`,
+        message: `ElevenLabs answered ${response.status}${voiceId === undefined ? "" : ` for voice ${voiceId}`}: ${message}`,
         ...(retryAfterMs === undefined ? {} : { retryAfterMs }),
     });
 }

package/dist/adapters/tts/inworld-async.js

@@ -0,0 +1,150 @@
+import { z } from "zod";
+import { redact } from "../../kernel/log.js";
+import { providerError } from "../../kernel/ports/model.js";
+import { retryAfter } from "../retry-after.js";
+const operationName = /^workspaces\/[A-Za-z0-9_-]+\/ttsAsyncJobs\/[A-Za-z0-9_-]+\/operations\/[A-Za-z0-9_-]+$/;
+const operationSchema = z.object({
+    name: z.string().regex(operationName),
+    done: z.boolean().optional(),
+    error: z.object({ code: z.number().optional(), message: z.string().optional() }).nullish(),
+    response: z.object({ audioUri: z.string() }).nullish(),
+});
+// Async is documented for TTS-2 only. Flash continues using the streaming API.
+// A continuation survives automatic retries of this call; pausing/restarting a
+// stage stops local polling but cannot cancel an already accepted remote job.
+export async function* inworldAsync(deps, request, key) {
+    if (request.text.length > 100_000) {
+        throw providerError({
+            kind: "unsupported",
+            message: "Inworld async accepts up to 100,000 characters per request (10,000 for On-Demand accounts). Select paragraph chunking for longer articles.",
+        });
+    }
+    const headers = { Authorization: `Basic ${key}`, "Content-Type": "application/json" };
+    const saved = request.continuation?.read();
+    if (saved && !operationName.test(saved))
+        throw invalid("returned an invalid operation name");
+    request.signal.throwIfAborted();
+    let response = await deps.fetch(saved
+        ? `https://api.inworld.ai/lro/v1alpha/${saved}`
+        : "https://api.inworld.ai/tts/v1/voice:synthesizeAsync", {
+        method: saved ? "GET" : "POST",
+        headers,
+        signal: request.signal,
+        redirect: "error",
+        ...(saved
+            ? {}
+            : {
+                body: JSON.stringify({
+                    text: request.text,
+                    voiceId: request.voiceId,
+                    modelId: request.model ?? "inworld-tts-2",
+                    audioConfig: { audioEncoding: "MP3", sampleRateHertz: 48_000, bitRate: 128_000 },
+                }),
+            }),
+    });
+    let expected = saved;
+    for (;;) {
+        request.signal.throwIfAborted();
+        await check(response, key);
+        const parsed = operationSchema.safeParse(await response.json().catch(() => null));
+        if (!parsed.success || (expected && parsed.data.name !== expected))
+            throw invalid("returned an invalid operation");
+        const operation = parsed.data;
+        expected = operation.name;
+        request.continuation?.write(operation.name);
+        request.onActivity?.();
+        request.signal.throwIfAborted();
+        if (operation.done) {
+            if (operation.error) {
+                const { code, message } = operation.error;
+                throw providerError({
+                    kind: code === 7 || code === 16
+                        ? "auth"
+                        : code === 8
+                            ? "rate_limit"
+                            : code === 3 || code === 5 || code === 9
+                                ? "unsupported"
+                                : "other",
+                    message: `Inworld async job failed: ${clean(message ?? "audio generation stopped", key)}`,
+                });
+            }
+            if (!operation.response)
+                throw invalid("finished without an audio download");
+            yield* download(deps.fetch, operation.response.audioUri, request.signal);
+            return;
+        }
+        await deps.clock.sleep(5000, request.signal);
+        request.signal.throwIfAborted();
+        response = await deps.fetch(`https://api.inworld.ai/lro/v1alpha/${operation.name}`, {
+            headers,
+            signal: request.signal,
+            redirect: "error",
+        });
+    }
+}
+async function* download(fetch, uri, signal) {
+    const url = URL.parse(uri);
+    if (url?.protocol !== "https:" || url.username || url.password)
+        throw invalid("returned an invalid audio download URL");
+    // This is a signed storage URL, not an Inworld API endpoint. Never forward Basic auth.
+    let response;
+    try {
+        response = await fetch(url.href, { signal, redirect: "error" });
+    }
+    catch {
+        signal.throwIfAborted();
+        // Signed query parameters must not become a persisted error or log entry.
+        throw invalid("audio download could not be reached; retrying the existing job");
+    }
+    if (!response.ok)
+        throw invalid(`audio download answered ${response.status}; retrying the existing job`);
+    if (!response.body)
+        throw invalid("answered with no audio");
+    const reader = response.body.getReader();
+    let heard = false;
+    try {
+        for (;;) {
+            const { value, done } = await reader.read();
+            signal.throwIfAborted();
+            if (done)
+                break;
+            if (value.length) {
+                heard = true;
+                yield value;
+            }
+        }
+    }
+    catch {
+        signal.throwIfAborted();
+        throw invalid("audio download stopped; retrying the existing job");
+    }
+    finally {
+        await reader.cancel().catch(() => { });
+        reader.releaseLock();
+    }
+    if (!heard)
+        throw invalid("answered with no audio");
+}
+async function check(response, key) {
+    if (response.ok)
+        return;
+    const detail = clean(await response.text().catch(() => ""), key);
+    const retryAfterMs = retryAfter(response.headers.get("retry-after"));
+    throw providerError({
+        kind: response.status === 401 || response.status === 403
+            ? "auth"
+            : response.status === 429
+                ? "rate_limit"
+                : response.status === 400 || response.status === 404
+                    ? "unsupported"
+                    : "other",
+        message: `Inworld async answered ${response.status}: ${detail || response.statusText}`,
+        ...(retryAfterMs === undefined ? {} : { retryAfterMs }),
+    });
+}
+function clean(message, key) {
+    return redact(message.replaceAll(key, "[redacted]"));
+}
+function invalid(detail) {
+    return providerError({ kind: "other", message: `Inworld ${detail}.` });
+}

package/dist/adapters/tts/inworld-text.js

@@ -0,0 +1,32 @@
+// Inworld's streaming endpoint accepts 4,000 characters. Split inside the
+// adapter so whole-text narration and long intros/outros all remain usable.
+// UTF-16 length is conservative for Unicode; never cut a surrogate pair.
+export function inworldTextParts(text) {
+    const parts = [];
+    let current = "";
+    for (const sentence of new Intl.Segmenter("en", { granularity: "sentence" }).segment(text)) {
+        if (current.length + sentence.segment.length <= 4000) {
+            current += sentence.segment;
+            continue;
+        }
+        if (current.trim())
+            parts.push(current.trim());
+        let remaining = sentence.segment;
+        while (remaining.length > 4000) {
+            const window = remaining.slice(0, 4000);
+            const boundary = Math.max(window.lastIndexOf(" "), window.lastIndexOf("\n"), window.lastIndexOf("\t"));
+            let cut = boundary > 0 ? boundary : 4000;
+            const last = remaining.charCodeAt(cut - 1);
+            if (last >= 0xd800 && last <= 0xdbff)
+                cut--;
+            const piece = remaining.slice(0, cut).trim();
+            if (piece)
+                parts.push(piece);
+            remaining = remaining.slice(cut).trimStart();
+        }
+        current = remaining;
+    }
+    if (current.trim())
+        parts.push(current.trim());
+    return parts;
+}

package/dist/adapters/tts/inworld.js

@@ -0,0 +1,170 @@
+import { z } from "zod";
+import { redact } from "../../kernel/log.js";
+import { providerError } from "../../kernel/ports/model.js";
+import { retryAfter } from "../retry-after.js";
+import { inworldAsync } from "./inworld-async.js";
+import { inworldTextParts } from "./inworld-text.js";
+export const inworldModels = [
+    { id: "inworld-tts-2", name: "Realtime TTS-2" },
+    { id: "inworld-tts-2-flash", name: "Realtime TTS-2 Flash" },
+];
+const envelope = z.object({
+    result: z.object({ audioContent: z.string().optional() }).optional(),
+    error: z.object({ code: z.number().optional(), message: z.string().optional() }).optional(),
+});
+export function inworldTts(deps) {
+    return {
+        id: "inworld",
+        capabilities: { streams: true },
+        models: async () => inworldModels,
+        synthesize: async (request) => {
+            const key = deps
+                .key()
+                ?.trim()
+                .replace(/^Basic\s+/i, "");
+            if (!key)
+                throw providerError({ kind: "missing_key", message: "No Inworld API key is stored." });
+            const cancel = new AbortController();
+            const signal = AbortSignal.any([request.signal, cancel.signal]);
+            const iterator = synthesizeParts(deps, { ...request, signal }, key);
+            return {
+                container: "mp3",
+                audio: new ReadableStream({
+                    async pull(controller) {
+                        try {
+                            const next = await iterator.next();
+                            if (next.done)
+                                controller.close();
+                            else
+                                controller.enqueue(next.value);
+                        }
+                        catch (error) {
+                            controller.error(error);
+                        }
+                    },
+                    async cancel() {
+                        cancel.abort();
+                        await iterator.return();
+                    },
+                }, { highWaterMark: 0 }),
+            };
+        },
+    };
+}
+async function* synthesizeParts(deps, request, key) {
+    if ((request.model ?? "inworld-tts-2") === "inworld-tts-2" && request.text.length > 4000) {
+        yield* inworldAsync(deps, request, key);
+        return;
+    }
+    const parts = inworldTextParts(request.text);
+    if (parts.length === 0)
+        throw providerError({ kind: "unsupported", message: "Inworld needs text to narrate." });
+    for (const text of parts) {
+        request.signal.throwIfAborted();
+        const response = await deps.fetch("https://api.inworld.ai/tts/v1/voice:stream", {
+            method: "POST",
+            redirect: "error",
+            signal: request.signal,
+            headers: { Authorization: `Basic ${key}`, "Content-Type": "application/json" },
+            body: JSON.stringify({
+                text,
+                voiceId: request.voiceId,
+                modelId: request.model ?? "inworld-tts-2",
+                audioConfig: { audioEncoding: "MP3", sampleRateHertz: 48_000, bitRate: 128_000 },
+            }),
+        });
+        if (!response.ok) {
+            const detail = clean(await response.text().catch(() => ""), key);
+            const retryAfterMs = retryAfter(response.headers.get("retry-after"));
+            throw providerError({
+                kind: response.status === 401 || response.status === 403
+                    ? "auth"
+                    : response.status === 429
+                        ? "rate_limit"
+                        : response.status === 400 || response.status === 404
+                            ? "unsupported"
+                            : "other",
+                message: clean(`Inworld answered ${response.status} for voice ${request.voiceId}: ${detail || response.statusText}`, key),
+                ...(retryAfterMs === undefined ? {} : { retryAfterMs }),
+            });
+        }
+        if (response.body === null)
+            throw invalid("answered with no audio");
+        let heard = false;
+        for await (const line of lines(response.body)) {
+            request.signal.throwIfAborted();
+            let raw;
+            try {
+                raw = JSON.parse(line);
+            }
+            catch {
+                throw invalid("sent an unreadable audio chunk");
+            }
+            const parsed = envelope.safeParse(raw);
+            if (!parsed.success || (!parsed.data.result && !parsed.data.error))
+                throw invalid("sent an unreadable audio chunk");
+            if (parsed.data.error) {
+                const { code, message } = parsed.data.error;
+                throw providerError({
+                    kind: code === 16 || code === 7
+                        ? "auth"
+                        : code === 8
+                            ? "rate_limit"
+                            : code === 3 || code === 5
+                                ? "unsupported"
+                                : "other",
+                    message: `Inworld stream failed: ${clean(message ?? "audio generation stopped", key)}`,
+                });
+            }
+            const encoded = parsed.data.result?.audioContent;
+            if (!encoded)
+                continue;
+            if (!/^[A-Za-z0-9+/]*={0,2}$/.test(encoded) || encoded.length % 4 === 1)
+                throw invalid("sent invalid encoded audio");
+            const audio = Buffer.from(encoded, "base64");
+            if (audio.length === 0)
+                continue;
+            heard = true;
+            yield audio;
+        }
+        if (!heard)
+            throw invalid("answered with no audio");
+    }
+}
+async function* lines(body) {
+    const reader = body.getReader();
+    const decoder = new TextDecoder();
+    let pending = "";
+    try {
+        for (;;) {
+            const { done, value } = await reader.read();
+            pending += done ? decoder.decode() : decoder.decode(value, { stream: true });
+            let end = pending.indexOf("\n");
+            while (end !== -1) {
+                if (end > 8 * 1024 * 1024)
+                    throw invalid("sent an oversized audio chunk");
+                const line = pending.slice(0, end).trim();
+                pending = pending.slice(end + 1);
+                if (line)
+                    yield line;
+                end = pending.indexOf("\n");
+            }
+            if (pending.length > 8 * 1024 * 1024)
+                throw invalid("sent an oversized audio chunk");
+            if (done)
+                break;
+        }
+        if (pending.trim())
+            yield pending.trim();
+    }
+    finally {
+        await reader.cancel().catch(() => { });
+        reader.releaseLock();
+    }
+}
+function clean(message, key) {
+    return redact(message.replaceAll(key, "[redacted]"));
+}
+function invalid(detail) {
+    return providerError({ kind: "other", message: `Inworld ${detail}.` });
+}

package/dist/adapters/tts/openai.js

@@ -5,9 +5,18 @@ import { retryAfter } from "../retry-after.js";
 // The HTTP gateway adapter for OpenAI's speech endpoint. `fetch` and nothing else; the response
 // body is already the stream the port asks for.
 export const openAiAudioBase = "https://api.openai.com/v1";
-// gpt-4o-mini-tts, tts-1 and tts-1-hd; the first is the current one and the cheapest of the
-// three per character.
+// Older callers can omit a model; saved project choices always supply one.
 export const openAiTtsModel = "gpt-4o-mini-tts";
+export const openAiTtsModels = [
+    { id: "gpt-4o-mini-tts", name: "GPT-4o mini TTS" },
+    { id: "gpt-4o-mini-tts-2025-12-15", name: "GPT-4o mini TTS (2025-12-15)" },
+    { id: "tts-1", name: "TTS-1" },
+    { id: "tts-1-hd", name: "TTS-1 HD" },
+];
+const modelList = z.object({ data: z.array(z.object({ id: z.string().min(1) })) });
+// /models has no capability metadata. Only the speech endpoint's documented model families
+// and dated snapshots belong here; realtime and transcription models use different APIs.
+const speechModel = /^(?:tts-1(?:-hd)?(?:-\d{4})?|gpt-4o-mini-tts(?:-\d{4}-\d{2}-\d{2})?)$/;
 const errorBody = z.object({
     error: z.object({ message: z.string(), code: z.string().nullish() }),
 });
@@ -19,6 +28,24 @@ export function openAiTts(deps) {
     return {
         id: "openai-tts",
         capabilities: { streams: true },
+        models: async () => {
+            const response = await deps.fetch(`${openAiAudioBase}/models`, {
+                headers: { Authorization: `Bearer ${keyOf(deps)}` },
+                signal: AbortSignal.timeout(10_000),
+            });
+            if (!response.ok)
+                throw await failure(response);
+            const parsed = modelList.safeParse(safeJson(await response.text()));
+            if (!parsed.success) {
+                throw providerError({
+                    kind: "other",
+                    message: "OpenAI's model list was not in the shape this app can read",
+                });
+            }
+            return parsed.data.data
+                .filter((model) => speechModel.test(model.id))
+                .map((model) => ({ id: model.id, name: model.id }));
+        },
         synthesize: async (req) => {
             const response = await deps.fetch(`${openAiAudioBase}/audio/speech`, {
                 method: "POST",
@@ -31,7 +58,7 @@ export function openAiTts(deps) {
                 // 400 and that is what the stage shows, so a user who chose Whole text learns the limit
                 // from the provider that set it.
                 body: JSON.stringify({
-                    model: openAiTtsModel,
+                    model: req.model ?? openAiTtsModel,
                     input: req.text,
                     voice: voiceOf(req.voiceId),
                     response_format: "mp3",
@@ -80,7 +107,7 @@ async function failure(response, voiceId) {
         kind: kindOf(response.status),
         // The voice ID is named, so a rejected voice reads differently from
         // a rejected key.
-        message: `OpenAI answered ${response.status} for voice ${voiceId}: ${message}`,
+        message: `OpenAI answered ${response.status}${voiceId === undefined ? "" : ` for voice ${voiceId}`}: ${message}`,
         ...(retryAfterMs === undefined ? {} : { retryAfterMs }),
     });
 }