openclaw/dist/speech-provider-BdBWI69Y.js

Multi-channel AI gateway with extensible messaging integrations

import { a as asOptionalRecord } from "./record-coerce-DItp3I4t.js";
import { l as normalizeOptionalString } from "./string-coerce-CIXf7egm.js";
import { m as normalizeResolvedSecretInputString } from "./types.secrets-kC0nOetj.js";
import { t as retryAsync } from "./retry-DIUON3ys.js";
import "./string-coerce-runtime-GQa0ehRA.js";
import "./secret-input-dpVVFmLG.js";
import "./speech-provider-D6qM0DDB.js";
//#region extensions/google/speech-provider.ts
const DEFAULT_GOOGLE_TTS_MODEL = "gemini-3.1-flash-tts-preview";
const DEFAULT_GOOGLE_TTS_VOICE = "Kore";
const GOOGLE_TTS_SAMPLE_RATE = 24e3;
const GOOGLE_TTS_CHANNELS = 1;
const GOOGLE_TTS_BITS_PER_SAMPLE = 16;
const GOOGLE_AUDIO_PROFILE_PROMPT_TEMPLATE = "audio-profile-v1";
const GOOGLE_TTS_MODELS = [
	"gemini-3.1-flash-tts-preview",
	"gemini-2.5-flash-preview-tts",
	"gemini-2.5-pro-preview-tts"
];
const GOOGLE_TTS_VOICES = [
	"Zephyr",
	"Puck",
	"Charon",
	"Kore",
	"Fenrir",
	"Leda",
	"Orus",
	"Aoede",
	"Callirrhoe",
	"Autonoe",
	"Enceladus",
	"Iapetus",
	"Umbriel",
	"Algieba",
	"Despina",
	"Erinome",
	"Algenib",
	"Rasalgethi",
	"Laomedeia",
	"Achernar",
	"Alnilam",
	"Schedar",
	"Gacrux",
	"Pulcherrima",
	"Achird",
	"Zubenelgenubi",
	"Vindemiatrix",
	"Sadachbia",
	"Sadaltager",
	"Sulafat"
];
var GoogleTtsRetryableError = class extends Error {
	constructor(message) {
		super(message);
		this.name = "GoogleTtsRetryableError";
	}
};
function isGoogleTtsRetryableError(err) {
	if (err instanceof GoogleTtsRetryableError) return true;
	if (!(err instanceof Error)) return false;
	if (err.name === "AbortError") return true;
	const message = err.message.toLowerCase();
	return message.includes("aborted") || message.includes("timeout") || message.includes("fetch failed") || message.includes("network");
}
function normalizeGoogleTtsModel(model) {
	const trimmed = normalizeOptionalString(model);
	if (!trimmed) return DEFAULT_GOOGLE_TTS_MODEL;
	const withoutProvider = trimmed.startsWith("google/") ? trimmed.slice(7) : trimmed;
	return withoutProvider === "gemini-3.1-flash-tts" ? DEFAULT_GOOGLE_TTS_MODEL : withoutProvider;
}
function normalizeGoogleTtsVoiceName(voiceName) {
	return normalizeOptionalString(voiceName) ?? DEFAULT_GOOGLE_TTS_VOICE;
}
function normalizeGooglePromptTemplate(value) {
	const trimmed = normalizeOptionalString(value);
	if (!trimmed) return;
	if (trimmed === GOOGLE_AUDIO_PROFILE_PROMPT_TEMPLATE) return trimmed;
	throw new Error(`Invalid Google TTS promptTemplate: ${trimmed}`);
}
function resolveGoogleTtsEnvApiKey() {
	return normalizeOptionalString(process.env.GEMINI_API_KEY) ?? normalizeOptionalString(process.env.GOOGLE_API_KEY);
}
function resolveGoogleTtsModelProviderApiKey(cfg) {
	return normalizeResolvedSecretInputString({
		value: cfg?.models?.providers?.google?.apiKey,
		path: "models.providers.google.apiKey"
	});
}
function resolveGoogleTtsApiKey(params) {
	return readGoogleTtsProviderConfig(params.providerConfig).apiKey ?? resolveGoogleTtsModelProviderApiKey(params.cfg) ?? resolveGoogleTtsEnvApiKey();
}
function resolveGoogleTtsBaseUrl(params) {
	return params.providerConfig.baseUrl ?? normalizeOptionalString(params.cfg?.models?.providers?.google?.baseUrl);
}
function resolveGoogleTtsConfigRecord(rawConfig) {
	const providers = asOptionalRecord(rawConfig.providers);
	return asOptionalRecord(providers?.google) ?? asOptionalRecord(rawConfig.google);
}
function normalizeGoogleTtsProviderConfig(rawConfig) {
	const raw = resolveGoogleTtsConfigRecord(rawConfig);
	const promptTemplate = normalizeGooglePromptTemplate(raw?.promptTemplate);
	const personaPrompt = normalizeOptionalString(raw?.personaPrompt);
	return {
		apiKey: normalizeResolvedSecretInputString({
			value: raw?.apiKey,
			path: "tts.providers.google.apiKey"
		}),
		baseUrl: normalizeOptionalString(raw?.baseUrl),
		model: normalizeGoogleTtsModel(raw?.model),
		voiceName: normalizeGoogleTtsVoiceName(raw?.voiceName ?? raw?.voice),
		audioProfile: normalizeOptionalString(raw?.audioProfile),
		speakerName: normalizeOptionalString(raw?.speakerName),
		...promptTemplate ? { promptTemplate } : {},
		...personaPrompt ? { personaPrompt } : {}
	};
}
function readGoogleTtsProviderConfig(config) {
	const normalized = normalizeGoogleTtsProviderConfig({});
	const promptTemplate = normalizeGooglePromptTemplate(config.promptTemplate) ?? normalized.promptTemplate;
	const personaPrompt = normalizeOptionalString(config.personaPrompt) ?? normalized.personaPrompt;
	return {
		apiKey: normalizeOptionalString(config.apiKey) ?? normalized.apiKey,
		baseUrl: normalizeOptionalString(config.baseUrl) ?? normalized.baseUrl,
		model: normalizeGoogleTtsModel(config.model ?? normalized.model),
		voiceName: normalizeGoogleTtsVoiceName(config.voiceName ?? config.voice ?? normalized.voiceName),
		audioProfile: normalizeOptionalString(config.audioProfile) ?? normalized.audioProfile,
		speakerName: normalizeOptionalString(config.speakerName) ?? normalized.speakerName,
		...promptTemplate ? { promptTemplate } : {},
		...personaPrompt ? { personaPrompt } : {}
	};
}
function readGoogleTtsOverrides(overrides) {
	if (!overrides) return {};
	return {
		model: normalizeOptionalString(overrides.model),
		voiceName: normalizeOptionalString(overrides.voiceName ?? overrides.voice),
		audioProfile: normalizeOptionalString(overrides.audioProfile),
		speakerName: normalizeOptionalString(overrides.speakerName)
	};
}
function composeGoogleTtsText(params) {
	return [
		normalizeOptionalString(params.audioProfile),
		normalizeOptionalString(params.speakerName) ? `Speaker name: ${params.speakerName}` : void 0,
		params.text
	].filter((part) => part !== void 0).join("\n\n");
}
function parseDirectiveToken(ctx) {
	switch (ctx.key) {
		case "voicename":
		case "voice_name":
		case "google_voice":
		case "googlevoice":
			if (!ctx.policy.allowVoice) return { handled: true };
			return {
				handled: true,
				overrides: { voiceName: ctx.value }
			};
		case "google_model":
		case "googlemodel":
			if (!ctx.policy.allowModelId) return { handled: true };
			return {
				handled: true,
				overrides: { model: ctx.value }
			};
		default: return { handled: false };
	}
}
function normalizePromptSectionText(value) {
	const trimmed = normalizeOptionalString(value?.replace(/\r\n?/g, "\n"));
	if (!trimmed) return;
	let sanitized = "";
	for (const char of trimmed) {
		const code = char.charCodeAt(0);
		if (code >= 0 && code <= 8 || code === 11 || code === 12 || code >= 14 && code <= 31 || code === 127) continue;
		sanitized += char;
	}
	return sanitized;
}
function isOpenClawGoogleAudioProfilePrompt(text) {
	return text.includes("# AUDIO PROFILE:") && text.includes("### TRANSCRIPT") && text.startsWith("Synthesize speech from the TRANSCRIPT section only.");
}
function renderGoogleAudioProfilePrompt(params) {
	const transcript = params.text.replace(/\r\n?/g, "\n").trim();
	const personaPrompt = normalizePromptSectionText(params.personaPrompt);
	const label = normalizePromptSectionText(params.persona?.label) ?? normalizePromptSectionText(params.persona?.id);
	const sections = [[
		"Synthesize speech from the TRANSCRIPT section only. Use the other sections only",
		"as performance direction. Do not read section titles, notes, labels, or",
		"configuration aloud."
	].join("\n")];
	if (label) sections.push(`# AUDIO PROFILE: ${label}`);
	const directorNotes = [];
	if (personaPrompt) directorNotes.push(["Provider notes:", personaPrompt].join("\n"));
	if (directorNotes.length > 0) sections.push(["### DIRECTOR'S NOTES", ...directorNotes].join("\n"));
	sections.push(["### TRANSCRIPT", transcript].join("\n"));
	return sections.join("\n\n");
}
function wrapPcm16MonoToWav(pcm, sampleRate = GOOGLE_TTS_SAMPLE_RATE) {
	const byteRate = sampleRate * GOOGLE_TTS_CHANNELS * (GOOGLE_TTS_BITS_PER_SAMPLE / 8);
	const blockAlign = GOOGLE_TTS_CHANNELS * (GOOGLE_TTS_BITS_PER_SAMPLE / 8);
	const header = Buffer.alloc(44);
	header.write("RIFF", 0, "ascii");
	header.writeUInt32LE(36 + pcm.length, 4);
	header.write("WAVE", 8, "ascii");
	header.write("fmt ", 12, "ascii");
	header.writeUInt32LE(16, 16);
	header.writeUInt16LE(1, 20);
	header.writeUInt16LE(GOOGLE_TTS_CHANNELS, 22);
	header.writeUInt32LE(sampleRate, 24);
	header.writeUInt32LE(byteRate, 28);
	header.writeUInt16LE(blockAlign, 32);
	header.writeUInt16LE(GOOGLE_TTS_BITS_PER_SAMPLE, 34);
	header.write("data", 36, "ascii");
	header.writeUInt32LE(pcm.length, 40);
	return Buffer.concat([header, pcm]);
}
async function synthesizeGoogleTtsPcmOnce(params) {
	const { assertOkOrThrowProviderError, postJsonRequest, readProviderJsonResponse } = await import("./plugin-sdk/provider-http.js");
	const { resolveGoogleGenerativeAiHttpRequestConfig } = await import("./extensions/google/api.js");
	const { canonicalizeGoogleProviderBase64 } = await import("./extensions/google/base64.js");
	const { baseUrl, allowPrivateNetwork, headers, dispatcherPolicy } = resolveGoogleGenerativeAiHttpRequestConfig({
		apiKey: params.apiKey,
		baseUrl: params.baseUrl,
		request: params.request,
		capability: "audio",
		transport: "http"
	});
	const { response: res, release } = await postJsonRequest({
		url: `${baseUrl}/models/${params.model}:generateContent`,
		headers,
		body: {
			contents: [{
				role: "user",
				parts: [{ text: composeGoogleTtsText({
					text: params.text,
					audioProfile: params.audioProfile,
					speakerName: params.speakerName
				}) }]
			}],
			generationConfig: {
				responseModalities: ["AUDIO"],
				speechConfig: { voiceConfig: { prebuiltVoiceConfig: { voiceName: params.voiceName } } }
			}
		},
		timeoutMs: params.timeoutMs,
		fetchFn: fetch,
		pinDns: false,
		allowPrivateNetwork,
		dispatcherPolicy
	});
	try {
		if (!res.ok) try {
			await assertOkOrThrowProviderError(res, "Google TTS failed");
		} catch (err) {
			const message = err instanceof Error ? err.message : String(err);
			if (res.status >= 500 && res.status < 600) throw new GoogleTtsRetryableError(message);
			throw err;
		}
		try {
			const payload = await readProviderJsonResponse(res, "Google TTS response");
			for (const candidate of payload.candidates ?? []) for (const part of candidate.content?.parts ?? []) {
				const inline = part.inlineData ?? part.inline_data;
				const data = normalizeOptionalString(inline?.data);
				if (!data) continue;
				const canonicalAudio = canonicalizeGoogleProviderBase64(data);
				if (!canonicalAudio) throw new Error("Google TTS response returned malformed base64 audio data");
				return Buffer.from(canonicalAudio, "base64");
			}
			throw new Error("Google TTS response missing audio data");
		} catch (err) {
			throw new GoogleTtsRetryableError(err instanceof Error ? err.message : String(err));
		}
	} finally {
		await release();
	}
}
async function synthesizeGoogleTtsPcm(params) {
	return await retryAsync(() => synthesizeGoogleTtsPcmOnce(params), {
		attempts: 2,
		minDelayMs: 0,
		shouldRetry: isGoogleTtsRetryableError
	});
}
async function synthesizeConfiguredGoogleTts(req) {
	const config = readGoogleTtsProviderConfig(req.providerConfig);
	const overrides = readGoogleTtsOverrides(req.providerOverrides);
	const apiKey = resolveGoogleTtsApiKey({
		cfg: req.cfg,
		providerConfig: req.providerConfig
	});
	if (!apiKey) throw new Error("Google API key missing");
	const { sanitizeConfiguredModelProviderRequest } = await import("./plugin-sdk/provider-http.js");
	return synthesizeGoogleTtsPcm({
		text: req.text,
		apiKey,
		baseUrl: resolveGoogleTtsBaseUrl({
			cfg: req.cfg,
			providerConfig: config
		}),
		request: sanitizeConfiguredModelProviderRequest(req.cfg?.models?.providers?.google?.request),
		model: normalizeGoogleTtsModel(overrides.model ?? config.model),
		voiceName: normalizeGoogleTtsVoiceName(overrides.voiceName ?? config.voiceName),
		audioProfile: overrides.audioProfile ?? config.audioProfile,
		speakerName: overrides.speakerName ?? config.speakerName,
		timeoutMs: req.timeoutMs
	});
}
function buildGoogleSpeechProvider() {
	return {
		id: "google",
		label: "Google",
		autoSelectOrder: 50,
		defaultModel: DEFAULT_GOOGLE_TTS_MODEL,
		models: GOOGLE_TTS_MODELS,
		voices: GOOGLE_TTS_VOICES,
		resolveConfig: ({ rawConfig }) => normalizeGoogleTtsProviderConfig(rawConfig),
		parseDirectiveToken,
		resolveTalkConfig: ({ baseTtsConfig, talkProviderConfig }) => {
			return {
				...normalizeGoogleTtsProviderConfig(baseTtsConfig),
				...talkProviderConfig.apiKey === void 0 ? {} : { apiKey: normalizeResolvedSecretInputString({
					value: talkProviderConfig.apiKey,
					path: "talk.providers.google.apiKey"
				}) },
				...normalizeOptionalString(talkProviderConfig.baseUrl) == null ? {} : { baseUrl: normalizeOptionalString(talkProviderConfig.baseUrl) },
				...normalizeOptionalString(talkProviderConfig.modelId) == null ? {} : { model: normalizeGoogleTtsModel(talkProviderConfig.modelId) },
				...normalizeOptionalString(talkProviderConfig.voiceId) == null ? {} : { voiceName: normalizeGoogleTtsVoiceName(talkProviderConfig.voiceId) }
			};
		},
		resolveTalkOverrides: ({ params }) => ({
			...normalizeOptionalString(params.voiceId) == null ? {} : { voiceName: normalizeGoogleTtsVoiceName(params.voiceId) },
			...normalizeOptionalString(params.modelId) == null ? {} : { model: normalizeGoogleTtsModel(params.modelId) }
		}),
		listVoices: async () => GOOGLE_TTS_VOICES.map((voice) => ({
			id: voice,
			name: voice
		})),
		isConfigured: ({ cfg, providerConfig }) => Boolean(resolveGoogleTtsApiKey({
			cfg,
			providerConfig
		})),
		prepareSynthesis: (ctx) => {
			const config = readGoogleTtsProviderConfig(ctx.providerConfig);
			if (!(config.promptTemplate === GOOGLE_AUDIO_PROFILE_PROMPT_TEMPLATE || Boolean(config.personaPrompt)) || isOpenClawGoogleAudioProfilePrompt(ctx.text)) return;
			return { text: renderGoogleAudioProfilePrompt({
				text: ctx.text,
				persona: ctx.persona,
				personaPrompt: config.personaPrompt
			}) };
		},
		synthesize: async (req) => {
			const pcm = await synthesizeConfiguredGoogleTts(req);
			if (req.target === "voice-note") {
				const { transcodeAudioBufferToOpus } = await import("./plugin-sdk/media-runtime.js");
				return {
					audioBuffer: await transcodeAudioBufferToOpus({
						audioBuffer: wrapPcm16MonoToWav(pcm),
						inputExtension: "wav",
						tempPrefix: "tts-google-",
						timeoutMs: req.timeoutMs
					}),
					outputFormat: "opus",
					fileExtension: ".opus",
					voiceCompatible: true
				};
			}
			return {
				audioBuffer: wrapPcm16MonoToWav(pcm),
				outputFormat: "wav",
				fileExtension: ".wav",
				voiceCompatible: false
			};
		},
		synthesizeTelephony: async (req) => {
			return {
				audioBuffer: await synthesizeConfiguredGoogleTts(req),
				outputFormat: "pcm",
				sampleRate: GOOGLE_TTS_SAMPLE_RATE
			};
		}
	};
}
//#endregion
export { buildGoogleSpeechProvider as t };