Vendor OpenClaw source as Adolf fork baseline

Adolf is a fork/vendored clone of github.com/openclaw/openclaw (v2026.6.11),
free to diverge. Tree copied sans upstream .git; upstream remote added for
future syncs. Node pinned to 24 (.nvmrc); engines already require >=22.19.
Preserves docs/ARCHITECTURE.md.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01LeqyaxJF2nbRXJtae2kNB2

extensions/vydra/speech-provider.ts

@@ -0,0 +1,156 @@
+// Vydra provider module implements model/runtime integration.
+import {
+  assertOkOrThrowHttpError,
+  postJsonRequest,
+  readProviderJsonResponse,
+  resolveProviderHttpRequestConfig,
+} from "openclaw/plugin-sdk/provider-http";
+import { normalizeResolvedSecretInputString } from "openclaw/plugin-sdk/secret-input";
+import type {
+  SpeechProviderConfig,
+  SpeechProviderOverrides,
+  SpeechProviderPlugin,
+} from "openclaw/plugin-sdk/speech-core";
+import { asObject } from "openclaw/plugin-sdk/speech-core";
+import {
+  DEFAULT_VYDRA_BASE_URL,
+  DEFAULT_VYDRA_SPEECH_MODEL,
+  DEFAULT_VYDRA_VOICE_ID,
+  downloadVydraAsset,
+  extractVydraResultUrls,
+  normalizeVydraBaseUrl,
+  resolveVydraGeneratedMediaMaxBytes,
+  trimToUndefined,
+} from "./shared.js";
+
+type VydraSpeechConfig = {
+  apiKey?: string;
+  baseUrl: string;
+  model: string;
+  voiceId: string;
+};
+
+const VYDRA_SPEECH_VOICES = [
+  {
+    id: DEFAULT_VYDRA_VOICE_ID,
+    name: "Rachel",
+  },
+] as const;
+
+function normalizeVydraSpeechConfig(rawConfig: Record<string, unknown>): VydraSpeechConfig {
+  const providers = asObject(rawConfig.providers);
+  const raw = asObject(providers?.vydra) ?? asObject(rawConfig.vydra);
+  return {
+    apiKey: normalizeResolvedSecretInputString({
+      value: raw?.apiKey,
+      path: "messages.tts.providers.vydra.apiKey",
+    }),
+    baseUrl: normalizeVydraBaseUrl(
+      trimToUndefined(raw?.baseUrl) ?? trimToUndefined(process.env.VYDRA_BASE_URL),
+    ),
+    model:
+      trimToUndefined(raw?.model) ??
+      trimToUndefined(process.env.VYDRA_TTS_MODEL) ??
+      DEFAULT_VYDRA_SPEECH_MODEL,
+    voiceId:
+      trimToUndefined(raw?.voiceId) ??
+      trimToUndefined(process.env.VYDRA_TTS_VOICE_ID) ??
+      DEFAULT_VYDRA_VOICE_ID,
+  };
+}
+
+function readVydraSpeechConfig(config: SpeechProviderConfig): VydraSpeechConfig {
+  const normalized = normalizeVydraSpeechConfig({});
+  return {
+    apiKey: trimToUndefined(config.apiKey) ?? normalized.apiKey,
+    baseUrl: normalizeVydraBaseUrl(trimToUndefined(config.baseUrl) ?? normalized.baseUrl),
+    model: trimToUndefined(config.model) ?? normalized.model,
+    voiceId: trimToUndefined(config.voiceId) ?? normalized.voiceId,
+  };
+}
+
+function readVydraOverrides(overrides: SpeechProviderOverrides | undefined): {
+  model?: string;
+  voiceId?: string;
+} {
+  if (!overrides) {
+    return {};
+  }
+  return {
+    model: trimToUndefined(overrides.model),
+    voiceId: trimToUndefined(overrides.voiceId),
+  };
+}
+
+export function buildVydraSpeechProvider(): SpeechProviderPlugin {
+  return {
+    id: "vydra",
+    label: "Vydra",
+    models: [DEFAULT_VYDRA_SPEECH_MODEL],
+    voices: VYDRA_SPEECH_VOICES.map((voice) => voice.id),
+    resolveConfig: ({ rawConfig }) => normalizeVydraSpeechConfig(rawConfig),
+    listVoices: async () => VYDRA_SPEECH_VOICES.map((voice) => Object.assign({}, voice)),
+    isConfigured: ({ providerConfig }) =>
+      Boolean(readVydraSpeechConfig(providerConfig).apiKey || process.env.VYDRA_API_KEY),
+    synthesize: async (req) => {
+      const config = readVydraSpeechConfig(req.providerConfig);
+      const overrides = readVydraOverrides(req.providerOverrides);
+      const apiKey = config.apiKey || process.env.VYDRA_API_KEY;
+      if (!apiKey) {
+        throw new Error("Vydra API key missing");
+      }
+
+      const fetchFn = fetch;
+      const { baseUrl, allowPrivateNetwork, headers, dispatcherPolicy } =
+        resolveProviderHttpRequestConfig({
+          baseUrl: config.baseUrl,
+          defaultBaseUrl: DEFAULT_VYDRA_BASE_URL,
+          allowPrivateNetwork: false,
+          defaultHeaders: {
+            Authorization: `Bearer ${apiKey}`,
+            "Content-Type": "application/json",
+          },
+          provider: "vydra",
+          capability: "audio",
+          transport: "http",
+        });
+
+      const { response, release } = await postJsonRequest({
+        url: `${baseUrl}/models/${overrides.model ?? config.model}`,
+        headers,
+        body: {
+          text: req.text,
+          voice_id: overrides.voiceId ?? config.voiceId,
+        },
+        timeoutMs: req.timeoutMs,
+        fetchFn,
+        allowPrivateNetwork,
+        dispatcherPolicy,
+      });
+
+      try {
+        await assertOkOrThrowHttpError(response, "Vydra speech synthesis failed");
+        const payload = await readProviderJsonResponse<unknown>(response, "Vydra speech synthesis");
+        const audioUrl = extractVydraResultUrls(payload, "audio")[0];
+        if (!audioUrl) {
+          throw new Error("Vydra speech synthesis response missing audio URL");
+        }
+        const audio = await downloadVydraAsset({
+          url: audioUrl,
+          kind: "audio",
+          timeoutMs: req.timeoutMs,
+          fetchFn,
+          maxBytes: resolveVydraGeneratedMediaMaxBytes({ cfg: req.cfg, kind: "audio" }),
+        });
+        return {
+          audioBuffer: audio.buffer,
+          outputFormat: audio.mimeType.includes("wav") ? "wav" : "mp3",
+          fileExtension: audio.fileName.endsWith(".wav") ? ".wav" : ".mp3",
+          voiceCompatible: false,
+        };
+      } finally {
+        await release();
+      }
+    },
+  };
+}