runline 0.31.0 → 0.33.0

package/dist/plugins/elevenlabs/src/schemas.js

@@ -0,0 +1,115 @@
+import * as t from "typebox";
+export const STRICT = { additionalProperties: false };
+export const text = t.String({ minLength: 1, pattern: "\\S" });
+export const timeout = t.Integer({
+    minimum: 1000,
+    maximum: 3_600_000,
+    default: 300_000,
+    description: "Request deadline including the response body; does not cancel provider work.",
+});
+export const fileOptions = {
+    saveDir: t.Optional(text),
+    timeoutMs: t.Optional(timeout),
+};
+export const seed = t.Integer({ minimum: 0, maximum: 4294967295 });
+export const normalization = t.Union([
+    t.Literal("auto"),
+    t.Literal("on"),
+    t.Literal("off"),
+]);
+export const dictionaries = t.Array(t.Object({ pronunciation_dictionary_id: text, version_id: t.Optional(text) }, STRICT), { maxItems: 3 });
+const rates = [8000, 16000, 22050, 24000, 32000, 44100, 48000];
+const mp3 = [
+    "mp3_22050_32",
+    "mp3_24000_48",
+    ...[32, 64, 96, 128, 192].map((rate) => `mp3_44100_${rate}`),
+];
+const compressedAndRaw = [
+    ...mp3,
+    ...rates.map((rate) => `pcm_${rate}`),
+    ...[32, 64, 96, 128, 192].map((rate) => `opus_48000_${rate}`),
+];
+export const formatSchema = (kind) => t.Union([
+    ...compressedAndRaw,
+    ...(kind === "speech" ? rates.map((rate) => `wav_${rate}`) : []),
+    ...(kind === "music"
+        ? ["auto", ...[128, 192, 240, 320].map((rate) => `mp3_48000_${rate}`)]
+        : []),
+].map((value) => t.Literal(value)), {
+    default: kind === "music" ? "auto" : "mp3_44100_128",
+    description: "Provider output format. PCM is raw audio without a WAV header; retain the sample rate and endpoint-specific channel layout. Higher-quality formats may require a paid tier.",
+});
+export const audioOptions = {
+    ...fileOptions,
+    outputFormat: t.Optional(formatSchema("speech")),
+};
+export const voiceSettings = t.Object({
+    stability: t.Optional(t.Number({ minimum: 0, maximum: 1 })),
+    similarity_boost: t.Optional(t.Number({ minimum: 0, maximum: 1 })),
+    style: t.Optional(t.Number({ minimum: 0, maximum: 1 })),
+    use_speaker_boost: t.Optional(t.Boolean()),
+    speed: t.Optional(t.Number({ minimum: 0.7, maximum: 1.2 })),
+}, STRICT);
+export const speechControls = {
+    seed: t.Optional(seed),
+    pronunciationDictionaries: t.Optional(dictionaries),
+    normalization: t.Optional(normalization),
+    languageNormalization: t.Optional(t.Boolean({
+        description: "Language-specific normalization; currently Japanese only, may increase latency.",
+    })),
+    previousText: t.Optional(t.String()),
+    nextText: t.Optional(t.String()),
+    previousRequestIds: t.Optional(t.Array(text, { maxItems: 3 })),
+    nextRequestIds: t.Optional(t.Array(text, { maxItems: 3 })),
+};
+const styles = t.Array(t.String(), { maxItems: 50 });
+const duration = t.Integer({ minimum: 3000, maximum: 120000 });
+const v1Plan = t.Object({
+    positive_global_styles: styles,
+    negative_global_styles: styles,
+    sections: t.Array(t.Object({
+        section_name: t.String({ minLength: 1, maxLength: 100 }),
+        positive_local_styles: styles,
+        negative_local_styles: styles,
+        duration_ms: duration,
+        lines: t.Array(t.String({ maxLength: 200 }), { maxItems: 30 }),
+    }, STRICT), { minItems: 1, maxItems: 30 }),
+}, STRICT);
+const v2Plan = t.Object({
+    chunks: t.Array(t.Object({
+        text: t.String({ maxLength: 6132 }),
+        duration_ms: duration,
+        positive_styles: styles,
+        negative_styles: t.Optional(styles),
+        context_adherence: t.Optional(t.Union([t.Literal("low"), t.Literal("medium"), t.Literal("high")])),
+    }, STRICT), { minItems: 1, maxItems: 30 }),
+}, STRICT);
+export const musicSchema = t.Union([
+    t.Object({
+        ...fileOptions,
+        outputFormat: t.Optional(formatSchema("music")),
+        prompt: t.String({ minLength: 1, maxLength: 4100, pattern: "\\S" }),
+        durationMs: t.Integer({ minimum: 3000, maximum: 600000 }),
+        model: t.Optional(t.Union([
+            t.Literal("music_v1"),
+            t.Literal("music_v2"),
+            t.Literal("music_v2_5"),
+        ])),
+        instrumental: t.Optional(t.Boolean()),
+    }, STRICT),
+    t.Object({
+        ...fileOptions,
+        outputFormat: t.Optional(formatSchema("music")),
+        model: t.Literal("music_v1"),
+        compositionPlan: v1Plan,
+        seed: t.Optional(t.Integer({ minimum: 0, maximum: 2147483647 })),
+        respectSectionsDurations: t.Optional(t.Boolean()),
+    }, STRICT),
+    t.Object({
+        ...fileOptions,
+        outputFormat: t.Optional(formatSchema("music")),
+        model: t.Union([t.Literal("music_v2"), t.Literal("music_v2_5")]),
+        compositionPlan: v2Plan,
+        seed: t.Optional(t.Integer({ minimum: 0, maximum: 2147483647 })),
+    }, STRICT),
+]);

package/dist/plugins/elevenlabs/src/shared.js

@@ -0,0 +1,272 @@
+import { constants } from "node:fs";
+import { open } from "node:fs/promises";
+import { basename } from "node:path";
+import * as t from "typebox";
+import { Check } from "typebox/value";
+import { authedFetch } from "../../_shared/authedFetch.js";
+import { SEND_FILE_NOTE, writeMediaFile } from "../../_shared/mediaFile.js";
+import { obj, readBounded, readBoundedBytes, seg, } from "../../_shared/provider.js";
+export const voicePath = (id) => seg(id, "voice id", "elevenlabs");
+const JSON_LIMIT = 8 * 1024 * 1024;
+const AUDIO_LIMIT = 100 * 1024 * 1024;
+/** A fixed origin, no redirects or retries, and one deadline through body consumption. */
+async function request(ctx, path, init, timeoutMs, consume) {
+    const key = ctx.connection.config.apiKey;
+    if (typeof key !== "string" || !key.trim())
+        throw new Error("Missing ELEVENLABS_API_KEY");
+    let requestId = null;
+    try {
+        const response = await authedFetch(`https://api.elevenlabs.io${path}`, {
+            ...init,
+            headers: {
+                "xi-api-key": key.trim(),
+                ...(typeof init.body === "string"
+                    ? { "content-type": "application/json" }
+                    : {}),
+            },
+            signal: AbortSignal.timeout(timeoutMs),
+        });
+        requestId = response.headers.get("request-id");
+        // Both JSON and audio errors use the provider's JSON error envelope.
+        if (!response.ok)
+            await json(response);
+        return await consume(response);
+    }
+    catch (error) {
+        const mutation = init.method && init.method !== "GET";
+        throw new Error(`${error instanceof Error ? error.message : String(error)}${requestId ? ` (requestId ${requestId})` : ""}${mutation ? ". Request may have been applied or billed; do not retry automatically." : ""}`, { cause: error });
+    }
+}
+async function json(response, limit = JSON_LIMIT) {
+    const text = await readBounded(response, limit, `elevenlabs: JSON exceeds ${limit / (1024 * 1024)} MiB`);
+    let body;
+    try {
+        body = text ? JSON.parse(text) : null;
+    }
+    catch {
+        throw new Error(`elevenlabs HTTP ${response.status}: non-JSON response`);
+    }
+    if (!response.ok) {
+        const detail = obj(body).detail;
+        const error = obj(detail);
+        // Include provider error messages and locations, not validation input payloads.
+        const message = typeof detail === "string"
+            ? detail
+            : Array.isArray(detail)
+                ? detail
+                    .map((v) => {
+                    const e = obj(v);
+                    return `${Array.isArray(e.loc) ? e.loc.join(".") : "body"}: ${e.msg ?? "invalid"}`;
+                })
+                    .join("; ")
+                : `${error.status ?? "request failed"}: ${error.message ?? ""}`;
+        throw new Error(`elevenlabs HTTP ${response.status}: ${message.slice(0, 1000)}`);
+    }
+    if (body === null || typeof body !== "object")
+        throw new Error("elevenlabs: expected a JSON object or array");
+    return body;
+}
+const id = t.String({ minLength: 1 });
+// Validate the fields callers depend on; preserve additional provider metadata.
+const voiceResponse = t.Object({ voice_id: id, name: t.String() });
+const responses = {
+    models: t.Array(t.Object({ model_id: id, name: t.String() })),
+    voices: t.Object({
+        voices: t.Array(voiceResponse),
+        has_more: t.Boolean(),
+        next_page_token: t.Optional(t.Union([id, t.Null()])),
+    }),
+    voice: voiceResponse,
+    clone: t.Object({ voice_id: id, requires_verification: t.Boolean() }),
+    acknowledgement: t.Object({ status: t.Literal("ok") }),
+    transcription: t.Union([
+        t.Object({ text: t.String(), words: t.Array(t.Unknown()) }),
+        t.Object({
+            transcripts: t.Array(t.Object({ text: t.String(), words: t.Array(t.Unknown()) }), { minItems: 1 }),
+        }),
+    ]),
+    history: t.Object({
+        history: t.Array(t.Object({ history_item_id: id })),
+        has_more: t.Boolean(),
+        last_history_item_id: t.Optional(t.Union([id, t.Null()])),
+    }),
+    historyItem: t.Object({ history_item_id: id, content_type: t.String() }),
+    settings: t.Object({
+        stability: t.Optional(t.Union([t.Number(), t.Null()])),
+        similarity_boost: t.Optional(t.Union([t.Number(), t.Null()])),
+        style: t.Optional(t.Union([t.Number(), t.Null()])),
+        speed: t.Optional(t.Union([t.Number(), t.Null()])),
+        use_speaker_boost: t.Optional(t.Union([t.Boolean(), t.Null()])),
+    }),
+    dictionaries: t.Object({
+        pronunciation_dictionaries: t.Array(t.Object({ id, name: t.String(), latest_version_id: id })),
+        has_more: t.Boolean(),
+        next_cursor: t.Optional(t.Union([id, t.Null()])),
+    }),
+    dictionary: t.Object({ id, version_id: id }),
+};
+export async function jsonRequest(ctx, path, expected, init = {}, timeoutMs = 60_000) {
+    return request(ctx, path, init, timeoutMs, async (response) => {
+        const body = await json(response);
+        if (!Check(responses[expected], body))
+            throw new Error(`elevenlabs: invalid ${expected} response`);
+        const cursor = {
+            voices: "next_page_token",
+            history: "last_history_item_id",
+            dictionaries: "next_cursor",
+        };
+        if (expected in cursor &&
+            obj(body).has_more &&
+            !obj(body)[cursor[expected]])
+            throw new Error("elevenlabs: page is missing its continuation token");
+        return body;
+    });
+}
+const alignment = t.Object({
+    characters: t.Array(t.String()),
+    character_start_times_seconds: t.Array(t.Number({ minimum: 0 })),
+    character_end_times_seconds: t.Array(t.Number({ minimum: 0 })),
+});
+const alignedAudio = t.Object({
+    audio_base64: t.String({
+        minLength: 1,
+        pattern: "^[A-Za-z0-9+/]*={0,2}$",
+    }),
+    alignment: t.Optional(t.Union([alignment, t.Null()])),
+    normalized_alignment: t.Optional(t.Union([alignment, t.Null()])),
+});
+/** Requested formats resolve generic headers; explicit audio types must agree. */
+function audioMime(format, contentType) {
+    const mime = contentType?.split(";")[0].trim().toLowerCase();
+    const supported = [
+        "audio/mpeg",
+        "audio/mp3",
+        "audio/wav",
+        "audio/x-wav",
+        "audio/ogg",
+        "audio/opus",
+        "audio/x-pcm",
+        "audio/pcm",
+    ];
+    if (mime && mime !== "application/octet-stream" && !supported.includes(mime))
+        throw new Error(`elevenlabs: expected audio, received ${mime}`);
+    const expected = format?.startsWith("pcm_")
+        ? "audio/x-pcm"
+        : format?.startsWith("wav_")
+            ? "audio/wav"
+            : format?.startsWith("opus_")
+                ? "audio/ogg"
+                : format === "auto" || format?.startsWith("mp3_")
+                    ? "audio/mpeg"
+                    : undefined;
+    const aliases = {
+        "audio/mp3": "audio/mpeg",
+        "audio/x-wav": "audio/wav",
+        "audio/pcm": "audio/x-pcm",
+        "audio/opus": "audio/ogg",
+    };
+    const actual = mime && supported.includes(mime) ? (aliases[mime] ?? mime) : undefined;
+    if (expected && actual && expected !== actual)
+        throw new Error(`elevenlabs: audio format mismatch: expected ${expected}, received ${actual}`);
+    const resolved = actual ?? expected;
+    if (!resolved)
+        throw new Error("elevenlabs: response has no identifiable audio format");
+    return resolved;
+}
+export async function audioRequest(ctx, path, body, options) {
+    const format = options.outputFormat ?? "mp3_44100_128";
+    return binaryRequest(ctx, `${path}?output_format=${encodeURIComponent(format)}`, {
+        method: "POST",
+        body: body instanceof FormData ? body : JSON.stringify(body),
+    }, { ...options, outputFormat: format });
+}
+/** All generated, aligned, isolated, and recovered audio uses the same file writer. */
+export async function binaryRequest(ctx, path, init, options) {
+    return request(ctx, path, init, options.timeoutMs ?? 300_000, async (response) => {
+        let bytes;
+        let timestamps = {};
+        let mime;
+        if (options.timestamps) {
+            const body = await json(response, 32 * 1024 * 1024);
+            if (!Check(alignedAudio, body) || body.audio_base64.length % 4 !== 0)
+                throw new Error("elevenlabs: invalid aligned audio response");
+            for (const a of [body.alignment, body.normalized_alignment]) {
+                if (a &&
+                    (a.characters.length !== a.character_start_times_seconds.length ||
+                        a.characters.length !== a.character_end_times_seconds.length ||
+                        a.character_end_times_seconds.some((end, i) => end < a.character_start_times_seconds[i])))
+                    throw new Error("elevenlabs: invalid alignment lengths or times");
+            }
+            bytes = Buffer.from(body.audio_base64, "base64");
+            timestamps = {
+                alignment: body.alignment,
+                normalizedAlignment: body.normalized_alignment,
+            };
+            mime = audioMime(options.outputFormat, null);
+        }
+        else {
+            try {
+                mime = audioMime(options.outputFormat, response.headers.get("content-type"));
+            }
+            catch (error) {
+                await response.body?.cancel();
+                throw error;
+            }
+            bytes = await readBoundedBytes(response, AUDIO_LIMIT, "elevenlabs: audio exceeds 100 MiB");
+        }
+        if (!bytes.length)
+            throw new Error("elevenlabs: empty audio response");
+        const audio = writeMediaFile({
+            bytes,
+            mimeType: mime,
+            provider: "elevenlabs",
+            index: 0,
+            saveDir: options.saveDir,
+        });
+        return {
+            provider: "elevenlabs",
+            audio,
+            outputFormat: options.outputFormat ?? null,
+            requestId: response.headers.get("request-id"),
+            songId: response.headers.get("song-id"),
+            characterCost: response.headers.get("character-cost"),
+            ...timestamps,
+            note: SEND_FILE_NOTE,
+        };
+    });
+}
+export async function voiceForm(input) {
+    const form = new FormData();
+    form.append("name", input.name);
+    for (const path of input.audioPaths ?? [])
+        await appendFile(form, "files", path);
+    if (input.description !== undefined)
+        form.append("description", input.description);
+    if (input.labels !== undefined)
+        form.append("labels", JSON.stringify(input.labels));
+    if (input.removeBackgroundNoise !== undefined)
+        form.append("remove_background_noise", String(input.removeBackgroundNoise));
+    return form;
+}
+/** Bound uploads before allocating; read through the same handle to avoid stat/read races. */
+export async function appendFile(form, field, path) {
+    // Nonblocking open lets fstat reject FIFOs without waiting for a writer.
+    const file = await open(path, constants.O_RDONLY | constants.O_NONBLOCK);
+    try {
+        const stat = await file.stat();
+        if (!stat.isFile() || stat.size === 0 || stat.size > 25 * 1024 * 1024)
+            throw new Error("elevenlabs: each input must be a nonempty regular file of at most 25 MiB");
+        const bytes = Buffer.alloc(stat.size);
+        let offset = 0;
+        while (offset < bytes.length) {
+            const { bytesRead } = await file.read(bytes, offset, bytes.length - offset, offset);
+            if (!bytesRead)
+                throw new Error("elevenlabs: input file changed while reading");
+            offset += bytesRead;
+        }
+        form.append(field, new Blob([bytes]), basename(path));
+    }
+    finally {
+        await file.close();
+    }
+}

package/dist/plugins/elevenlabs/src/workflows.js

@@ -0,0 +1,191 @@
+import * as t from "typebox";
+import { seg } from "../../_shared/provider.js";
+import { audioOptions, dictionaries, fileOptions, normalization, STRICT, seed, text, voiceSettings, } from "./schemas.js";
+import { appendFile, audioRequest, binaryRequest, jsonRequest, voiceForm, voicePath, } from "./shared.js";
+const dialogue = t.Object({
+    ...audioOptions,
+    inputs: t.Array(t.Object({ text, voiceId: text }, STRICT), {
+        minItems: 1,
+        maxItems: 100,
+        description: "At most 10 unique voices and 2000 total characters per request.",
+    }),
+    model: t.Optional(text),
+    languageCode: t.Optional(t.String({ pattern: "^[a-z]{2}$" })),
+    stability: t.Optional(t.Number({ minimum: 0, maximum: 1 })),
+    seed: t.Optional(seed),
+    pronunciationDictionaries: t.Optional(dictionaries),
+    normalization: t.Optional(normalization),
+}, STRICT);
+const isolate = t.Object({ ...fileOptions, audioPath: text }, STRICT);
+const historyList = t.Object({
+    limit: t.Optional(t.Integer({ minimum: 1, maximum: 1000 })),
+    cursor: t.Optional(text),
+    voiceId: t.Optional(text),
+    model: t.Optional(text),
+    search: t.Optional(text),
+    source: t.Optional(t.Union([t.Literal("TTS"), t.Literal("STS"), t.Literal("Flows")])),
+}, STRICT);
+const historyItem = t.Object({ historyItemId: text }, STRICT);
+const historyDownload = t.Object({ historyItemId: text, ...fileOptions }, STRICT);
+const voice = t.Object({ voiceId: text }, STRICT);
+const settings = t.Object({
+    voiceId: text,
+    settings: t.Object(voiceSettings.properties, {
+        ...STRICT,
+        minProperties: 1,
+    }),
+}, STRICT);
+const editVoice = t.Object({
+    voiceId: text,
+    name: text,
+    description: t.Optional(t.String()),
+    labels: t.Optional(t.Record(t.String(), t.String())),
+    audioPaths: t.Optional(t.Array(text, { maxItems: 10 })),
+    removeBackgroundNoise: t.Optional(t.Boolean()),
+}, STRICT);
+const dictionaryList = t.Object({
+    cursor: t.Optional(text),
+    limit: t.Optional(t.Integer({ minimum: 1, maximum: 100 })),
+}, STRICT);
+const ruleOptions = {
+    string_to_replace: text,
+    case_sensitive: t.Optional(t.Boolean()),
+    word_boundaries: t.Optional(t.Boolean()),
+};
+const dictionaryCreate = t.Object({
+    name: text,
+    description: t.Optional(t.String()),
+    rules: t.Array(t.Union([
+        t.Object({ ...ruleOptions, type: t.Literal("alias"), alias: text }, STRICT),
+        t.Object({
+            ...ruleOptions,
+            type: t.Literal("phoneme"),
+            phoneme: text,
+            alphabet: text,
+        }, STRICT),
+    ]), { minItems: 1 }),
+}, STRICT);
+const historyPath = (id) => `/v1/history/${seg(id, "history item id", "elevenlabs")}`;
+export function registerWorkflows(rl) {
+    rl.registerAction("dialogue.create", {
+        access: "write",
+        description: "Generate multi-speaker dialogue with Eleven v3 (billed). Up to 10 voices and 2000 total characters. Returns audio.path.",
+        inputSchema: dialogue,
+        async execute(input, ctx) {
+            const p = input;
+            if (new Set(p.inputs.map((i) => i.voiceId)).size > 10 ||
+                p.inputs.reduce((sum, i) => sum + i.text.length, 0) > 2000)
+                throw new Error("elevenlabs: dialogue allows at most 10 voices and 2000 total characters");
+            return audioRequest(ctx, "/v1/text-to-dialogue", {
+                inputs: p.inputs.map((i) => ({ text: i.text, voice_id: i.voiceId })),
+                model_id: p.model ?? "eleven_v3",
+                language_code: p.languageCode,
+                settings: p.stability === undefined ? undefined : { stability: p.stability },
+                seed: p.seed,
+                pronunciation_dictionary_locators: p.pronunciationDictionaries,
+                apply_text_normalization: p.normalization,
+            }, p);
+        },
+    });
+    rl.registerAction("audio.isolate", {
+        access: "write",
+        description: "Remove background noise from a local recording (billed). Input up to 25 MiB. Saves the provider's output without transcoding.",
+        inputSchema: isolate,
+        async execute(input, ctx) {
+            const p = input;
+            const form = new FormData();
+            await appendFile(form, "audio", p.audioPath);
+            return binaryRequest(ctx, "/v1/audio-isolation", { method: "POST", body: form }, p);
+        },
+    });
+    rl.registerAction("history.list", {
+        access: "read",
+        description: "List speech history (TTS, STS, Flows), not a universal music/sound archive. Pass last_history_item_id as cursor while has_more is true. Zero-retention requests are unavailable.",
+        inputSchema: historyList,
+        async execute(input, ctx) {
+            const p = input;
+            const query = new URLSearchParams({ page_size: String(p.limit ?? 100) });
+            for (const [key, value] of Object.entries({
+                start_after_history_item_id: p.cursor,
+                voice_id: p.voiceId,
+                model_id: p.model,
+                search: p.search,
+                source: p.source,
+            }))
+                if (value !== undefined)
+                    query.set(key, value);
+            return jsonRequest(ctx, `/v1/history?${query}`, "history");
+        },
+    });
+    rl.registerAction("history.get", {
+        access: "read",
+        description: "Get one speech history item, including generation settings, text, and output format.",
+        inputSchema: historyItem,
+        async execute(input, ctx) {
+            return jsonRequest(ctx, historyPath(input.historyItemId), "historyItem");
+        },
+    });
+    rl.registerAction("history.download", {
+        access: "write",
+        description: "Recover existing speech audio without regenerating. Saves the downloaded response format to audio.path; the original generation format may differ.",
+        inputSchema: historyDownload,
+        async execute(input, ctx) {
+            const p = input;
+            return binaryRequest(ctx, `${historyPath(p.historyItemId)}/audio`, {}, p);
+        },
+    });
+    rl.registerAction("voices.settings.get", {
+        access: "read",
+        description: "Read a voice's saved synthesis settings.",
+        inputSchema: voice,
+        async execute(input, ctx) {
+            return jsonRequest(ctx, `/v1/voices/${voicePath(input.voiceId)}/settings`, "settings");
+        },
+    });
+    rl.registerAction("voices.settings.update", {
+        access: "write",
+        description: "Update a voice's saved synthesis settings. Omitted fields follow provider defaults; read voices.settings.get to construct complete settings when preserving other values. Affects future synthesis using that voice.",
+        inputSchema: settings,
+        async execute(input, ctx) {
+            const p = input;
+            return jsonRequest(ctx, `/v1/voices/${voicePath(p.voiceId)}/settings/edit`, "acknowledgement", { method: "POST", body: JSON.stringify(p.settings) });
+        },
+    });
+    rl.registerAction("voices.update", {
+        access: "write",
+        description: "Edit voice name, description, labels, and optionally add owned/authorized audio samples (25 MiB each). Name is required by the API.",
+        inputSchema: editVoice,
+        async execute(input, ctx) {
+            const p = input;
+            const path = `/v1/voices/${voicePath(p.voiceId)}/edit`;
+            return jsonRequest(ctx, path, "acknowledgement", {
+                method: "POST",
+                body: await voiceForm(p),
+            });
+        },
+    });
+    rl.registerAction("pronunciationDictionaries.list", {
+        access: "read",
+        description: "List pronunciation dictionaries and their latest version IDs for speech/dialogue generation. Pass next_cursor as cursor.",
+        inputSchema: dictionaryList,
+        async execute(input, ctx) {
+            const p = input;
+            const query = new URLSearchParams({
+                page_size: String(p.limit ?? 30),
+                include_archived: "false",
+            });
+            if (p.cursor)
+                query.set("cursor", p.cursor);
+            return jsonRequest(ctx, `/v1/pronunciation-dictionaries?${query}`, "dictionaries");
+        },
+    });
+    rl.registerAction("pronunciationDictionaries.create", {
+        access: "write",
+        description: "Create a pronunciation dictionary from alias or phoneme rules. Returns id and version_id; phoneme support depends on the synthesis model.",
+        inputSchema: dictionaryCreate,
+        async execute(input, ctx) {
+            const p = input;
+            return jsonRequest(ctx, "/v1/pronunciation-dictionaries/add-from-rules", "dictionary", { method: "POST", body: JSON.stringify(p) });
+        },
+    });
+}