openclaw/dist/music-generation-provider-CRp52hDA.mjs

Multi-channel AI gateway with extensible messaging integrations

import { l as normalizeOptionalString } from "./string-coerce-1VuiLaaR.mjs";
import { c as isRecord } from "./record-coerce-TIsquoVR.mjs";
import { m as readProviderJsonResponse, n as assertOkOrThrowHttpError } from "./provider-http-errors-DmewLLH7.mjs";
import "./string-coerce-runtime-50qKeWeL.mjs";
import { r as resolveGeneratedMediaMaxBytes } from "./configured-max-bytes-94qDtzvY.mjs";
import { d as postJsonRequest } from "./shared-DcnGQdHV.mjs";
import { t as isProviderApiKeyConfigured } from "./provider-auth-availability-GiSm5QUa.mjs";
import "./media-generation-runtime-DrYRW4VG.mjs";
import "./provider-http-CuRGJD0L.mjs";
import { n as extractGeneratedMusicFileCandidates, t as downloadGeneratedMusicAsset } from "./music-generation-D-5knzUP.mjs";
import "./provider-auth-C0Mnu3Sx.mjs";
import { t as resolveFalHttpRequestConfig } from "./http-config-BCs4S82L.mjs";
//#region extensions/fal/music-generation-provider.ts
const DEFAULT_FAL_MUSIC_MODEL = "fal-ai/minimax-music/v2.6";
const FAL_ACE_STEP_MODEL = "fal-ai/ace-step/prompt-to-audio";
const FAL_STABLE_AUDIO_MODEL = "fal-ai/stable-audio-25/text-to-audio";
const DEFAULT_TIMEOUT_MS = 18e4;
const FAL_MUSIC_MODELS = [
	DEFAULT_FAL_MUSIC_MODEL,
	FAL_ACE_STEP_MODEL,
	FAL_STABLE_AUDIO_MODEL
];
function buildFalMusicRequestBody(req, model) {
	const lyrics = normalizeOptionalString(req.lyrics);
	if (model === FAL_ACE_STEP_MODEL || model === FAL_STABLE_AUDIO_MODEL) {
		const isStableAudio = model === FAL_STABLE_AUDIO_MODEL;
		if (lyrics) throw new Error(`fal ${isStableAudio ? "Stable Audio" : "ACE-Step"} music generation does not support explicit lyrics.`);
		if (isStableAudio && req.instrumental === true) throw new Error("fal Stable Audio music generation does not support instrumental mode.");
		return {
			prompt: req.prompt,
			...req.instrumental === true ? { instrumental: true } : {},
			...typeof req.durationSeconds === "number" ? { [isStableAudio ? "seconds_total" : "duration"]: req.durationSeconds } : {}
		};
	}
	if (lyrics && req.instrumental === true) throw new Error("fal MiniMax music generation cannot use lyrics when instrumental=true.");
	return {
		prompt: req.prompt,
		...lyrics ? { lyrics } : {},
		...req.instrumental === true ? { is_instrumental: true } : {},
		...!lyrics && req.instrumental !== true ? { lyrics_optimizer: true } : {},
		...typeof req.durationSeconds === "number" ? { duration: req.durationSeconds } : {},
		audio_setting: {
			sample_rate: 44100,
			bitrate: 256e3,
			format: req.format ?? "mp3"
		}
	};
}
function resolveFalMusicMetadata(payload) {
	if (!isRecord(payload)) return;
	const metadata = {};
	for (const key of ["seed", "tags"]) {
		const value = payload[key];
		if (value !== void 0 && value !== null) metadata[key] = value;
	}
	return Object.keys(metadata).length > 0 ? metadata : void 0;
}
function buildFalMusicGenerationProvider() {
	return {
		id: "fal",
		label: "fal",
		defaultModel: DEFAULT_FAL_MUSIC_MODEL,
		models: [...FAL_MUSIC_MODELS],
		isConfigured: (ctx) => isProviderApiKeyConfigured({
			provider: "fal",
			...ctx
		}),
		capabilities: {
			generate: {
				maxTracks: 1,
				maxDurationSeconds: 240,
				supportsLyrics: true,
				supportsLyricsByModel: {
					[FAL_ACE_STEP_MODEL]: false,
					[FAL_STABLE_AUDIO_MODEL]: false
				},
				supportsInstrumental: true,
				supportsInstrumentalByModel: { [FAL_STABLE_AUDIO_MODEL]: false },
				supportsDuration: true,
				supportsFormat: true,
				supportedFormats: ["mp3", "wav"],
				supportedFormatsByModel: {
					[DEFAULT_FAL_MUSIC_MODEL]: ["mp3"],
					[FAL_ACE_STEP_MODEL]: ["wav"],
					[FAL_STABLE_AUDIO_MODEL]: ["wav"]
				}
			},
			edit: { enabled: false }
		},
		async generateMusic(req) {
			if ((req.inputImages?.length ?? 0) > 0) throw new Error("fal music generation does not support image reference inputs.");
			const { baseUrl, allowPrivateNetwork, headers, dispatcherPolicy } = await resolveFalHttpRequestConfig({
				req,
				capability: "audio"
			});
			const model = normalizeOptionalString(req.model) ?? DEFAULT_FAL_MUSIC_MODEL;
			const { response, release } = await postJsonRequest({
				url: `${baseUrl}/${model}`,
				headers,
				body: buildFalMusicRequestBody(req, model),
				timeoutMs: req.timeoutMs ?? DEFAULT_TIMEOUT_MS,
				fetchFn: fetch,
				allowPrivateNetwork,
				dispatcherPolicy
			});
			try {
				await assertOkOrThrowHttpError(response, "fal music generation failed");
				const payload = await readProviderJsonResponse(response, "fal music generation");
				const [candidate] = extractGeneratedMusicFileCandidates(payload);
				if (!candidate) throw new Error("fal music generation response missing audio output");
				const track = await downloadGeneratedMusicAsset({
					candidate,
					timeoutMs: req.timeoutMs ?? DEFAULT_TIMEOUT_MS,
					fetchFn: fetch,
					provider: "fal",
					requestFailedMessage: "fal generated music download failed",
					maxBytes: resolveGeneratedMediaMaxBytes(req.cfg, "audio")
				});
				const lyrics = isRecord(payload) ? normalizeOptionalString(payload.lyrics) : void 0;
				return {
					tracks: [track],
					model,
					...lyrics ? { lyrics: [lyrics] } : {},
					metadata: {
						...resolveFalMusicMetadata(payload),
						...track.metadata?.url ? { audioUrl: track.metadata.url } : {},
						instrumental: req.instrumental === true,
						...req.format ? { requestedFormat: req.format } : {},
						...typeof req.durationSeconds === "number" ? { requestedDurationSeconds: req.durationSeconds } : {}
					}
				};
			} finally {
				await release();
			}
		}
	};
}
//#endregion
export { buildFalMusicGenerationProvider as t };