runline 0.31.0 → 0.33.0

package/dist/plugin/schema.d.ts

@@ -18,10 +18,8 @@ export declare function validateLegacyInput(schema: LegacyInputSchema, input: un
 /**
  * A call written with no arguments is a call with an empty argument set.
  *
- * `linear.user.me()` is the most natural way to invoke an action that
- * takes nothing, and validating `undefined` against an object schema
- * rejected it every time. It also made a genuinely missing input report
- * "must be object" instead of naming the field.
+ * `linear.user.me()` supplies no argument, so object validation needs an
+ * empty object to accept no-input actions and name missing required fields.
  *
  * Only `undefined` is normalized: an explicit `null` or `42` is an
  * argument, and a wrong one.

package/dist/plugin/schema.js

@@ -53,12 +53,43 @@ export function helpInputs(schema) {
             },
         ]));
     }
-    const metadata = schema;
-    if (metadata.type !== "object")
-        return {};
-    return describeProperties(metadata, 0);
+    return describeProperties(schema, 0);
 }
 function describeProperties(schema, depth) {
+    if (depth > MAX_DESCRIBE_DEPTH)
+        return {};
+    const branches = branchesOf(schema);
+    if (branches && !schema.properties) {
+        const alternatives = branches.map((branch) => describeProperties(branch, depth + 1));
+        const names = new Set(alternatives.flatMap((fields) => Object.keys(fields)));
+        return Object.fromEntries([...names].map((name) => {
+            const fields = alternatives.flatMap((fields) => Object.hasOwn(fields, name)
+                ? [{ ...fields[name], required: false }]
+                : []);
+            // Descriptions are depth-bounded, so deduplication is safe for recursive schemas.
+            const unique = [
+                ...new Map(fields.map((field) => [JSON.stringify(field), field])).values(),
+            ];
+            const required = alternatives.every((fields) => Object.hasOwn(fields, name) && fields[name].required);
+            if (unique.length === 1)
+                return [name, { ...unique[0], required }];
+            const values = unique.map((field) => field.enum ??
+                (field.const !== undefined ? [field.const] : undefined));
+            return [
+                name,
+                {
+                    type: [...new Set(unique.map((field) => field.type))].join(" | "),
+                    displayType: [
+                        ...new Set(unique.map((field) => field.displayType)),
+                    ].join(" | "),
+                    required,
+                    ...(values.every((value) => value !== undefined)
+                        ? { enum: [...new Set(values.flat())] }
+                        : { variants: unique }),
+                },
+            ];
+        }));
+    }
     const required = new Set(schema.required ?? []);
     return Object.fromEntries(Object.entries(schema.properties ?? {}).map(([key, field]) => [
         key,
@@ -158,10 +189,8 @@ export function validateLegacyInput(schema, input) {
 /**
  * A call written with no arguments is a call with an empty argument set.
  *
- * `linear.user.me()` is the most natural way to invoke an action that
- * takes nothing, and validating `undefined` against an object schema
- * rejected it every time. It also made a genuinely missing input report
- * "must be object" instead of naming the field.
+ * `linear.user.me()` supplies no argument, so object validation needs an
+ * empty object to accept no-input actions and name missing required fields.
  *
  * Only `undefined` is normalized: an explicit `null` or `42` is an
  * argument, and a wrong one.
@@ -224,20 +253,26 @@ function branchesOf(schema) {
     const branches = schema.anyOf ?? schema.oneOf;
     return branches?.length ? branches : undefined;
 }
-function displayType(schema) {
+function displayType(schema, depth = 0) {
+    if (depth >= MAX_DESCRIBE_DEPTH)
+        return schema.type ?? "unknown";
     const branches = branchesOf(schema);
     if (branches)
-        return branches.map(displayType).join(" | ");
+        return branches.map((branch) => displayType(branch, depth + 1)).join(" | ");
     if (schema.enum?.length)
         return schema.enum.map(String).join(" | ");
     if (schema.const !== undefined)
         return JSON.stringify(schema.const);
     return schema.type ?? "unknown";
 }
-function baseType(schema) {
+function baseType(schema, depth = 0) {
+    if (depth >= MAX_DESCRIBE_DEPTH)
+        return schema.type ?? "unknown";
     const branches = branchesOf(schema);
     if (branches) {
-        const types = [...new Set(branches.map(baseType))];
+        const types = [
+            ...new Set(branches.map((branch) => baseType(branch, depth + 1))),
+        ];
         return types.length === 1 ? types[0] : types.join(" | ");
     }
     if (schema.type)

package/dist/plugins/_shared/{imageFile.js → mediaFile.js}

@@ -1,13 +1,14 @@
 /**
- * Shared helper for image-generation plugins: write generated bytes to a
+ * Shared helper for media-generating plugins: write generated bytes to a
  * file and return its path, instead of returning raw base64.
  *
- * Base64 image payloads in an action result bloat the agent context and are
+ * Base64 payloads in an action result bloat the agent context and are
  * stripped by many hosts before reaching the model, so the agent can never
- * actually deliver the image. A file `path` hands straight to a host
+ * actually deliver the file. A file `path` hands straight to a host
  * send_file/attachment tool. Plugins load in-process via jiti, so node:fs is
  * available (same pattern as googleDrive/googleSlides).
  */
+import { randomUUID } from "node:crypto";
 import { readFileSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { basename, extname, join } from "node:path";
@@ -18,26 +19,46 @@ const MIME_EXT = {
     "image/webp": "webp",
     "image/gif": "gif",
     "image/svg+xml": "svg",
+    "video/mp4": "mp4",
+    "video/webm": "webm",
+    "video/quicktime": "mov",
+    "audio/mpeg": "mp3",
+    "audio/mp3": "mp3",
+    "audio/wav": "wav",
+    "audio/x-wav": "wav",
+    "audio/ogg": "ogg",
+    "audio/opus": "opus",
+    "audio/x-pcm": "pcm",
 };
 export function extForMime(mimeType) {
     if (!mimeType)
         return "png";
-    return MIME_EXT[mimeType] ?? mimeType.split("/")[1]?.split("+")[0] ?? "png";
+    const mime = mimeType.split(";")[0].trim().toLowerCase();
+    return Object.hasOwn(MIME_EXT, mime) ? MIME_EXT[mime] : "bin";
 }
 /**
- * Decode base64 image bytes and write them to `saveDir` (or the OS temp dir),
- * named `<provider>-<stamp>-<index>.<ext>`. Returns the file path + size.
+ * Write media bytes with a unique name in `saveDir` (or the OS temp dir).
+ * Exclusive creation prevents overwrites and following a pre-existing file symlink.
  */
-export function writeImageFile(opts) {
+export function writeMediaFile(opts) {
     const mimeType = opts.mimeType ?? "image/png";
     const dir = (typeof opts.saveDir === "string" && opts.saveDir.trim()) || tmpdir();
-    const bytes = Buffer.from(opts.base64 ?? "", "base64");
     const stamp = opts.stamp ?? Date.now();
-    const path = join(dir, `${opts.provider}-${stamp}-${opts.index}.${extForMime(mimeType)}`);
-    writeFileSync(path, bytes);
-    return { path, mimeType, byteLength: bytes.length };
+    if (!/^[\w-]+$/.test(opts.provider))
+        throw new Error("invalid media provider name");
+    const path = join(dir, `${opts.provider}-${stamp}-${opts.index}-${randomUUID()}.${extForMime(mimeType)}`);
+    writeFileSync(path, opts.bytes, { flag: "wx", mode: 0o600 });
+    return { path, mimeType, byteLength: opts.bytes.byteLength };
+}
+/**
+ * Decode base64 media bytes and write them, for the providers that answer
+ * with base64 rather than a URL to download.
+ */
+export function writeImageFile(opts) {
+    const { base64, ...rest } = opts;
+    return writeMediaFile({ ...rest, bytes: Buffer.from(base64 ?? "", "base64") });
 }
-export const SEND_FILE_NOTE = "Image(s) written to disk. Deliver each to the user with send_file using its `path`.";
+export const SEND_FILE_NOTE = "File(s) written to disk. Deliver each to the user with send_file using its `path`.";
 const EXT_MIME = {
     png: "image/png",
     jpg: "image/jpeg",

package/dist/plugins/_shared/provider.js

@@ -1,7 +1,6 @@
 /**
- * Helpers for plugins that consume an undocumented provider JSON API over a
- * bearer token (gett, wolt): total readers for unshaped payloads, path-segment
- * safety, and a bounded body read.
+ * Provider helpers: total readers for unshaped JSON, path-segment safety,
+ * and bounded text or binary body reads.
  *
  * The readers are total by design. These payloads are deep and change without
  * notice, so a missing or wrongly-typed field yields the empty value for its
@@ -52,23 +51,30 @@ export function seg(value, what, plugin) {
  * make the process hold an unbounded string.
  */
 export async function readBounded(res, maxBytes, oversizeMessage) {
+    return new TextDecoder().decode(await readBoundedBytes(res, maxBytes, oversizeMessage));
+}
+/** Text and binary consumers share the same streaming byte limit. */
+export async function readBoundedBytes(res, maxBytes, oversizeMessage) {
     const reader = res.body?.getReader();
     if (!reader)
-        return "";
+        return new Uint8Array();
     const chunks = [];
     let total = 0;
-    for (;;) {
-        const { done, value } = await reader.read();
-        if (done)
-            break;
-        if (!value)
-            continue;
-        total += value.byteLength;
-        if (total > maxBytes) {
-            await reader.cancel();
-            throw new Error(oversizeMessage);
+    try {
+        for (;;) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            total += value.byteLength;
+            if (total > maxBytes) {
+                await reader.cancel();
+                throw new Error(oversizeMessage);
+            }
+            chunks.push(value);
         }
-        chunks.push(value);
+    }
+    finally {
+        reader.releaseLock();
     }
     const joined = new Uint8Array(total);
     let offset = 0;
@@ -76,5 +82,5 @@ export async function readBounded(res, maxBytes, oversizeMessage) {
         joined.set(chunk, offset);
         offset += chunk.byteLength;
     }
-    return new TextDecoder().decode(joined);
+    return joined;
 }

package/dist/plugins/_shared/shiftCloud.js

@@ -1,4 +1,6 @@
 import * as t from "typebox";
+import { authedFetch } from "./authedFetch.js";
+import { readBounded } from "./provider.js";
 export const STRICT_OBJECT = { additionalProperties: false };
 export const STRICT_UPDATE_OBJECT = {
     additionalProperties: false,
@@ -23,24 +25,46 @@ export function enumDescription(name, values) {
 export function enumSchema(name, values) {
     return t.Union(values.map((value) => t.Literal(value)), { description: enumDescription(name, values) });
 }
-const SHIFT_API_URL = "https://cloud.shift-labs.ai";
+export const SHIFT_API_URL = "https://cloud.shift-labs.ai";
 export function baseUrl() {
     return `${SHIFT_API_URL}/`;
 }
-export async function request(ctx, path, init = {}) {
-    const headers = new Headers(init.headers);
-    const apiKey = ctx.connection.config.apiKey;
-    if (typeof apiKey !== "string" || !apiKey) {
+/** Default deadline; endpoints that hold the request open pass their own. */
+export const SHIFT_REQUEST_TIMEOUT_MS = 60_000;
+const MAX_RESPONSE_BYTES = 16 * 1024 * 1024;
+/**
+ * The transport for every request carrying a Shift API key. Redirects are
+ * refused so the key never reaches another host; one deadline covers the
+ * whole exchange including the body, in place of any caller signal; the
+ * text body is read with a ceiling and returned buffered, so JSON and text
+ * callers consume it as usual.
+ */
+export async function shiftFetch(input, init = {}, timeoutMs = SHIFT_REQUEST_TIMEOUT_MS) {
+    const response = await authedFetch(input, {
+        ...init,
+        signal: AbortSignal.timeout(timeoutMs),
+    });
+    const text = await readBounded(response, MAX_RESPONSE_BYTES, "Shift API response exceeds 16 MiB");
+    return new Response(text || null, {
+        status: response.status,
+        statusText: response.statusText,
+        headers: response.headers,
+    });
+}
+export function apiKey(ctx) {
+    const key = ctx.connection.config.apiKey;
+    if (typeof key !== "string" || !key) {
         throw new Error("Shift Labs apiKey is required");
     }
-    headers.set("authorization", `Bearer ${apiKey}`);
+    return key;
+}
+export async function request(ctx, path, init = {}, timeoutMs = SHIFT_REQUEST_TIMEOUT_MS) {
+    const headers = new Headers(init.headers);
+    headers.set("authorization", `Bearer ${apiKey(ctx)}`);
     if (init.body && !headers.has("content-type")) {
         headers.set("content-type", "application/json");
     }
-    const response = await fetch(new URL(path, baseUrl()), {
-        ...init,
-        headers,
-    });
+    const response = await shiftFetch(new URL(path, baseUrl()), { ...init, headers }, timeoutMs);
     if (!response.ok) {
         throw new Error(`Shift Labs API error ${response.status}: ${await response.text()}`);
     }

package/dist/plugins/_shared/shiftUpload.js

@@ -95,7 +95,7 @@ async function fileBody(path, sizeBytes) {
         if (sizeBytes > MAX_BUFFERED_BYTES) {
             throw new Error("This runtime cannot stream uploads and the file is too large to buffer.");
         }
-        return await readFile(path);
+        return new Blob([await readFile(path)]);
     }
 }
 /**

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

@@ -0,0 +1,277 @@
+import * as t from "typebox";
+import { audioOptions, formatSchema, musicSchema as music, STRICT, seed, speechControls, text, timeout, voiceSettings, } from "./schemas.js";
+import { appendFile, audioRequest, jsonRequest, voiceForm, voicePath, } from "./shared.js";
+import { registerWorkflows } from "./workflows.js";
+const voice = t.Object({ voiceId: text }, STRICT);
+const speech = t.Object({
+    ...audioOptions,
+    voiceId: text,
+    text,
+    ...speechControls,
+    timestamps: t.Optional(t.Boolean({
+        description: "Return character alignment with the saved audio, not base64.",
+    })),
+    model: t.Optional(t.String({ default: "eleven_multilingual_v2", minLength: 1 })),
+    languageCode: t.Optional(t.String({
+        pattern: "^[a-z]{2}$",
+        description: "ISO 639-1 language. Not supported by eleven_multilingual_v2; use a compatible model such as Flash or Turbo.",
+    })),
+    voiceSettings: t.Optional(voiceSettings),
+}, STRICT);
+const convert = t.Object({
+    ...audioOptions,
+    voiceId: text,
+    audioPath: t.String({
+        minLength: 1,
+        description: "Local audio file, at most 25 MiB.",
+    }),
+    model: t.Optional(t.String({ default: "eleven_multilingual_sts_v2", minLength: 1 })),
+    voiceSettings: t.Optional(voiceSettings),
+    removeBackgroundNoise: t.Optional(t.Boolean()),
+    seed: t.Optional(seed),
+}, STRICT);
+const transcribe = t.Object({
+    filePath: t.Optional(t.String({
+        minLength: 1,
+        description: "Local audio/video file, at most 25 MiB. Exactly one of filePath or sourceUrl is required.",
+    })),
+    sourceUrl: t.Optional(t.String({
+        pattern: "^https://",
+        description: "Remote source fetched by ElevenLabs, not this host. Exactly one of filePath or sourceUrl is required.",
+    })),
+    timestampsGranularity: t.Optional(t.Union([t.Literal("none"), t.Literal("word"), t.Literal("character")])),
+    keyterms: t.Optional(t.Array(t.String({
+        minLength: 1,
+        maxLength: 49,
+        pattern: "^[^<>{}\\[\\]\\\\]+$",
+    }), {
+        maxItems: 1000,
+        description: "Up to 5 words per term. Adds 20% cost; over 100 terms has a 20-second minimum billable duration.",
+    })),
+    multiChannel: t.Optional(t.Boolean({
+        description: "Transcribe up to 5 channels independently; each channel is billed at the full audio duration.",
+    })),
+    channelOutput: t.Optional(t.Union([t.Literal("separate"), t.Literal("combined")])),
+    model: t.Optional(t.Union([t.Literal("scribe_v1"), t.Literal("scribe_v2")], {
+        default: "scribe_v2",
+    })),
+    languageCode: t.Optional(text),
+    diarize: t.Optional(t.Boolean()),
+    numSpeakers: t.Optional(t.Integer({ minimum: 1, maximum: 32 })),
+    tagAudioEvents: t.Optional(t.Boolean()),
+    timeoutMs: t.Optional(timeout),
+}, STRICT);
+const list = t.Object({
+    limit: t.Optional(t.Integer({ minimum: 1, maximum: 100, default: 10 })),
+    cursor: t.Optional(text),
+    search: t.Optional(text),
+}, STRICT);
+const clone = t.Object({
+    name: text,
+    audioPaths: t.Array(text, {
+        minItems: 1,
+        maxItems: 10,
+        description: "Local samples, each at most 25 MiB. Only voices you own or have permission to clone.",
+    }),
+    description: t.Optional(text),
+    labels: t.Optional(t.Record(t.String(), t.String())),
+    removeBackgroundNoise: t.Optional(t.Boolean()),
+}, STRICT);
+const sound = t.Object({
+    ...audioOptions,
+    outputFormat: t.Optional(formatSchema("sound")),
+    text,
+    durationSeconds: t.Optional(t.Number({ minimum: 0.5, maximum: 30 })),
+    loop: t.Optional(t.Boolean()),
+    promptInfluence: t.Optional(t.Number({ minimum: 0, maximum: 1 })),
+}, STRICT);
+/** Audio returns local file paths; catalog responses preserve provider pagination metadata. */
+export default function elevenlabs(rl) {
+    rl.setName("elevenlabs");
+    rl.setVersion("0.1.0");
+    registerWorkflows(rl);
+    rl.setConnectionSchema(t.Object({
+        apiKey: t.String({
+            minLength: 1,
+            env: "ELEVENLABS_API_KEY",
+            description: "ElevenLabs key with permissions for the requested endpoints.",
+        }),
+    }));
+    rl.registerAction("models.list", {
+        access: "read",
+        description: "List ElevenLabs models and their supported capabilities.",
+        inputSchema: t.Object({}, STRICT),
+        async execute(_input, ctx) {
+            return jsonRequest(ctx, "/v1/models", "models");
+        },
+    });
+    rl.registerAction("voices.list", {
+        access: "read",
+        description: "Search one page of voices. Pass next_page_token back as cursor while has_more is true.",
+        inputSchema: list,
+        async execute(input, ctx) {
+            const p = input;
+            const query = new URLSearchParams({ page_size: String(p.limit ?? 10) });
+            if (p.cursor !== undefined)
+                query.set("next_page_token", p.cursor);
+            if (p.search !== undefined)
+                query.set("search", p.search);
+            return jsonRequest(ctx, `/v2/voices?${query}`, "voices");
+        },
+    });
+    rl.registerAction("voices.get", {
+        access: "read",
+        description: "Get voice metadata and settings by ID.",
+        inputSchema: voice,
+        async execute(input, ctx) {
+            return jsonRequest(ctx, `/v1/voices/${voicePath(input.voiceId)}`, "voice");
+        },
+    });
+    rl.registerAction("voices.delete", {
+        access: "write",
+        description: "Delete a voice from your ElevenLabs account.",
+        inputSchema: voice,
+        async execute(input, ctx) {
+            return jsonRequest(ctx, `/v1/voices/${voicePath(input.voiceId)}`, "acknowledgement", { method: "DELETE" });
+        },
+    });
+    rl.registerAction("voices.clone", {
+        access: "write",
+        description: "Create an instant voice clone from local audio samples you own or have permission to use. Returns voice_id and any verification requirement.",
+        inputSchema: clone,
+        async execute(input, ctx) {
+            const p = input;
+            return jsonRequest(ctx, "/v1/voices/add", "clone", {
+                method: "POST",
+                body: await voiceForm(p),
+            });
+        },
+    });
+    rl.registerAction("speech.create", {
+        access: "write",
+        description: "Convert text to speech (billed). Returns audio.path for send_file and optional character timestamps. Select a voice with voices.list; format support depends on the endpoint and account tier.",
+        inputSchema: speech,
+        async execute(input, ctx) {
+            const p = input;
+            return audioRequest(ctx, `/v1/text-to-speech/${voicePath(p.voiceId)}${p.timestamps ? "/with-timestamps" : ""}`, {
+                text: p.text,
+                model_id: p.model ?? "eleven_multilingual_v2",
+                language_code: p.languageCode,
+                voice_settings: p.voiceSettings,
+                seed: p.seed,
+                pronunciation_dictionary_locators: p.pronunciationDictionaries,
+                apply_text_normalization: p.normalization,
+                apply_language_text_normalization: p.languageNormalization,
+                previous_text: p.previousText,
+                next_text: p.nextText,
+                previous_request_ids: p.previousRequestIds,
+                next_request_ids: p.nextRequestIds,
+            }, p);
+        },
+    });
+    rl.registerAction("speech.convert", {
+        access: "write",
+        description: "Change a local recording to another voice (billed), preserving delivery. Returns audio.path in the requested format.",
+        inputSchema: convert,
+        async execute(input, ctx) {
+            const p = input;
+            const path = `/v1/speech-to-speech/${voicePath(p.voiceId)}`;
+            const form = new FormData();
+            await appendFile(form, "audio", p.audioPath);
+            form.append("model_id", p.model ?? "eleven_multilingual_sts_v2");
+            if (p.seed !== undefined)
+                form.append("seed", String(p.seed));
+            if (p.voiceSettings !== undefined)
+                form.append("voice_settings", JSON.stringify(p.voiceSettings));
+            if (p.removeBackgroundNoise !== undefined)
+                form.append("remove_background_noise", String(p.removeBackgroundNoise));
+            return audioRequest(ctx, path, form, p);
+        },
+    });
+    rl.registerAction("transcription.create", {
+        access: "write",
+        description: "Transcribe local audio/video or an HTTPS source with Scribe (billed). Returns text, selectable timestamps, and speaker labels; multichannel mode can return transcripts[]. Keyterms add 20%; each channel is billed separately.",
+        inputSchema: transcribe,
+        async execute(input, ctx) {
+            const p = input;
+            if (Boolean(p.filePath) === Boolean(p.sourceUrl))
+                throw new Error("elevenlabs: supply exactly one of filePath or sourceUrl");
+            if (p.channelOutput && !p.multiChannel)
+                throw new Error("elevenlabs: channelOutput requires multiChannel");
+            if (p.channelOutput === "combined" && p.timestampsGranularity === "none")
+                throw new Error("elevenlabs: combined channels require timestamps");
+            if (p.keyterms?.some((term) => !term.trim() || term.trim().split(/\s+/u).length > 5))
+                throw new Error("elevenlabs: keyterms allow at most 5 words each");
+            const form = new FormData();
+            if (p.filePath)
+                await appendFile(form, "file", p.filePath);
+            if (p.sourceUrl) {
+                const url = new URL(p.sourceUrl);
+                if (url.protocol !== "https:" || url.username || url.password)
+                    throw new Error("elevenlabs: sourceUrl requires HTTPS without embedded credentials");
+                form.append("source_url", url.href);
+            }
+            for (const term of p.keyterms ?? [])
+                form.append("keyterms", term);
+            form.append("model_id", p.model ?? "scribe_v2");
+            for (const [key, value] of Object.entries({
+                language_code: p.languageCode,
+                diarize: p.diarize,
+                num_speakers: p.numSpeakers,
+                tag_audio_events: p.tagAudioEvents,
+                timestamps_granularity: p.timestampsGranularity,
+                use_multi_channel: p.multiChannel,
+                multichannel_output_style: p.channelOutput,
+            })) {
+                if (value !== undefined)
+                    form.append(key, String(value));
+            }
+            return jsonRequest(ctx, "/v1/speech-to-text", "transcription", { method: "POST", body: form }, p.timeoutMs ?? 300_000);
+        },
+    });
+    rl.registerAction("music.create", {
+        access: "write",
+        description: "Compose music (billed) from either prompt + durationMs, or a model-specific compositionPlan with explicit section durations. Supports v1 sections and v2/v2.5 chunks. Returns audio.path; plans are capped at 10 minutes total.",
+        inputSchema: music,
+        async execute(input, ctx) {
+            const p = input;
+            if ("compositionPlan" in p) {
+                const parts = "sections" in p.compositionPlan
+                    ? p.compositionPlan.sections
+                    : p.compositionPlan.chunks;
+                if (parts.reduce((sum, part) => sum + part.duration_ms, 0) > 600000)
+                    throw new Error("elevenlabs: composition plans are limited to 600000ms total");
+            }
+            return audioRequest(ctx, "/v1/music", "prompt" in p
+                ? {
+                    prompt: p.prompt,
+                    music_length_ms: p.durationMs,
+                    model_id: p.model ?? "music_v1",
+                    force_instrumental: p.instrumental ?? false,
+                }
+                : {
+                    composition_plan: p.compositionPlan,
+                    model_id: p.model,
+                    seed: p.seed,
+                    respect_sections_durations: "respectSectionsDurations" in p
+                        ? p.respectSectionsDurations
+                        : undefined,
+                }, { ...p, outputFormat: p.outputFormat ?? "auto" });
+        },
+    });
+    rl.registerAction("sound.create", {
+        access: "write",
+        description: "Generate sound effects from text (billed) using eleven_text_to_sound_v2. Returns audio.path in the requested format.",
+        inputSchema: sound,
+        async execute(input, ctx) {
+            const p = input;
+            return audioRequest(ctx, "/v1/sound-generation", {
+                text: p.text,
+                model_id: "eleven_text_to_sound_v2",
+                duration_seconds: p.durationSeconds,
+                loop: p.loop,
+                prompt_influence: p.promptInfluence,
+            }, p);
+        },
+    });
+}