### Fixes

- Agents/media: register detached `video_generate` and `music_generate` tool run contexts until terminal status, so Discord-backed provider jobs stay live in `/tasks` instead of becoming `lost` when the parent chat run context disappears. Thanks @vincentkoc.

- Agents/media: prefer OpenAI image and video providers when the default model uses the OpenAI Codex auth alias, so auto media generation no longer falls through to Fal before GPT Image or Sora. Thanks @vincentkoc.

- Tasks/media: infer agent ownership for session-scoped task records so `/tasks` agent-local fallback includes session-backed `video_generate` and other async media jobs even when the current chat session has no linked rows. Thanks @vincentkoc.

- Agents/media: keep long-running `video_generate` and `music_generate` tasks fresh while provider jobs are still pending, so task maintenance does not mark active Discord media renders lost before completion. Thanks @vincentkoc.

- CLI/status: treat scope-limited gateway probes as reachable-but-degraded in shared status scans, so `openclaw status --all` no longer reports a live gateway as unreachable after `missing scope: operator.read`. Fixes #49180; supersedes #47981. Thanks @openjay.

const provider = buildOpenAIImageGenerationProvider();

expect(provider.defaultModel).toBe("gpt-image-2");

expect(provider.aliases).toContain("openai-codex");

expect(provider.models).toEqual([

"gpt-image-2",

"gpt-image-1.5",

}): ImageGenerationProvider {

return {

id: params.id,

aliases: ["openai-codex"],

label: params.label,

defaultModel: DEFAULT_OPENAI_IMAGE_MODEL,

models: [...OPENAI_IMAGE_MODELS],

installProviderHttpMockCleanup();

describe("openai video generation provider", () => {

it("declares the openai-codex alias for default-model ordering", () => {

const provider = buildOpenAIVideoGenerationProvider();

expect(provider.aliases).toContain("openai-codex");

});

it("declares explicit mode capabilities", () => {

expectExplicitVideoGenerationCapabilities(buildOpenAIVideoGenerationProvider());

});

export function buildOpenAIVideoGenerationProvider(): VideoGenerationProvider {

return {

id: "openai",

aliases: ["openai-codex"],

label: "OpenAI",

defaultModel: DEFAULT_OPENAI_VIDEO_MODEL,

models: [DEFAULT_OPENAI_VIDEO_MODEL, "sora-2-pro"],

});

});

it("prefers OpenAI image generation when the default model uses its Codex provider alias", () => {

vi.spyOn(imageGenerationRuntime, "listRuntimeImageGenerationProviders").mockReturnValue([

{

id: "fal",

defaultModel: "fal-ai/flux/dev",

models: ["fal-ai/flux/dev"],

isConfigured: () => true,

capabilities: {

generate: { maxCount: 4 },

edit: { enabled: true, maxInputImages: 1 },

},

generateImage: vi.fn(async () => {

throw new Error("not used");

}),

},

{

id: "openai",

aliases: ["openai-codex"],

defaultModel: "gpt-image-2",

models: ["gpt-image-2"],

isConfigured: () => true,

capabilities: {

generate: { maxCount: 4 },

edit: { enabled: true, maxInputImages: 5 },

},

generateImage: vi.fn(async () => {

throw new Error("not used");

}),

},

]);

expect(

resolveImageGenerationModelConfigForTool({

cfg: {

agents: {

defaults: {

model: {

primary: "openai-codex/gpt-5.5",

},

},

},

},

}),

).toEqual({

primary: "openai/gpt-image-2",

fallbacks: ["fal/fal-ai/flux/dev"],

});

});

it("prefers the primary model provider when multiple image providers have auth", () => {

stubImageGenerationProviders();

vi.stubEnv("OPENAI_API_KEY", "openai-test");

agentDir?: string;

providers: CapabilityProvider[];

}): string[] {

const providerDefaults = new Map<string, string>();

const providerDefaults = new Map<string, { ref: string; aliases: string[] }>();

for (const provider of params.providers) {

const providerId = provider.id.trim();

const modelId = provider.defaultModel?.trim();

) {

continue;

}

providerDefaults.set(providerId, `${providerId}/${modelId}`);

const aliases = (provider.aliases ?? []).flatMap((alias) => {

const normalized = normalizeProviderId(alias);

return normalized ? [normalized] : [];

});

providerDefaults.set(providerId, { ref: `${providerId}/${modelId}`, aliases });

}

const primaryProvider = resolveDefaultModelRef(params.cfg).provider;

const normalizedPrimaryProvider = normalizeProviderId(primaryProvider);

const providerIds = [...providerDefaults.keys()].toSorted();

const matchesPrimaryProvider = (providerId: string): boolean => {

const entry = providerDefaults.get(providerId);

return (

normalizeProviderId(providerId) === normalizedPrimaryProvider ||

(entry?.aliases ?? []).includes(normalizedPrimaryProvider)

);

};

const orderedProviders = [

primaryProvider,

...[...providerDefaults.keys()]

.filter((providerId) => providerId !== primaryProvider)

.toSorted(),

...providerIds.filter(matchesPrimaryProvider),

...providerIds.filter((providerId) => !matchesPrimaryProvider(providerId)),

];

const orderedRefs: string[] = [];

const seen = new Set<string>();

for (const providerId of orderedProviders) {

const ref = providerDefaults.get(providerId);

if (!ref || seen.has(ref)) {

const entry = providerDefaults.get(providerId);

if (!entry || seen.has(entry.ref)) {

continue;

}

seen.add(ref);

orderedRefs.push(ref);

seen.add(entry.ref);

orderedRefs.push(entry.ref);

}

return orderedRefs;

}

import * as webMedia from "../../media/web-media.js";

import * as videoGenerationRuntime from "../../video-generation/runtime.js";

import * as videoGenerateBackground from "./video-generate-background.js";

import { createVideoGenerateTool } from "./video-generate-tool.js";

import {

createVideoGenerateTool,

resolveVideoGenerationModelConfigForTool,

} from "./video-generate-tool.js";

const taskRuntimeInternalMocks = vi.hoisted(() => ({

listTasksForOwnerKey: vi.fn(),

).not.toBeNull();

});

it("orders auto-detected provider defaults by canonical aliases", () => {

vi.spyOn(videoGenerationRuntime, "listRuntimeVideoGenerationProviders").mockReturnValue([

{

id: "fal",

defaultModel: "fal-ai/minimax/video-01-live",

models: ["fal-ai/minimax/video-01-live"],

capabilities: {},

isConfigured: () => true,

generateVideo: vi.fn(async () => ({ videos: [] })),

},

{

id: "openai",

aliases: ["openai-codex"],

defaultModel: "sora-2",

models: ["sora-2"],

capabilities: {},

isConfigured: () => true,

generateVideo: vi.fn(async () => ({ videos: [] })),

},

]);

expect(

resolveVideoGenerationModelConfigForTool({

cfg: asConfig({

agents: {

defaults: {

model: {

primary: "openai-codex/gpt-5.5",

},

},

},

}),

}),

).toEqual({

primary: "openai/sora-2",

fallbacks: ["fal/fal-ai/minimax/video-01-live"],

});

});

it("generates videos, saves them, and emits MEDIA paths without a session-backed detach", async () => {

taskExecutorMocks.createRunningTaskRun.mockReturnValue({

taskId: "task-123",

]);

});

it("orders auto-detected provider defaults by canonical aliases", () => {

const candidates = resolveCapabilityModelCandidates({

cfg: {

agents: {

defaults: {

model: {

primary: "openai-codex/gpt-5.5",

},

},

},

} as OpenClawConfig,

modelConfig: undefined,

parseModelRef,

listProviders: () => [

{

id: "fal",

defaultModel: "fal-ai/flux/dev",

isConfigured: () => true,

},

{

id: "openai",

aliases: ["openai-codex"],

defaultModel: "gpt-image-2",

isConfigured: () => true,

},

],

});

expect(candidates).toEqual([

{ provider: "openai", model: "gpt-image-2" },

{ provider: "fal", model: "fal-ai/flux/dev" },

]);

});

it("disables implicit provider expansion when mediaGenerationAutoProviderFallback=false", () => {

const candidates = resolveCapabilityModelCandidates({

cfg: {

type CapabilityProviderCandidate = {

id: string;

aliases?: readonly string[];

defaultModel?: string | null;

isConfigured?: (ctx: { cfg?: OpenClawConfig; agentDir?: string }) => boolean;

};

agentDir?: string;

listProviders: (cfg?: OpenClawConfig) => CapabilityProviderCandidate[];

}): string[] {

const providerDefaults = new Map<string, string>();

const providerDefaults = new Map<string, { ref: string; aliases: string[] }>();

for (const provider of params.listProviders(params.cfg)) {

const providerId = normalizeOptionalString(provider.id);

const modelId = normalizeOptionalString(provider.defaultModel);

) {

continue;

}

providerDefaults.set(providerId, `${providerId}/${modelId}`);

const aliases = (provider.aliases ?? []).flatMap((alias) => {

const normalized = normalizeOptionalString(alias);

return normalized ? [normalized] : [];

});

providerDefaults.set(providerId, { ref: `${providerId}/${modelId}`, aliases });

}

const defaultProvider = resolveCurrentDefaultProviderId(params.cfg);

const providerIds = [...providerDefaults.keys()].toSorted();

const matchesDefaultProvider = (providerId: string): boolean => {

const entry = providerDefaults.get(providerId);

return providerId === defaultProvider || (entry?.aliases ?? []).includes(defaultProvider);

};

const orderedProviders = [

defaultProvider,

...[...providerDefaults.keys()]

.filter((providerId) => providerId !== defaultProvider)

.toSorted(),

...providerIds.filter(matchesDefaultProvider),

...providerIds.filter((providerId) => !matchesDefaultProvider(providerId)),

];

return orderedProviders.flatMap((providerId) => {

const ref = providerDefaults.get(providerId);

return ref ? [ref] : [];

const entry = providerDefaults.get(providerId);

return entry ? [entry.ref] : [];

});

}