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/xai/speech-provider.test.ts

@@ -0,0 +1,213 @@
+// Xai tests cover speech provider plugin behavior.
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { buildXaiSpeechProvider } from "./speech-provider.js";
+
+const { xaiTTSMock, isProviderAuthProfileConfiguredMock, resolveApiKeyForProviderMock } =
+  vi.hoisted(() => ({
+    xaiTTSMock: vi.fn(async () => Buffer.from("audio-bytes")),
+    isProviderAuthProfileConfiguredMock: vi.fn(() => false),
+    resolveApiKeyForProviderMock: vi.fn(
+      async (): Promise<{ apiKey: string | undefined }> => ({ apiKey: undefined }),
+    ),
+  }));
+
+vi.mock("./tts.js", () => ({
+  XAI_BASE_URL: "https://api.x.ai/v1",
+  XAI_TTS_VOICES: ["eve", "ara", "rex", "sal", "leo", "una"],
+  isValidXaiTtsVoice: (voice: string) => ["eve", "ara", "rex", "sal", "leo", "una"].includes(voice),
+  normalizeXaiLanguageCode: (value: unknown) =>
+    typeof value === "string" && value.trim() ? value.trim().toLowerCase() : undefined,
+  normalizeXaiTtsBaseUrl: (baseUrl?: string) =>
+    baseUrl?.trim().replace(/\/+$/, "") || "https://api.x.ai/v1",
+  xaiTTS: xaiTTSMock,
+}));
+
+vi.mock("openclaw/plugin-sdk/provider-auth", () => ({
+  isProviderAuthProfileConfigured: isProviderAuthProfileConfiguredMock,
+}));
+
+vi.mock("openclaw/plugin-sdk/provider-auth-runtime", () => ({
+  resolveApiKeyForProvider: resolveApiKeyForProviderMock,
+}));
+
+function requireLastTtsCall(): {
+  text?: string;
+  apiKey?: string;
+  baseUrl?: string;
+  voiceId?: string;
+  language?: string;
+  speed?: number;
+  responseFormat?: string;
+  maxBytes?: number;
+} {
+  const params = (xaiTTSMock.mock.calls as unknown as Array<[unknown]>).at(-1)?.[0] as
+    | {
+        text?: string;
+        apiKey?: string;
+        baseUrl?: string;
+        voiceId?: string;
+        language?: string;
+        speed?: number;
+        responseFormat?: string;
+        maxBytes?: number;
+      }
+    | undefined;
+  if (!params) {
+    throw new Error("Expected xaiTTS call");
+  }
+  return params;
+}
+
+describe("xai speech provider", () => {
+  afterEach(() => {
+    isProviderAuthProfileConfiguredMock.mockReset();
+    isProviderAuthProfileConfiguredMock.mockReturnValue(false);
+    resolveApiKeyForProviderMock.mockReset();
+    resolveApiKeyForProviderMock.mockResolvedValue({ apiKey: undefined });
+    delete process.env.XAI_API_KEY;
+  });
+
+  it("synthesizes mp3 audio and does not claim native voice-note compatibility", async () => {
+    const provider = buildXaiSpeechProvider();
+    const result = await provider.synthesize({
+      text: "hello",
+      cfg: {
+        agents: {
+          defaults: {
+            mediaMaxMb: 2,
+          },
+        },
+      },
+      providerConfig: {
+        apiKey: "xai-key",
+        voiceId: "eve",
+      },
+      target: "voice-note",
+      timeoutMs: 5_000,
+    });
+
+    expect(result.outputFormat).toBe("mp3");
+    expect(result.fileExtension).toBe(".mp3");
+    expect(result.voiceCompatible).toBe(false);
+    expect(result.audioBuffer.byteLength).toBeGreaterThan(0);
+    const tts = requireLastTtsCall();
+    expect(tts.text).toBe("hello");
+    expect(tts.apiKey).toBe("xai-key");
+    expect(tts.baseUrl).toBe("https://api.x.ai/v1");
+    expect(tts.voiceId).toBe("eve");
+    expect(tts.responseFormat).toBe("mp3");
+    expect(tts.maxBytes).toBe(2 * 1024 * 1024);
+  });
+
+  it("honors configured response formats", async () => {
+    const provider = buildXaiSpeechProvider();
+    const result = await provider.synthesize({
+      text: "hello",
+      cfg: {},
+      providerConfig: {
+        apiKey: "xai-key",
+        responseFormat: "wav",
+      },
+      target: "audio-file",
+      timeoutMs: 5_000,
+    });
+
+    expect(result.outputFormat).toBe("wav");
+    expect(result.fileExtension).toBe(".wav");
+    expect(requireLastTtsCall().responseFormat).toBe("wav");
+  });
+
+  it("honors voice, language, and speed overrides for telephony output", async () => {
+    const provider = buildXaiSpeechProvider();
+    const result = await provider.synthesizeTelephony?.({
+      text: "hello",
+      cfg: {},
+      providerConfig: {
+        apiKey: "xai-key",
+        baseUrl: "https://api.x.ai/v1",
+        voiceId: "eve",
+        language: "en",
+        speed: 1,
+      },
+      providerOverrides: {
+        voice: "aura",
+        language: "es",
+        speed: 1.2,
+      },
+      timeoutMs: 5_000,
+    });
+
+    expect(result).toEqual({
+      audioBuffer: Buffer.from("audio-bytes"),
+      outputFormat: "pcm",
+      sampleRate: 24_000,
+    });
+    const tts = requireLastTtsCall();
+    expect(tts.voiceId).toBe("aura");
+    expect(tts.language).toBe("es");
+    expect(tts.speed).toBe(1.2);
+    expect(tts.responseFormat).toBe("pcm");
+  });
+
+  it("drops malformed speed values before synthesis", async () => {
+    const provider = buildXaiSpeechProvider();
+    await provider.synthesize({
+      text: "hello",
+      cfg: {},
+      providerConfig: {
+        apiKey: "xai-key",
+        speed: 2,
+      },
+      providerOverrides: {
+        speed: 0.5,
+      },
+      target: "audio-file",
+      timeoutMs: 5_000,
+    });
+
+    expect(requireLastTtsCall().speed).toBeUndefined();
+  });
+
+  it("reports configured when an xAI auth profile exists, even without env or config apiKey", () => {
+    isProviderAuthProfileConfiguredMock.mockReturnValue(true);
+    const provider = buildXaiSpeechProvider();
+    expect(
+      provider.isConfigured({
+        cfg: {},
+        providerConfig: {},
+        timeoutMs: 5_000,
+      }),
+    ).toBe(true);
+    expect(isProviderAuthProfileConfiguredMock).toHaveBeenCalledWith({
+      provider: "xai",
+      cfg: {},
+    });
+  });
+
+  it("reports not configured when there is no apiKey, env, or auth profile", () => {
+    isProviderAuthProfileConfiguredMock.mockReturnValue(false);
+    const provider = buildXaiSpeechProvider();
+    expect(
+      provider.isConfigured({
+        cfg: {},
+        providerConfig: {},
+        timeoutMs: 5_000,
+      }),
+    ).toBe(false);
+  });
+
+  it("threads cfg into the OAuth fallback resolver when no direct apiKey is available", async () => {
+    resolveApiKeyForProviderMock.mockResolvedValueOnce({ apiKey: "oauth-bearer" });
+    const provider = buildXaiSpeechProvider();
+    const cfg = { agents: { defaults: {} } };
+    await provider.synthesize({
+      text: "hello",
+      cfg,
+      providerConfig: {},
+      target: "voice-note",
+      timeoutMs: 5_000,
+    });
+    expect(resolveApiKeyForProviderMock).toHaveBeenCalledWith({ provider: "xai", cfg });
+    expect(requireLastTtsCall().apiKey).toBe("oauth-bearer");
+  });
+});