### Fixes

- Media generation: honor configured music and video generation timeouts when tool calls omit `timeoutMs`, matching image generation behavior. (#80687)

- Plugins/update: include beta-channel fallback details in plugin update outcomes when `@beta` is unavailable and OpenClaw uses the recorded default/latest plugin spec, making mixed beta/latest plugin cohorts visible in update summaries. Fixes #80689. Thanks @BKF-Gitty.

- Control UI/performance: scope Nodes polling to the active Nodes tab, debounce stale session-list reconciliation, and bound chat-side session refreshes so long-running dashboards avoid background reload churn. Thanks @BunsDev.

- Plugins/channels: explain bundled channel entry files that reach the legacy plugin loader as setup-runtime loader mismatches instead of generic missing-register failures. Thanks @chinar-amrutkar.

Output format hint when the provider supports it.

</ParamField>

<ParamField path="filename" type="string">Output filename hint.</ParamField>

<ParamField path="timeoutMs" type="number">Optional provider request timeout in milliseconds. Values below 10000ms are raised to 10000ms and reported in the tool result.</ParamField>

<ParamField path="timeoutMs" type="number">Optional provider request timeout in milliseconds. When omitted, OpenClaw uses `agents.defaults.musicGenerationModel.timeoutMs` if configured. Values below 10000ms are raised to 10000ms and reported in the tool result.</ParamField>

<Note>

Not all providers support all parameters. OpenClaw still validates hard

</ParamField>

<ParamField path="model" type="string">Provider/model override (e.g. `runway/gen4.5`).</ParamField>

<ParamField path="filename" type="string">Output filename hint.</ParamField>

<ParamField path="timeoutMs" type="number">Optional provider operation timeout in milliseconds.</ParamField>

<ParamField path="timeoutMs" type="number">Optional provider operation timeout in milliseconds. When omitted, OpenClaw uses `agents.defaults.videoGenerationModel.timeoutMs` if configured.</ParamField>

<ParamField path="providerOptions" type="object">

Provider-specific options as a JSON object (e.g. `{"seed": 42, "draft": true}`).

Providers that declare a typed schema validate the keys and types; unknown

});

});

it("uses configured timeoutMs for music generation and lets calls override it", async () => {

vi.spyOn(musicGenerationRuntime, "generateMusic").mockResolvedValue({

provider: "google",

model: "lyria-3-clip-preview",

attempts: [],

ignoredOverrides: [],

tracks: [

{

buffer: Buffer.from("music-bytes"),

mimeType: "audio/mpeg",

fileName: "night-drive.mp3",

},

],

});

vi.spyOn(mediaStore, "saveMediaBuffer").mockResolvedValue({

path: "/tmp/generated-night-drive.mp3",

id: "generated-night-drive.mp3",

size: 11,

contentType: "audio/mpeg",

});

const tool = createMusicGenerateTool({

config: asConfig({

agents: {

defaults: {

musicGenerationModel: {

primary: "google/lyria-3-clip-preview",

timeoutMs: 180_000,

},

},

},

}),

});

if (!tool) {

throw new Error("expected music_generate tool");

}

const defaultResult = await tool.execute("call-timeout-default", {

prompt: "night-drive synthwave",

});

const overrideResult = await tool.execute("call-timeout-override", {

prompt: "night-drive synthwave",

timeoutMs: 12_345,

});

expect(generateMusicOptions(0).timeoutMs).toBe(180_000);

expect(generateMusicOptions(1).timeoutMs).toBe(12_345);

expect(detailsOf(defaultResult).timeoutMs).toBe(180_000);

expect(detailsOf(overrideResult).timeoutMs).toBe(12_345);

});

it("starts background generation and wakes the session with MEDIA lines", async () => {

taskExecutorMocks.createRunningTaskRun.mockReturnValue({

taskId: "task-123",

});

const format = normalizeOutputFormat(readStringParam(args, "format"));

const filename = readStringParam(args, "filename");

const requestedTimeoutMs = readGenerationTimeoutMs(args);

const requestedTimeoutMs =

readGenerationTimeoutMs(args) ?? musicGenerationModelConfig.timeoutMs;

const timeout = normalizeMusicGenerationTimeoutMs(requestedTimeoutMs);

const timeoutMs = timeout.timeoutMs;

const imageInputs = normalizeReferenceImageInputs(args);

expect(taskExecutorMocks.completeTaskRunByRunId).not.toHaveBeenCalled();

});

it("uses configured timeoutMs for video generation and lets calls override it", async () => {

mockVideoPluginProvider();

const generateSpy = mockSavedVideoResult();

const tool = createVideoGenerateTool({

config: asConfig({

agents: {

defaults: {

videoGenerationModel: {

primary: "video-plugin/vid-v1",

timeoutMs: 180_000,

},

},

},

}),

});

if (!tool) {

throw new Error("expected video_generate tool");

}

const defaultResult = await tool.execute("call-timeout-default", {

prompt: "friendly lobster surfing",

});

vi.spyOn(mediaStore, "saveMediaBuffer").mockResolvedValueOnce({

path: "/tmp/out-override.mp4",

id: "out-override.mp4",

size: 11,

contentType: "video/mp4",

});

const overrideResult = await tool.execute("call-timeout-override", {

prompt: "friendly lobster surfing",

timeoutMs: 12_345,

});

expect((firstMockCallArg(generateSpy) as { timeoutMs?: number }).timeoutMs).toBe(180_000);

expect((generateSpy.mock.calls[1]?.[0] as { timeoutMs?: number }).timeoutMs).toBe(12_345);

expect(resultDetails(defaultResult).timeoutMs).toBe(180_000);

expect(resultDetails(overrideResult).timeoutMs).toBe(12_345);

});

it("uses the video media cap when mediaMaxMb is not configured", async () => {

vi.spyOn(videoGenerationRuntime, "generateVideo").mockResolvedValue({

provider: "qwen",

});

const audio = readBooleanToolParam(args, "audio");

const watermark = readBooleanToolParam(args, "watermark");

const timeoutMs = readGenerationTimeoutMs(args);

const timeoutMs = readGenerationTimeoutMs(args) ?? videoGenerationModelConfig.timeoutMs;

// providerOptions must be a plain object. Arrays are objects in JS, so

// exclude them explicitly — a bogus call like `providerOptions: ["seed", 42]`

// would otherwise be cast to `Record<string, unknown>` with numeric-string

]);

});

it("uses configured music-generation timeout when call omits timeoutMs", async () => {

let seenTimeoutMs: number | undefined;

providers = [

{

id: "music-plugin",

capabilities: {},

async generateMusic(req: { timeoutMs?: number }) {

seenTimeoutMs = req.timeoutMs;

return {

tracks: [{ buffer: Buffer.from("mp3-bytes"), mimeType: "audio/mpeg" }],

model: "track-v1",

};

},

},

];

await runGenerateMusic({

cfg: {

agents: {

defaults: {

musicGenerationModel: { primary: "music-plugin/track-v1", timeoutMs: 300_000 },

},

},

} as OpenClawConfig,

prompt: "play a synth line",

});

expect(seenTimeoutMs).toBe(300_000);

});

it("does not list providers when explicit config disables auto provider fallback", async () => {

const provider: MusicGenerationProvider = {

id: "music-plugin",

import type { FallbackAttempt } from "../agents/model-fallback.types.js";

import { resolveAgentModelTimeoutMsValue } from "../config/model-input.js";

import type { OpenClawConfig } from "../config/types.openclaw.js";

import { createSubsystemLogger } from "../logging/subsystem.js";

import {

const getProvider = deps.getProvider ?? getMusicGenerationProvider;

const listProviders = deps.listProviders ?? listMusicGenerationProviders;

const logger = deps.log ?? log;

const timeoutMs =

params.timeoutMs ??

resolveAgentModelTimeoutMsValue(params.cfg.agents?.defaults?.musicGenerationModel);

const candidates = resolveCapabilityModelCandidates({

cfg: params.cfg,

modelConfig: params.cfg.agents?.defaults?.musicGenerationModel,

durationSeconds: sanitized.durationSeconds,

format: sanitized.format,

inputImages: params.inputImages,

...(params.timeoutMs !== undefined ? { timeoutMs: params.timeoutMs } : {}),

...(timeoutMs !== undefined ? { timeoutMs } : {}),

});

if (!Array.isArray(result.tracks) || result.tracks.length === 0) {

throw new Error("Music generation provider returned no tracks.");

]);

});

it("uses configured video-generation timeout when call omits timeoutMs", async () => {

let seenTimeoutMs: number | undefined;

providers = [

{

id: "video-plugin",

capabilities: {},

async generateVideo(req: { timeoutMs?: number }) {

seenTimeoutMs = req.timeoutMs;

return {

videos: [{ buffer: Buffer.from("mp4-bytes"), mimeType: "video/mp4" }],

model: "vid-v1",

};

},

},

];

await runGenerateVideo({

cfg: {

agents: {

defaults: {

videoGenerationModel: { primary: "video-plugin/vid-v1", timeoutMs: 300_000 },

},

},

} as OpenClawConfig,

prompt: "animate a cat",

});

expect(seenTimeoutMs).toBe(300_000);

});

it("does not list providers when explicit config disables auto provider fallback", async () => {

const provider: VideoGenerationProvider = {

id: "video-plugin",