@openclaw/fish-audio-speech 2026.9.1-beta.1 → 2026.9.2

package/dist/capability-catalog.js

@@ -0,0 +1,5 @@
+import { buildFishAudioSpeechProvider } from "./speech-provider.js";
+//#region extensions/fish-audio-speech/capability-catalog.ts
+var capability_catalog_default = { speechProviders: [buildFishAudioSpeechProvider()] };
+//#endregion
+export { capability_catalog_default as default };

package/dist/speech-provider.js

@@ -1,8 +1,7 @@
 import { FISH_AUDIO_STREAM_MAX_BYTES, fishAudioTts, fishAudioTtsStream, listFishAudioVoices, normalizeFishAudioBaseUrl } from "./tts.js";
-import { resolveGeneratedMediaMaxBytes } from "openclaw/plugin-sdk/media-generation-runtime";
 import { normalizeResolvedSecretInputString } from "openclaw/plugin-sdk/secret-input";
-import { asBoolean, parseSpeechDirectiveNumberOverride, resolveSpeechProviderApiKey, trimToUndefined } from "openclaw/plugin-sdk/speech-core";
-import { asFiniteNumberInRange, asOptionalRecord, parseBooleanValue } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { parseSpeechDirectiveNumberOverride, resolveSpeechProviderApiKey } from "openclaw/plugin-sdk/speech-provider";
+import { asBoolean, asFiniteNumberInRange, asOptionalRecord, normalizeOptionalString, parseBooleanValue } from "openclaw/plugin-sdk/string-coerce-runtime";
 //#region extensions/fish-audio-speech/speech-provider.ts
 const FISH_AUDIO_MODELS = [
 	"s2.1-pro-free",
@@ -14,13 +13,13 @@ const DEFAULT_MODEL = "s2.1-pro";
 const DEFAULT_LATENCY = "balanced";
 const DEFAULT_TIMEOUT_MS = 24e4;
 function normalizeModel(value) {
-	const model = trimToUndefined(value);
+	const model = normalizeOptionalString(value);
 	if (!model) return DEFAULT_MODEL;
 	if (FISH_AUDIO_MODELS.some((candidate) => candidate === model)) return model;
 	throw new Error(`invalid Fish Audio model "${model}"`);
 }
 function normalizeLatency(value) {
-	const latency = trimToUndefined(value)?.toLowerCase();
+	const latency = normalizeOptionalString(value)?.toLowerCase();
 	if (!latency) return DEFAULT_LATENCY;
 	if (latency === "low" || latency === "balanced" || latency === "normal") return latency;
 	throw new Error(`invalid Fish Audio latency "${latency}"`);
@@ -32,16 +31,17 @@ function normalizeNumber(value, min, max) {
 	});
 }
 function resolveReferenceId(raw) {
-	return trimToUndefined(raw?.speakerVoiceId ?? raw?.voiceId ?? raw?.referenceId);
+	return normalizeOptionalString(raw?.speakerVoiceId ?? raw?.voiceId ?? raw?.referenceId);
 }
 function normalizeProviderConfig(rawConfig) {
-	const raw = asOptionalRecord(asOptionalRecord(rawConfig.providers)?.["fish-audio"]) ?? asOptionalRecord(rawConfig["fish-audio"]);
+	const providers = asOptionalRecord(rawConfig.providers);
+	const raw = asOptionalRecord(providers?.["fish-audio"]) ?? asOptionalRecord(rawConfig["fish-audio"]);
 	return {
 		apiKey: normalizeResolvedSecretInputString({
 			value: raw?.apiKey,
 			path: "tts.providers.fish-audio.apiKey"
 		}),
-		baseUrl: normalizeFishAudioBaseUrl(trimToUndefined(raw?.baseUrl)),
+		baseUrl: normalizeFishAudioBaseUrl(normalizeOptionalString(raw?.baseUrl)),
 		model: normalizeModel(raw?.model ?? raw?.modelId),
 		referenceId: resolveReferenceId(raw),
 		latency: normalizeLatency(raw?.latency),
@@ -55,8 +55,8 @@ function readProviderConfig(config) {
 	const defaults = normalizeProviderConfig({});
 	const raw = asOptionalRecord(config) ?? {};
 	return {
-		apiKey: trimToUndefined(raw.apiKey) ?? defaults.apiKey,
-		baseUrl: normalizeFishAudioBaseUrl(trimToUndefined(raw.baseUrl) ?? defaults.baseUrl),
+		apiKey: normalizeOptionalString(raw.apiKey) ?? defaults.apiKey,
+		baseUrl: normalizeFishAudioBaseUrl(normalizeOptionalString(raw.baseUrl) ?? defaults.baseUrl),
 		model: normalizeModel(raw.model ?? raw.modelId ?? defaults.model),
 		referenceId: resolveReferenceId(raw) ?? defaults.referenceId,
 		latency: normalizeLatency(raw.latency ?? defaults.latency),
@@ -69,9 +69,9 @@ function readProviderConfig(config) {
 function readOverrides(overrides) {
 	const raw = asOptionalRecord(overrides) ?? {};
 	return {
-		model: trimToUndefined(raw.model ?? raw.modelId) ? normalizeModel(raw.model ?? raw.modelId) : void 0,
+		model: normalizeOptionalString(raw.model ?? raw.modelId) ? normalizeModel(raw.model ?? raw.modelId) : void 0,
 		referenceId: resolveReferenceId(raw),
-		latency: trimToUndefined(raw.latency) ? normalizeLatency(raw.latency) : void 0,
+		latency: normalizeOptionalString(raw.latency) ? normalizeLatency(raw.latency) : void 0,
 		speed: normalizeNumber(raw.speed, .5, 2),
 		temperature: normalizeNumber(raw.temperature, 0, 1),
 		topP: normalizeNumber(raw.topP ?? raw.top_p, 0, 1),
@@ -221,7 +221,6 @@ function resolveSynthesisRequest(req) {
 		topP: overrides.topP ?? config.topP,
 		normalize: overrides.normalize ?? config.normalize,
 		timeoutMs: req.timeoutMs,
-		maxBytes: resolveGeneratedMediaMaxBytes(req.cfg, "audio"),
 		...output
 	};
 }
@@ -242,33 +241,37 @@ function buildFishAudioSpeechProvider() {
 					value: talkProviderConfig.apiKey,
 					path: "talk.providers.fish-audio.apiKey"
 				}) },
-				...trimToUndefined(talkProviderConfig.baseUrl) == null ? {} : { baseUrl: normalizeFishAudioBaseUrl(trimToUndefined(talkProviderConfig.baseUrl)) },
-				...trimToUndefined(talkProviderConfig.modelId ?? talkProviderConfig.model) == null ? {} : { model: normalizeModel(talkProviderConfig.modelId ?? talkProviderConfig.model) },
+				...normalizeOptionalString(talkProviderConfig.baseUrl) == null ? {} : { baseUrl: normalizeFishAudioBaseUrl(normalizeOptionalString(talkProviderConfig.baseUrl)) },
+				...normalizeOptionalString(talkProviderConfig.modelId ?? talkProviderConfig.model) == null ? {} : { model: normalizeModel(talkProviderConfig.modelId ?? talkProviderConfig.model) },
 				...resolveReferenceId(talkProviderConfig) == null ? {} : { referenceId: resolveReferenceId(talkProviderConfig) },
-				...trimToUndefined(talkProviderConfig.latency) == null ? {} : { latency: normalizeLatency(talkProviderConfig.latency) },
+				...normalizeOptionalString(talkProviderConfig.latency) == null ? {} : { latency: normalizeLatency(talkProviderConfig.latency) },
 				...normalizeNumber(talkProviderConfig.speed, .5, 2) == null ? {} : { speed: normalizeNumber(talkProviderConfig.speed, .5, 2) }
 			};
 		},
 		resolveTalkOverrides: ({ params }) => ({
-			...trimToUndefined(params.modelId ?? params.model) == null ? {} : { model: normalizeModel(params.modelId ?? params.model) },
+			...normalizeOptionalString(params.modelId ?? params.model) == null ? {} : { model: normalizeModel(params.modelId ?? params.model) },
 			...resolveReferenceId(params) == null ? {} : { referenceId: resolveReferenceId(params) },
 			...normalizeNumber(params.speed, .5, 2) == null ? {} : { speed: normalizeNumber(params.speed, .5, 2) }
 		}),
 		listVoices: async (req) => {
 			const config = readProviderConfig(req.providerConfig ?? {});
-			const apiKey = resolveApiKey(trimToUndefined(req.apiKey) ?? config.apiKey);
+			const apiKey = resolveApiKey(normalizeOptionalString(req.apiKey) ?? config.apiKey);
 			if (!apiKey) throw new Error("Fish Audio API key missing");
 			return await listFishAudioVoices({
 				apiKey,
-				baseUrl: normalizeFishAudioBaseUrl(trimToUndefined(req.baseUrl) ?? config.baseUrl),
+				baseUrl: normalizeFishAudioBaseUrl(normalizeOptionalString(req.baseUrl) ?? config.baseUrl),
 				timeoutMs: req.timeoutMs ?? DEFAULT_TIMEOUT_MS
 			});
 		},
 		isConfigured: ({ providerConfig }) => Boolean(resolveApiKey(readProviderConfig(providerConfig).apiKey)),
 		synthesize: async (req) => {
 			const params = resolveSynthesisRequest(req);
+			const { resolveGeneratedMediaMaxBytes } = await import("openclaw/plugin-sdk/media-generation-runtime");
 			return {
-				audioBuffer: await fishAudioTts(params),
+				audioBuffer: await fishAudioTts({
+					...params,
+					maxBytes: resolveGeneratedMediaMaxBytes(req.cfg, "audio")
+				}),
 				outputFormat: params.format,
 				fileExtension: params.fileExtension,
 				voiceCompatible: params.voiceCompatible
@@ -276,9 +279,10 @@ function buildFishAudioSpeechProvider() {
 		},
 		streamSynthesize: async (req) => {
 			const params = resolveSynthesisRequest(req);
+			const { resolveGeneratedMediaMaxBytes } = await import("openclaw/plugin-sdk/media-generation-runtime");
 			const stream = await fishAudioTtsStream({
 				...params,
-				maxBytes: Math.min(params.maxBytes, FISH_AUDIO_STREAM_MAX_BYTES)
+				maxBytes: Math.min(resolveGeneratedMediaMaxBytes(req.cfg, "audio"), FISH_AUDIO_STREAM_MAX_BYTES)
 			});
 			return {
 				audioStream: stream.audioStream,
@@ -289,11 +293,16 @@ function buildFishAudioSpeechProvider() {
 			};
 		},
 		synthesizeTelephony: async (req) => {
+			const params = resolveSynthesisRequest({
+				...req,
+				target: "telephony"
+			});
+			const { resolveGeneratedMediaMaxBytes } = await import("openclaw/plugin-sdk/media-generation-runtime");
 			return {
-				audioBuffer: await fishAudioTts(resolveSynthesisRequest({
-					...req,
-					target: "telephony"
-				})),
+				audioBuffer: await fishAudioTts({
+					...params,
+					maxBytes: resolveGeneratedMediaMaxBytes(req.cfg, "audio")
+				}),
 				outputFormat: "pcm",
 				sampleRate: 8e3
 			};

package/dist/tts.js

@@ -1,12 +1,8 @@
-import { asOptionalRecord } from "openclaw/plugin-sdk/string-coerce-runtime";
-import { MAX_AUDIO_BYTES } from "openclaw/plugin-sdk/media-runtime";
-import { createBoundedProviderBinaryStream } from "openclaw/plugin-sdk/provider-binary-stream";
-import { assertOkOrThrowProviderError, assertProviderBinaryResponseContent, readProviderBinaryResponse, readProviderJsonResponse } from "openclaw/plugin-sdk/provider-http";
-import { trimToUndefined } from "openclaw/plugin-sdk/speech";
-import { fetchWithSsrFGuard, ssrfPolicyFromHttpBaseUrlAllowedHostname } from "openclaw/plugin-sdk/ssrf-runtime";
+import { MAX_AUDIO_BYTES } from "openclaw/plugin-sdk/speech-provider";
+import { asOptionalRecord, normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
 //#region extensions/fish-audio-speech/tts.ts
 const FISH_AUDIO_BASE_URL = "https://api.fish.audio";
-const FISH_AUDIO_VOICES_MAX_BYTES = 2 * 1024 * 1024;
+const FISH_AUDIO_VOICES_MAX_BYTES = 2097152;
 const FISH_AUDIO_VOICE_PAGE_SIZE = 100;
 const FISH_AUDIO_MAX_OWN_VOICE_PAGES = 20;
 function normalizeFishAudioBaseUrl(value) {
@@ -28,6 +24,7 @@ function buildFishAudioRequestBody(params) {
 }
 async function requestFishAudioTts(params) {
 	const baseUrl = normalizeFishAudioBaseUrl(params.baseUrl);
+	const { fetchWithSsrFGuard, ssrfPolicyFromHttpBaseUrlAllowedHostname } = await import("openclaw/plugin-sdk/ssrf-runtime");
 	return await fetchWithSsrFGuard({
 		url: `${baseUrl}/v1/tts`,
 		init: {
@@ -45,15 +42,18 @@ async function requestFishAudioTts(params) {
 	});
 }
 async function fishAudioTts(params) {
+	const { assertOkOrThrowProviderError, readProviderBinaryResponse } = await import("openclaw/plugin-sdk/provider-http");
 	const { response, release } = await requestFishAudioTts(params);
 	try {
 		await assertOkOrThrowProviderError(response, "Fish Audio TTS API error");
-		return Buffer.from(await readProviderBinaryResponse(response, "Fish Audio TTS API error", "audio", { maxBytes: params.maxBytes }));
+		return await readProviderBinaryResponse(response, "Fish Audio TTS API error", "audio", { maxBytes: params.maxBytes });
 	} finally {
 		await release();
 	}
 }
 async function fishAudioTtsStream(params) {
+	const { createBoundedProviderBinaryStream } = await import("openclaw/plugin-sdk/provider-binary-stream");
+	const { assertOkOrThrowProviderError, assertProviderBinaryResponseContent } = await import("openclaw/plugin-sdk/provider-http");
 	const { response, release } = await requestFishAudioTts(params);
 	let handedOff = false;
 	try {
@@ -63,23 +63,13 @@ async function fishAudioTtsStream(params) {
 		const bounded = createBoundedProviderBinaryStream(response.body, {
 			maxBytes: params.maxBytes,
 			createOverflowError: ({ maxBytes }) => /* @__PURE__ */ new Error(`Fish Audio TTS API error: audio response exceeds ${maxBytes} bytes`),
-			createReleaseError: () => /* @__PURE__ */ new Error("Fish Audio TTS stream released")
+			createReleaseError: () => /* @__PURE__ */ new Error("Fish Audio TTS stream released"),
+			cleanup: release
 		});
-		let releasePromise;
-		const releaseAll = () => {
-			releasePromise ??= (async () => {
-				try {
-					await bounded.release();
-				} finally {
-					await release();
-				}
-			})();
-			return releasePromise;
-		};
 		handedOff = true;
 		return {
 			audioStream: bounded.stream,
-			release: releaseAll
+			release: bounded.release
 		};
 	} finally {
 		if (!handedOff) await release();
@@ -87,15 +77,15 @@ async function fishAudioTtsStream(params) {
 }
 function parseVoiceItem(value) {
 	const item = asOptionalRecord(value);
-	const id = trimToUndefined(item?.["_id"]);
+	const id = normalizeOptionalString(item?.["_id"]);
 	if (!id) return;
 	const languages = Array.isArray(item?.languages) ? item.languages.flatMap((entry) => typeof entry === "string" && entry.trim() ? [entry.trim()] : []) : [];
 	const tags = Array.isArray(item?.tags) ? item.tags.flatMap((entry) => typeof entry === "string" && entry.trim() ? [entry.trim()] : []) : [];
 	return {
 		id,
-		name: trimToUndefined(item?.title),
-		description: trimToUndefined(item?.description),
-		category: trimToUndefined(item?.visibility),
+		name: normalizeOptionalString(item?.title),
+		description: normalizeOptionalString(item?.description),
+		category: normalizeOptionalString(item?.visibility),
 		locale: languages[0],
 		personalities: tags.length > 0 ? tags : void 0
 	};
@@ -107,6 +97,8 @@ async function requestVoicePage(params) {
 	url.searchParams.set("page_number", String(params.pageNumber));
 	if (params.self) url.searchParams.set("self", "true");
 	else url.searchParams.set("sort_by", "score");
+	const { assertOkOrThrowProviderError, readProviderJsonResponse } = await import("openclaw/plugin-sdk/provider-http");
+	const { fetchWithSsrFGuard, ssrfPolicyFromHttpBaseUrlAllowedHostname } = await import("openclaw/plugin-sdk/ssrf-runtime");
 	const { response, release } = await fetchWithSsrFGuard({
 		url: url.toString(),
 		init: { headers: { Authorization: `Bearer ${params.apiKey}` } },

package/openclaw.plugin.json

@@ -1,6 +1,9 @@
 {
   "id": "fish-audio-speech",
-  "legacyPluginIds": ["fish-audio"],
+  "capabilityCatalogEntry": "./dist/capability-catalog.js",
+  "legacyPluginIds": [
+    "fish-audio"
+  ],
   "activation": {
     "onStartup": false
   },
@@ -10,12 +13,17 @@
     "providers": [
       {
         "id": "fish-audio",
-        "envVars": ["FISH_API_KEY", "FISH_AUDIO_API_KEY"]
+        "envVars": [
+          "FISH_API_KEY",
+          "FISH_AUDIO_API_KEY"
+        ]
       }
     ]
   },
   "contracts": {
-    "speechProviders": ["fish-audio"]
+    "speechProviders": [
+      "fish-audio"
+    ]
   },
   "configSchema": {
     "type": "object",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openclaw/fish-audio-speech",
-  "version": "2026.9.1-beta.1",
+  "version": "2026.9.2",
   "description": "OpenClaw Fish Audio speech plugin.",
   "repository": {
     "type": "git",
@@ -18,10 +18,10 @@
       "minHostVersion": ">=2026.7.2"
     },
     "compat": {
-      "pluginApi": ">=2026.9.1-beta.1"
+      "pluginApi": ">=2026.9.2"
     },
     "build": {
-      "openclawVersion": "2026.9.1-beta.1",
+      "openclawVersion": "2026.9.2",
       "bundledDist": false
     },
     "release": {
@@ -38,7 +38,7 @@
     "README.md"
   ],
   "peerDependencies": {
-    "openclaw": ">=2026.9.1-beta.1"
+    "openclaw": ">=2026.9.2"
   },
   "peerDependenciesMeta": {
     "openclaw": {