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/senseaudio/index.ts

@@ -0,0 +1,12 @@
+// Senseaudio plugin entrypoint registers its OpenClaw integration.
+import { definePluginEntry } from "openclaw/plugin-sdk/plugin-entry";
+import { senseaudioMediaUnderstandingProvider } from "./media-understanding-provider.js";
+
+export default definePluginEntry({
+  id: "senseaudio",
+  name: "SenseAudio",
+  description: "Bundled SenseAudio audio transcription provider",
+  register(api) {
+    api.registerMediaUnderstandingProvider(senseaudioMediaUnderstandingProvider);
+  },
+});

extensions/senseaudio/media-understanding-provider.test.ts

@@ -0,0 +1,137 @@
+// Senseaudio tests cover media understanding provider plugin behavior.
+import { spawnSync } from "node:child_process";
+import { mkdtempSync, readFileSync, rmSync } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { runFfmpeg } from "openclaw/plugin-sdk/media-runtime";
+import {
+  createAuthCaptureJsonFetch,
+  createRequestCaptureJsonFetch,
+  installPinnedHostnameTestHooks,
+} from "openclaw/plugin-sdk/test-env";
+import { describe, expect, it } from "vitest";
+import { transcribeSenseAudioAudio } from "./media-understanding-provider.js";
+
+installPinnedHostnameTestHooks();
+
+describe("transcribeSenseAudioAudio", () => {
+  it("uses SenseAudio base URL by default", async () => {
+    const { fetchFn, getRequest } = createRequestCaptureJsonFetch({ text: "ok" });
+
+    await transcribeSenseAudioAudio({
+      buffer: Buffer.from("audio"),
+      fileName: "note.mp3",
+      apiKey: "test-key",
+      timeoutMs: 1000,
+      fetchFn,
+    });
+
+    expect(getRequest().url).toBe("https://api.senseaudio.cn/v1/audio/transcriptions");
+  });
+
+  it("respects lowercase authorization header overrides", async () => {
+    const { fetchFn, getAuthHeader } = createAuthCaptureJsonFetch({ text: "ok" });
+
+    const result = await transcribeSenseAudioAudio({
+      buffer: Buffer.from("audio"),
+      fileName: "note.mp3",
+      apiKey: "test-key",
+      timeoutMs: 1000,
+      headers: { authorization: "Bearer override" },
+      fetchFn,
+    });
+
+    expect(getAuthHeader()).toBe("Bearer override");
+    expect(result.text).toBe("ok");
+  });
+
+  it("builds the expected request payload", async () => {
+    const { fetchFn, getRequest } = createRequestCaptureJsonFetch({ text: "hello" });
+
+    const result = await transcribeSenseAudioAudio({
+      buffer: Buffer.from("audio-bytes"),
+      fileName: "voice.wav",
+      apiKey: "test-key",
+      timeoutMs: 1234,
+      baseUrl: "https://api.example.com/v1/",
+      model: " ",
+      language: " en ",
+      prompt: " hello ",
+      mime: "audio/wav",
+      headers: { "X-Custom": "1" },
+      fetchFn,
+    });
+    const { url: seenUrl, init: seenInit } = getRequest();
+
+    expect(result.model).toBe("senseaudio-asr-pro-1.5-260319");
+    expect(result.text).toBe("hello");
+    expect(seenUrl).toBe("https://api.example.com/v1/audio/transcriptions");
+    expect(seenInit?.method).toBe("POST");
+    expect(seenInit?.signal).toBeInstanceOf(AbortSignal);
+
+    const headers = new Headers(seenInit?.headers);
+    expect(headers.get("authorization")).toBe("Bearer test-key");
+    expect(headers.get("x-custom")).toBe("1");
+
+    const form = seenInit?.body as FormData;
+    expect(form).toBeInstanceOf(FormData);
+    expect(form.get("model")).toBe("senseaudio-asr-pro-1.5-260319");
+    expect(form.get("language")).toBe("en");
+    expect(form.get("prompt")).toBe("hello");
+    const file = form.get("file") as Blob | { type?: string; name?: string } | null;
+    if (!file) {
+      throw new Error("expected SenseAudio audio file");
+    }
+    expect(file.type).toBe("audio/wav");
+    if (file && "name" in file && typeof file.name === "string") {
+      expect(file.name).toBe("voice.wav");
+    }
+  });
+
+  it("throws when the provider response omits text", async () => {
+    const { fetchFn } = createRequestCaptureJsonFetch({});
+
+    await expect(
+      transcribeSenseAudioAudio({
+        buffer: Buffer.from("audio-bytes"),
+        fileName: "voice.wav",
+        apiKey: "test-key",
+        timeoutMs: 1234,
+        fetchFn,
+      }),
+    ).rejects.toThrow("Audio transcription response missing text");
+  });
+
+  it("can transcribe generated speech in live mode", async () => {
+    if (process.env.OPENCLAW_LIVE_TEST !== "1" || !process.env.SENSEAUDIO_API_KEY) {
+      return;
+    }
+    const say = spawnSync("sh", ["-lc", "command -v say"], { encoding: "utf8" });
+    if (say.status !== 0) {
+      return;
+    }
+
+    const tempDir = mkdtempSync(path.join(os.tmpdir(), "openclaw-senseaudio-live-"));
+    try {
+      const aiffPath = path.join(tempDir, "speech.aiff");
+      const mp3Path = path.join(tempDir, "speech.mp3");
+      const sayResult = spawnSync("say", ["-o", aiffPath, "open claw live transcription test"], {
+        encoding: "utf8",
+      });
+      expect(sayResult.status).toBe(0);
+      await runFfmpeg(["-y", "-i", aiffPath, "-c:a", "libmp3lame", "-b:a", "96k", mp3Path]);
+
+      const result = await transcribeSenseAudioAudio({
+        buffer: readFileSync(mp3Path),
+        fileName: "speech.mp3",
+        mime: "audio/mpeg",
+        apiKey: process.env.SENSEAUDIO_API_KEY,
+        timeoutMs: 30_000,
+      });
+
+      expect(result.text.trim().length).toBeGreaterThan(0);
+    } finally {
+      rmSync(tempDir, { recursive: true, force: true });
+    }
+  });
+});

extensions/senseaudio/media-understanding-provider.ts

@@ -0,0 +1,26 @@
+// Senseaudio provider module implements model/runtime integration.
+import {
+  transcribeOpenAiCompatibleAudio,
+  type AudioTranscriptionRequest,
+  type MediaUnderstandingProvider,
+} from "openclaw/plugin-sdk/media-understanding";
+
+const DEFAULT_SENSEAUDIO_AUDIO_BASE_URL = "https://api.senseaudio.cn/v1";
+const DEFAULT_SENSEAUDIO_AUDIO_MODEL = "senseaudio-asr-pro-1.5-260319";
+
+export async function transcribeSenseAudioAudio(params: AudioTranscriptionRequest) {
+  return await transcribeOpenAiCompatibleAudio({
+    ...params,
+    provider: "senseaudio",
+    defaultBaseUrl: DEFAULT_SENSEAUDIO_AUDIO_BASE_URL,
+    defaultModel: DEFAULT_SENSEAUDIO_AUDIO_MODEL,
+  });
+}
+
+export const senseaudioMediaUnderstandingProvider: MediaUnderstandingProvider = {
+  id: "senseaudio",
+  capabilities: ["audio"],
+  defaultModels: { audio: DEFAULT_SENSEAUDIO_AUDIO_MODEL },
+  autoPriority: { audio: 40 },
+  transcribeAudio: transcribeSenseAudioAudio,
+};

extensions/senseaudio/openclaw.plugin.json

@@ -0,0 +1,23 @@
+{
+  "id": "senseaudio",
+  "activation": {
+    "onStartup": false
+  },
+  "enabledByDefault": true,
+  "setup": {
+    "providers": [
+      {
+        "id": "senseaudio",
+        "envVars": ["SENSEAUDIO_API_KEY"]
+      }
+    ]
+  },
+  "contracts": {
+    "mediaUnderstandingProviders": ["senseaudio"]
+  },
+  "configSchema": {
+    "type": "object",
+    "additionalProperties": false,
+    "properties": {}
+  }
+}

extensions/senseaudio/package.json

@@ -0,0 +1,15 @@
+{
+  "name": "@openclaw/senseaudio-provider",
+  "version": "2026.6.11",
+  "private": true,
+  "description": "OpenClaw SenseAudio media-understanding provider",
+  "type": "module",
+  "devDependencies": {
+    "@openclaw/plugin-sdk": "workspace:*"
+  },
+  "openclaw": {
+    "extensions": [
+      "./index.ts"
+    ]
+  }
+}

extensions/senseaudio/test-api.ts

@@ -0,0 +1,2 @@
+// Senseaudio API module exposes the plugin public contract.
+export { senseaudioMediaUnderstandingProvider } from "./media-understanding-provider.js";