@openclaw/fish-audio-speech 2026.7.2-beta.7

package/README.md

@@ -0,0 +1,10 @@
+# Fish Audio speech plugin
+
+Official OpenClaw speech provider for Fish Audio's hosted S2.1 API.
+
+Configure `tts.provider: "fish-audio"` and set `FISH_API_KEY`. The provider
+supports buffered audio, HTTP-streamed playback, native Opus voice notes,
+8 kHz PCM telephony, and Fish Audio voice discovery.
+
+See [Fish Audio](https://docs.openclaw.ai/providers/fish-audio) for setup,
+models, voice selection, expressive tags, and local macOS MLX usage.

package/dist/index.js

@@ -0,0 +1,13 @@
+import { buildFishAudioSpeechProvider } from "./speech-provider.js";
+import { definePluginEntry } from "openclaw/plugin-sdk/plugin-entry";
+//#region extensions/fish-audio/index.ts
+var fish_audio_default = definePluginEntry({
+	id: "fish-audio",
+	name: "Fish Audio Speech",
+	description: "Hosted Fish Audio S2.1 text-to-speech provider",
+	register(api) {
+		api.registerSpeechProvider(buildFishAudioSpeechProvider());
+	}
+});
+//#endregion
+export { fish_audio_default as default };

package/dist/speech-provider.js

@@ -0,0 +1,318 @@
+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, asFiniteNumber, asObject, parseSpeechDirectiveNumberOverride, resolveSpeechProviderApiKey, trimToUndefined } from "openclaw/plugin-sdk/speech-core";
+//#region extensions/fish-audio/speech-provider.ts
+const FISH_AUDIO_MODELS = [
+	"s2.1-pro-free",
+	"s2.1-pro",
+	"s2-pro",
+	"s1"
+];
+const DEFAULT_MODEL = "s2.1-pro";
+const DEFAULT_LATENCY = "balanced";
+const DEFAULT_TIMEOUT_MS = 24e4;
+function normalizeModel(value) {
+	const model = trimToUndefined(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();
+	if (!latency) return DEFAULT_LATENCY;
+	if (latency === "low" || latency === "balanced" || latency === "normal") return latency;
+	throw new Error(`invalid Fish Audio latency "${latency}"`);
+}
+function normalizeNumber(value, min, max) {
+	const number = asFiniteNumber(value);
+	return number != null && number >= min && number <= max ? number : void 0;
+}
+function resolveReferenceId(raw) {
+	return trimToUndefined(raw?.speakerVoiceId ?? raw?.voiceId ?? raw?.referenceId);
+}
+function normalizeProviderConfig(rawConfig) {
+	const raw = asObject(asObject(rawConfig.providers)?.["fish-audio"]) ?? asObject(rawConfig["fish-audio"]);
+	return {
+		apiKey: normalizeResolvedSecretInputString({
+			value: raw?.apiKey,
+			path: "tts.providers.fish-audio.apiKey"
+		}),
+		baseUrl: normalizeFishAudioBaseUrl(trimToUndefined(raw?.baseUrl)),
+		model: normalizeModel(raw?.model ?? raw?.modelId),
+		referenceId: resolveReferenceId(raw),
+		latency: normalizeLatency(raw?.latency),
+		speed: normalizeNumber(raw?.speed, .5, 2),
+		temperature: normalizeNumber(raw?.temperature, 0, 1),
+		topP: normalizeNumber(raw?.topP ?? raw?.top_p, 0, 1),
+		normalize: asBoolean(raw?.normalize)
+	};
+}
+function readProviderConfig(config) {
+	const defaults = normalizeProviderConfig({});
+	const raw = asObject(config) ?? {};
+	return {
+		apiKey: trimToUndefined(raw.apiKey) ?? defaults.apiKey,
+		baseUrl: normalizeFishAudioBaseUrl(trimToUndefined(raw.baseUrl) ?? defaults.baseUrl),
+		model: normalizeModel(raw.model ?? raw.modelId ?? defaults.model),
+		referenceId: resolveReferenceId(raw) ?? defaults.referenceId,
+		latency: normalizeLatency(raw.latency ?? defaults.latency),
+		speed: normalizeNumber(raw.speed, .5, 2) ?? defaults.speed,
+		temperature: normalizeNumber(raw.temperature, 0, 1) ?? defaults.temperature,
+		topP: normalizeNumber(raw.topP ?? raw.top_p, 0, 1) ?? defaults.topP,
+		normalize: asBoolean(raw.normalize) ?? defaults.normalize
+	};
+}
+function readOverrides(overrides) {
+	const raw = asObject(overrides) ?? {};
+	return {
+		model: trimToUndefined(raw.model ?? raw.modelId) ? normalizeModel(raw.model ?? raw.modelId) : void 0,
+		referenceId: resolveReferenceId(raw),
+		latency: trimToUndefined(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),
+		normalize: asBoolean(raw.normalize)
+	};
+}
+function resolveApiKey(configValue) {
+	return resolveSpeechProviderApiKey(configValue, process.env.FISH_API_KEY, process.env.FISH_AUDIO_API_KEY);
+}
+function parseDirectiveToken(ctx) {
+	switch (ctx.key) {
+		case "voice":
+		case "voiceid":
+		case "voice_id":
+		case "referenceid":
+		case "reference_id":
+		case "fish_voice":
+		case "fishaudio_voice": return ctx.policy.allowVoice ? {
+			handled: true,
+			overrides: {
+				...ctx.currentOverrides,
+				referenceId: ctx.value
+			}
+		} : { handled: true };
+		case "model":
+		case "modelid":
+		case "model_id":
+		case "fish_model":
+		case "fishaudio_model":
+			if (!ctx.policy.allowModelId) return { handled: true };
+			try {
+				return {
+					handled: true,
+					overrides: {
+						...ctx.currentOverrides,
+						model: normalizeModel(ctx.value)
+					}
+				};
+			} catch (error) {
+				return {
+					handled: true,
+					warnings: [String(error)]
+				};
+			}
+		case "speed":
+		case "fish_speed": return parseSpeechDirectiveNumberOverride({
+			ctx,
+			overrideKey: "speed",
+			range: {
+				min: .5,
+				max: 2
+			},
+			warning: (value) => `invalid Fish Audio speed "${value}"`
+		});
+		case "temperature":
+		case "fish_temperature": return parseSpeechDirectiveNumberOverride({
+			ctx,
+			overrideKey: "temperature",
+			range: {
+				min: 0,
+				max: 1
+			},
+			warning: (value) => `invalid Fish Audio temperature "${value}"`
+		});
+		case "top_p":
+		case "topp":
+		case "fish_top_p": return parseSpeechDirectiveNumberOverride({
+			ctx,
+			overrideKey: "topP",
+			range: {
+				min: 0,
+				max: 1
+			},
+			warning: (value) => `invalid Fish Audio top_p "${value}"`
+		});
+		case "latency":
+		case "fish_latency":
+			if (!ctx.policy.allowVoiceSettings) return { handled: true };
+			try {
+				return {
+					handled: true,
+					overrides: {
+						...ctx.currentOverrides,
+						latency: normalizeLatency(ctx.value)
+					}
+				};
+			} catch (error) {
+				return {
+					handled: true,
+					warnings: [String(error)]
+				};
+			}
+		case "normalize":
+		case "fish_normalize": {
+			if (!ctx.policy.allowNormalization) return { handled: true };
+			const value = ctx.value.trim().toLowerCase();
+			if ([
+				"true",
+				"1",
+				"yes",
+				"on"
+			].includes(value)) return {
+				handled: true,
+				overrides: {
+					...ctx.currentOverrides,
+					normalize: true
+				}
+			};
+			if ([
+				"false",
+				"0",
+				"no",
+				"off"
+			].includes(value)) return {
+				handled: true,
+				overrides: {
+					...ctx.currentOverrides,
+					normalize: false
+				}
+			};
+			return {
+				handled: true,
+				warnings: [`invalid Fish Audio normalize "${ctx.value}"`]
+			};
+		}
+		default: return { handled: false };
+	}
+}
+function resolveFormat(target) {
+	if (target === "voice-note") return {
+		format: "opus",
+		sampleRate: 48e3,
+		fileExtension: ".opus",
+		voiceCompatible: true
+	};
+	if (target === "telephony") return {
+		format: "pcm",
+		sampleRate: 8e3,
+		fileExtension: ".pcm",
+		voiceCompatible: false
+	};
+	return {
+		format: "mp3",
+		sampleRate: 44100,
+		fileExtension: ".mp3",
+		voiceCompatible: false
+	};
+}
+function resolveSynthesisRequest(req) {
+	const config = readProviderConfig(req.providerConfig);
+	const overrides = readOverrides(req.providerOverrides);
+	const apiKey = resolveApiKey(config.apiKey);
+	if (!apiKey) throw new Error("Fish Audio API key missing");
+	const output = resolveFormat(req.target);
+	return {
+		text: req.text,
+		apiKey,
+		baseUrl: config.baseUrl,
+		model: overrides.model ?? config.model,
+		referenceId: overrides.referenceId ?? config.referenceId,
+		latency: overrides.latency ?? config.latency,
+		speed: overrides.speed ?? config.speed,
+		temperature: overrides.temperature ?? config.temperature,
+		topP: overrides.topP ?? config.topP,
+		normalize: overrides.normalize ?? config.normalize,
+		timeoutMs: req.timeoutMs,
+		maxBytes: resolveGeneratedMediaMaxBytes(req.cfg, "audio"),
+		...output
+	};
+}
+function buildFishAudioSpeechProvider() {
+	return {
+		id: "fish-audio",
+		label: "Fish Audio",
+		autoSelectOrder: 28,
+		defaultTimeoutMs: DEFAULT_TIMEOUT_MS,
+		defaultModel: DEFAULT_MODEL,
+		models: FISH_AUDIO_MODELS,
+		resolveConfig: ({ rawConfig }) => normalizeProviderConfig(rawConfig),
+		parseDirectiveToken,
+		resolveTalkConfig: ({ baseTtsConfig, talkProviderConfig }) => {
+			return {
+				...normalizeProviderConfig(baseTtsConfig),
+				...talkProviderConfig.apiKey === void 0 ? {} : { apiKey: normalizeResolvedSecretInputString({
+					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) },
+				...resolveReferenceId(talkProviderConfig) == null ? {} : { referenceId: resolveReferenceId(talkProviderConfig) },
+				...trimToUndefined(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) },
+			...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);
+			if (!apiKey) throw new Error("Fish Audio API key missing");
+			return await listFishAudioVoices({
+				apiKey,
+				baseUrl: normalizeFishAudioBaseUrl(trimToUndefined(req.baseUrl) ?? config.baseUrl),
+				timeoutMs: req.timeoutMs ?? DEFAULT_TIMEOUT_MS
+			});
+		},
+		isConfigured: ({ providerConfig }) => Boolean(resolveApiKey(readProviderConfig(providerConfig).apiKey)),
+		synthesize: async (req) => {
+			const params = resolveSynthesisRequest(req);
+			return {
+				audioBuffer: await fishAudioTts(params),
+				outputFormat: params.format,
+				fileExtension: params.fileExtension,
+				voiceCompatible: params.voiceCompatible
+			};
+		},
+		streamSynthesize: async (req) => {
+			const params = resolveSynthesisRequest(req);
+			const stream = await fishAudioTtsStream({
+				...params,
+				maxBytes: Math.min(params.maxBytes, FISH_AUDIO_STREAM_MAX_BYTES)
+			});
+			return {
+				audioStream: stream.audioStream,
+				outputFormat: params.format,
+				fileExtension: params.fileExtension,
+				voiceCompatible: params.voiceCompatible,
+				release: stream.release
+			};
+		},
+		synthesizeTelephony: async (req) => {
+			return {
+				audioBuffer: await fishAudioTts(resolveSynthesisRequest({
+					...req,
+					target: "telephony"
+				})),
+				outputFormat: "pcm",
+				sampleRate: 8e3
+			};
+		}
+	};
+}
+//#endregion
+export { buildFishAudioSpeechProvider };

package/dist/tts.js

@@ -0,0 +1,207 @@
+import { MAX_AUDIO_BYTES } from "openclaw/plugin-sdk/media-runtime";
+import { assertOkOrThrowProviderError, assertProviderBinaryResponseContent, readProviderBinaryResponse, readProviderJsonResponse } from "openclaw/plugin-sdk/provider-http";
+import { asObject, trimToUndefined } from "openclaw/plugin-sdk/speech";
+import { fetchWithSsrFGuard, ssrfPolicyFromHttpBaseUrlAllowedHostname } from "openclaw/plugin-sdk/ssrf-runtime";
+//#region extensions/fish-audio/tts.ts
+const FISH_AUDIO_BASE_URL = "https://api.fish.audio";
+const FISH_AUDIO_VOICES_MAX_BYTES = 2 * 1024 * 1024;
+const FISH_AUDIO_VOICE_PAGE_SIZE = 100;
+const FISH_AUDIO_MAX_OWN_VOICE_PAGES = 20;
+function normalizeFishAudioBaseUrl(value) {
+	const trimmed = value?.trim();
+	return trimmed ? trimmed.replace(/\/+$/u, "") : FISH_AUDIO_BASE_URL;
+}
+function buildFishAudioRequestBody(params) {
+	return JSON.stringify({
+		text: params.text,
+		format: params.format,
+		...params.referenceId ? { reference_id: params.referenceId } : {},
+		...params.sampleRate == null ? {} : { sample_rate: params.sampleRate },
+		...params.latency == null ? {} : { latency: params.latency },
+		...params.speed == null ? {} : { prosody: { speed: params.speed } },
+		...params.temperature == null ? {} : { temperature: params.temperature },
+		...params.topP == null ? {} : { top_p: params.topP },
+		...params.normalize == null ? {} : { normalize: params.normalize }
+	});
+}
+async function requestFishAudioTts(params) {
+	const baseUrl = normalizeFishAudioBaseUrl(params.baseUrl);
+	return await fetchWithSsrFGuard({
+		url: `${baseUrl}/v1/tts`,
+		init: {
+			method: "POST",
+			headers: {
+				Authorization: `Bearer ${params.apiKey}`,
+				"Content-Type": "application/json",
+				model: params.model
+			},
+			body: buildFishAudioRequestBody(params)
+		},
+		timeoutMs: params.timeoutMs,
+		policy: ssrfPolicyFromHttpBaseUrlAllowedHostname(baseUrl),
+		auditContext: "fish-audio.tts"
+	});
+}
+async function fishAudioTts(params) {
+	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 }));
+	} finally {
+		await release();
+	}
+}
+function createBoundedFishAudioStream(stream, maxBytes) {
+	let reader;
+	let totalBytes = 0;
+	const releaseReader = (activeReader) => {
+		if (reader === activeReader) {
+			reader = void 0;
+			activeReader.releaseLock();
+		}
+	};
+	const cancelReader = async (reason) => {
+		const activeReader = reader;
+		if (!activeReader) return;
+		try {
+			await activeReader.cancel(reason).catch(() => void 0);
+		} finally {
+			releaseReader(activeReader);
+		}
+	};
+	return {
+		audioStream: new ReadableStream({
+			start() {
+				reader = stream.getReader();
+			},
+			async pull(controller) {
+				const activeReader = reader;
+				if (!activeReader) {
+					controller.close();
+					return;
+				}
+				try {
+					const chunk = await activeReader.read();
+					if (chunk.done) {
+						releaseReader(activeReader);
+						controller.close();
+						return;
+					}
+					const remaining = maxBytes - totalBytes;
+					if (chunk.value.byteLength > remaining) {
+						if (remaining > 0) controller.enqueue(chunk.value.subarray(0, remaining));
+						const error = /* @__PURE__ */ new Error(`Fish Audio TTS API error: audio response exceeds ${maxBytes} bytes`);
+						await activeReader.cancel(error).catch(() => void 0);
+						releaseReader(activeReader);
+						controller.error(error);
+						return;
+					}
+					totalBytes += chunk.value.byteLength;
+					controller.enqueue(chunk.value);
+				} catch (error) {
+					releaseReader(activeReader);
+					controller.error(error);
+				}
+			},
+			async cancel(reason) {
+				await cancelReader(reason);
+			}
+		}),
+		release: () => cancelReader(/* @__PURE__ */ new Error("Fish Audio TTS stream released"))
+	};
+}
+async function fishAudioTtsStream(params) {
+	const { response, release } = await requestFishAudioTts(params);
+	let handedOff = false;
+	try {
+		await assertOkOrThrowProviderError(response, "Fish Audio TTS API error");
+		assertProviderBinaryResponseContent(response, "Fish Audio TTS API error", "audio");
+		if (!response.body) throw new Error("Fish Audio TTS API response missing audio stream");
+		const bounded = createBoundedFishAudioStream(response.body, params.maxBytes);
+		let releasePromise;
+		const releaseAll = () => {
+			releasePromise ??= (async () => {
+				try {
+					await bounded.release();
+				} finally {
+					await release();
+				}
+			})();
+			return releasePromise;
+		};
+		handedOff = true;
+		return {
+			audioStream: bounded.audioStream,
+			release: releaseAll
+		};
+	} finally {
+		if (!handedOff) await release();
+	}
+}
+function parseVoiceItem(value) {
+	const item = asObject(value);
+	const id = trimToUndefined(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),
+		locale: languages[0],
+		personalities: tags.length > 0 ? tags : void 0
+	};
+}
+async function requestVoicePage(params) {
+	const url = new URL(`${normalizeFishAudioBaseUrl(params.baseUrl)}/model`);
+	url.searchParams.set("type", "tts");
+	url.searchParams.set("page_size", String(FISH_AUDIO_VOICE_PAGE_SIZE));
+	url.searchParams.set("page_number", String(params.pageNumber));
+	if (params.self) url.searchParams.set("self", "true");
+	else url.searchParams.set("sort_by", "score");
+	const { response, release } = await fetchWithSsrFGuard({
+		url: url.toString(),
+		init: { headers: { Authorization: `Bearer ${params.apiKey}` } },
+		timeoutMs: params.timeoutMs,
+		policy: ssrfPolicyFromHttpBaseUrlAllowedHostname(params.baseUrl),
+		auditContext: "fish-audio.voices"
+	});
+	try {
+		await assertOkOrThrowProviderError(response, "Fish Audio voices API error");
+		return await readProviderJsonResponse(response, "Fish Audio voices", { maxBytes: FISH_AUDIO_VOICES_MAX_BYTES });
+	} finally {
+		await release();
+	}
+}
+async function listFishAudioVoices(params) {
+	const own = [];
+	for (let pageNumber = 1; pageNumber <= FISH_AUDIO_MAX_OWN_VOICE_PAGES; pageNumber += 1) {
+		const payload = await requestVoicePage({
+			...params,
+			self: true,
+			pageNumber
+		});
+		const items = Array.isArray(payload.items) ? payload.items : [];
+		own.push(...items.flatMap((item) => parseVoiceItem(item) ?? []));
+		if (items.length < FISH_AUDIO_VOICE_PAGE_SIZE || own.length >= (payload.total ?? Number.MAX_SAFE_INTEGER)) break;
+	}
+	let publicVoices = [];
+	try {
+		const payload = await requestVoicePage({
+			...params,
+			self: false,
+			pageNumber: 1
+		});
+		publicVoices = (Array.isArray(payload.items) ? payload.items : []).flatMap((item) => parseVoiceItem(item) ?? []);
+	} catch {}
+	const seen = /* @__PURE__ */ new Set();
+	return [...own, ...publicVoices].filter((voice) => {
+		if (seen.has(voice.id)) return false;
+		seen.add(voice.id);
+		return true;
+	});
+}
+const FISH_AUDIO_STREAM_MAX_BYTES = MAX_AUDIO_BYTES;
+//#endregion
+export { FISH_AUDIO_STREAM_MAX_BYTES, fishAudioTts, fishAudioTtsStream, listFishAudioVoices, normalizeFishAudioBaseUrl };

package/openclaw.plugin.json

@@ -0,0 +1,24 @@
+{
+  "id": "fish-audio",
+  "activation": {
+    "onStartup": false
+  },
+  "name": "Fish Audio",
+  "description": "Fish Audio S2.1 hosted text-to-speech with streaming, voice notes, and telephony output.",
+  "setup": {
+    "providers": [
+      {
+        "id": "fish-audio",
+        "envVars": ["FISH_API_KEY", "FISH_AUDIO_API_KEY"]
+      }
+    ]
+  },
+  "contracts": {
+    "speechProviders": ["fish-audio"]
+  },
+  "configSchema": {
+    "type": "object",
+    "additionalProperties": false,
+    "properties": {}
+  }
+}

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "@openclaw/fish-audio-speech",
+  "version": "2026.7.2-beta.7",
+  "description": "OpenClaw Fish Audio speech plugin.",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/openclaw/openclaw"
+  },
+  "type": "module",
+  "openclaw": {
+    "extensions": [
+      "./index.ts"
+    ],
+    "install": {
+      "clawhubSpec": "clawhub:@openclaw/fish-audio-speech",
+      "npmSpec": "@openclaw/fish-audio-speech",
+      "defaultChoice": "npm",
+      "minHostVersion": ">=2026.7.2"
+    },
+    "compat": {
+      "pluginApi": ">=2026.7.2-beta.7"
+    },
+    "build": {
+      "openclawVersion": "2026.7.2-beta.7",
+      "bundledDist": false
+    },
+    "release": {
+      "publishToClawHub": true,
+      "publishToNpm": true
+    },
+    "runtimeExtensions": [
+      "./dist/index.js"
+    ]
+  },
+  "files": [
+    "dist/**",
+    "openclaw.plugin.json",
+    "README.md"
+  ],
+  "peerDependencies": {
+    "openclaw": ">=2026.7.2-beta.7"
+  },
+  "peerDependenciesMeta": {
+    "openclaw": {
+      "optional": true
+    }
+  },
+  "bundledDependencies": []
+}