### Fixes

- Media/audio: skip empty structured sherpa-onnx transcripts instead of treating the raw JSON payload as spoken text. (#84667) Thanks @TurboTheTurtle.

- CLI/perf: keep `setup --help`, `onboard --help`, and `configure --help` out of the full wizard runtime while preserving the existing help output. (#84488) Thanks @frankekn.

## 2026.5.20

expectCliRunOptions(options);

});

it("skips auto-detected sherpa audio when structured output has empty text", async () => {

clearMediaUnderstandingBinaryCacheForTests();

const binDir = await createTempMediaDir();

const modelDir = await createTempMediaDir();

await createMockExecutable(binDir, "sherpa-onnx-offline");

await fs.writeFile(path.join(modelDir, "tokens.txt"), "a");

await fs.writeFile(path.join(modelDir, "encoder.onnx"), "a");

await fs.writeFile(path.join(modelDir, "decoder.onnx"), "a");

await fs.writeFile(path.join(modelDir, "joiner.onnx"), "a");

const emptySherpaJson =

'{"lang":"","emotion":"","event":"","text":"","timestamps":[],"durations":[],"tokens":[],"ys_log_probs":[],"words":[]}';

const { ctx, cfg } = await setupAudioAutoDetectCase(emptySherpaJson);

await withMediaAutoDetectEnv(

{

PATH: binDir,

SHERPA_ONNX_MODEL_DIR: modelDir,

},

async () => {

const result = await applyMediaUnderstanding({ ctx, cfg });

expect(result.appliedAudio).toBe(false);

},

);

expect(ctx.Transcript).toBeUndefined();

expect(ctx.Body).toBe("<media:audio>");

const [command] = getRunExecCall();

expect(command).toBe("sherpa-onnx-offline");

});

it("auto-detects whisper-cli when sherpa is unavailable", async () => {

clearMediaUnderstandingBinaryCacheForTests();

const binDir = await createTempMediaDir();

maxBuffer: CLI_OUTPUT_MAX_BUFFER,

});

});

it("treats sherpa structured JSON with empty text as empty output", async () => {

runExecMock.mockResolvedValueOnce({

stdout:

'{"lang":"","emotion":"","event":"","text":"","timestamps":[],"durations":[],"tokens":[],"ys_log_probs":[],"words":[]}',

stderr: "",

});

await withAudioFixture("openclaw-cli-audio-empty-sherpa", async ({ ctx, cache }) => {

const result = await runCliEntry({

capability: "audio",

entry: {

type: "cli",

command: "sherpa-onnx-offline",

args: ["{{MediaPath}}"],

},

cfg: { tools: { media: { audio: {} } } } as OpenClawConfig,

ctx,

attachmentIndex: 0,

cache,

config: {} as never,

});

expect(result).toBeNull();

});

});

it("extracts sherpa text from the final structured output line", async () => {

runExecMock.mockResolvedValueOnce({

stdout: 'loading model\n{"text":"sherpa transcript","tokens":["sherpa","transcript"]}\n',

stderr: "",

});

await withAudioFixture("openclaw-cli-audio-sherpa-json", async ({ ctx, cache }) => {

const result = await runCliEntry({

capability: "audio",

entry: {

type: "cli",

command: "sherpa-onnx-offline",

args: ["{{MediaPath}}"],

},

cfg: { tools: { media: { audio: {} } } } as OpenClawConfig,

ctx,

attachmentIndex: 0,

cache,

config: {} as never,

});

expect(result?.text).toBe("sherpa transcript");

});

});

});

return trimmed.slice(0, maxChars).trim();

}

function extractSherpaOnnxText(raw: string): string | null {

const tryParse = (value: string): string | null => {

function extractSherpaOnnxText(raw: string): { matched: boolean; text: string } {

const noMatch = { matched: false, text: "" };

const tryParse = (value: string): { matched: boolean; text: string } => {

const trimmed = value.trim();

if (!trimmed) {

return null;

return noMatch;

}

const head = trimmed[0];

if (head !== "{" && head !== '"') {

return null;

return noMatch;

}

try {

const parsed = JSON.parse(trimmed) as unknown;

}

if (parsed && typeof parsed === "object") {

const text = (parsed as { text?: unknown }).text;

if (typeof text === "string" && text.trim()) {

return text.trim();

if (typeof text === "string") {

return { matched: true, text: text.trim() };

}

}

} catch {}

return null;

return noMatch;

};

const direct = tryParse(raw);

if (direct) {

if (direct.matched) {

return direct;

}

.filter(Boolean);

for (let i = lines.length - 1; i >= 0; i -= 1) {

const parsed = tryParse(lines[i] ?? "");

if (parsed) {

if (parsed.matched) {

return parsed;

}

}

return null;

return noMatch;

}

function commandBase(command: string): string {

if (commandId === "sherpa-onnx-offline") {

const response = extractSherpaOnnxText(params.stdout);

if (response) {

return response;

if (response.matched) {

return response.text;

}

}

return YAML.parse(fs.readFileSync(workspacePath, "utf8")) as PnpmWorkspaceConfig;

}

function readPackageManifest(packagePath: string): RootPackageManifest {

return JSON.parse(fs.readFileSync(packagePath, "utf8")) as RootPackageManifest;

}

describe("root package override guardrails", () => {

it("keeps Bedrock runtime ownership in the Amazon provider plugin", () => {

const manifest = readRootManifest();

const pnpmWorkspace = readPnpmWorkspaceConfig();

const packageName = "@aws-sdk/client-bedrock-runtime";

const bedrockManifest = readPackageManifest(

path.resolve(process.cwd(), "extensions", "amazon-bedrock", "package.json"),

);

const bedrockRuntimeDependency = bedrockManifest.dependencies?.[packageName];

const npmOverride = manifest.overrides?.[packageName];

const pnpmOverride = pnpmWorkspace.overrides?.["@aws-sdk/client-bedrock-runtime"];

const pnpmOverride = pnpmWorkspace.overrides?.[packageName];

expect(bedrockRuntimeDependency).toBeDefined();

expect(manifest.dependencies).not.toHaveProperty(packageName);

expect(npmOverride).toBeUndefined();

expect(pnpmOverride).toBe("3.1048.0");

expect(pnpmOverride).toBe(bedrockRuntimeDependency);

});

it("pins the node-domexception alias exactly in npm and pnpm overrides", () => {