fix(media-understanding): video auto-selection runs without a model (#99791)

zhangguiping-xydt · vincentkoc · web-flow · commit 565097fc1001 · 2026-07-06T12:42:01.000-07:00
* fix: require video media provider models

* fix video media test typing and skip coverage

* fix(media-understanding): preserve self-defaulting video providers

---------

Co-authored-by: Vincent Koc &lt;vincentkoc@ieee.org&gt;
diff --git a/src/media-understanding/runner.ts b/src/media-understanding/runner.ts
@@ -632,7 +632,14 @@ async function resolveKeyEntry(params: {
             explicitModel: model,
             workspaceDir,
           })
-        : model;
+        : capability === "video"
+          ? (model ??
+            resolveDefaultMediaModelFromRegistry({
+              providerId,
+              capability: "video",
+              providerRegistry,
+            }))
+          : model;
     if (capability === "image" && !resolvedModel) {
       return null;
     }
@@ -907,7 +914,13 @@ async function resolveActiveModelEntry(params: {
       providerRegistry: params.providerRegistry,
     });
   } else {
-    model = params.activeModel?.model;
+    model =
+      params.activeModel?.model ??
+      resolveDefaultMediaModelFromRegistry({
+        providerId,
+        capability: "video",
+        providerRegistry: params.providerRegistry,
+      });
   }
   if ((params.capability === "image" || params.capability === "audio") && !model) {
     return null;
diff --git a/src/media-understanding/runner.video.test.ts b/src/media-understanding/runner.video.test.ts
@@ -6,6 +6,7 @@ import { withTempDir } from "../test-helpers/temp-dir.js";
 import { withEnvAsync } from "../test-utils/env.js";
 import { runCapability } from "./runner.js";
 import { withVideoFixture } from "./runner.test-utils.js";
+import type { MediaUnderstandingProvider } from "./types.js";
 
 vi.mock("../media/channel-inbound-roots.js", () => ({
   resolveChannelInboundAttachmentRoots: () => undefined,
@@ -84,7 +85,7 @@ describe("runCapability video provider wiring", () => {
           agentDir: isolatedAgentDir,
           attachments: cache,
           media,
-          providerRegistry: new Map([
+          providerRegistry: new Map<string, MediaUnderstandingProvider>([
             [
               "moonshot",
               {
@@ -150,7 +151,7 @@ describe("runCapability video provider wiring", () => {
               agentDir: isolatedAgentDir,
               attachments: cache,
               media,
-              providerRegistry: new Map([
+              providerRegistry: new Map<string, MediaUnderstandingProvider>([
                 [
                   "google",
                   {
@@ -164,7 +165,8 @@ describe("runCapability video provider wiring", () => {
                   {
                     id: "moonshot",
                     capabilities: ["video"],
-                    describeVideo: async () => ({ text: "moonshot", model: "kimi-k2.5" }),
+                    defaultModels: { video: "kimi-k2.5" },
+                    describeVideo: async (req) => ({ text: "moonshot", model: req.model }),
                   },
                 ],
               ]),
@@ -180,6 +182,122 @@ describe("runCapability video provider wiring", () => {
     });
   });
 
+  it("uses the provider video default when the active provider has no model", async () => {
+    let seenModel: string | undefined;
+
+    await withTempDir({ prefix: "openclaw-video-active-provider-" }, async (isolatedAgentDir) => {
+      await withVideoFixture("openclaw-video-active-default", async ({ ctx, media, cache }) => {
+        const cfg = {
+          models: {
+            providers: {
+              moonshot: {
+                auth: "api-key",
+                apiKey: "moonshot-key", // pragma: allowlist secret
+                models: [],
+              },
+            },
+          },
+          tools: {
+            media: {
+              video: {
+                enabled: true,
+              },
+            },
+          },
+        } as unknown as OpenClawConfig;
+
+        const result = await runCapability({
+          capability: "video",
+          cfg,
+          ctx,
+          agentDir: isolatedAgentDir,
+          attachments: cache,
+          media,
+          providerRegistry: new Map<string, MediaUnderstandingProvider>([
+            [
+              "moonshot",
+              {
+                id: "moonshot",
+                capabilities: ["video"],
+                defaultModels: { video: "kimi-k2.5" },
+                describeVideo: async (req) => {
+                  seenModel = req.model;
+                  return { text: "moonshot", model: req.model };
+                },
+              },
+            ],
+          ]),
+          activeModel: { provider: "moonshot" },
+        });
+
+        expect(result.decision.outcome).toBe("success");
+        const output = requireCapabilityOutput(result, 0);
+        expect(output.provider).toBe("moonshot");
+        expect(output.model).toBe("kimi-k2.5");
+        expect(seenModel).toBe("kimi-k2.5");
+      });
+    });
+  });
+
+  it("preserves self-defaulting video providers without registry model metadata", async () => {
+    let seenModel: string | undefined;
+
+    await withTempDir(
+      { prefix: "openclaw-video-no-default-provider-" },
+      async (isolatedAgentDir) => {
+        await withVideoFixture("openclaw-video-no-default", async ({ ctx, media, cache }) => {
+          const cfg = {
+            models: {
+              providers: {
+                moonshot: {
+                  auth: "api-key",
+                  apiKey: "moonshot-key", // pragma: allowlist secret
+                  models: [],
+                },
+              },
+            },
+            tools: {
+              media: {
+                video: {
+                  enabled: true,
+                },
+              },
+            },
+          } as unknown as OpenClawConfig;
+
+          const result = await runCapability({
+            capability: "video",
+            cfg,
+            ctx,
+            agentDir: isolatedAgentDir,
+            attachments: cache,
+            media,
+            providerRegistry: new Map<string, MediaUnderstandingProvider>([
+              [
+                "moonshot",
+                {
+                  id: "moonshot",
+                  capabilities: ["video"],
+                  describeVideo: async (req) => {
+                    seenModel = req.model;
+                    return { text: "moonshot", model: "provider-default" };
+                  },
+                },
+              ],
+            ]),
+            activeModel: { provider: "moonshot" },
+          });
+
+          expect(result.decision.outcome).toBe("success");
+          const output = requireCapabilityOutput(result, 0);
+          expect(output.provider).toBe("moonshot");
+          expect(output.model).toBe("provider-default");
+          expect(seenModel).toBeUndefined();
+        });
+      },
+    );
+  });
+
   it("does not use provider api config as video auth modelApi", async () => {
     const modelAuth = await import("../agents/model-auth.js");
     const resolveApiKeyForProvider = vi.mocked(modelAuth.resolveApiKeyForProvider);
@@ -214,7 +332,7 @@ describe("runCapability video provider wiring", () => {
           agentDir: isolatedAgentDir,
           attachments: cache,
           media,
-          providerRegistry: new Map([
+          providerRegistry: new Map<string, MediaUnderstandingProvider>([
             [
               "openai",
               {
