fix(models): refresh Moonshot Kimi vision capabilities

Co-authored-by: manikv12 <mac1317@live.missouristate.edu>

src/agents/models-config.fills-missing-provider-apikey-from-env-var.test.ts

@@ -133,4 +133,68 @@ describe("models-config", () => {
       expect(parsed.providers["custom-proxy"]?.baseUrl).toBe("http://localhost:4000/v1");
     });
   });
+
+  it("refreshes stale explicit moonshot model capabilities from implicit catalog", async () => {
+    await withTempHome(async () => {
+      const prevKey = process.env.MOONSHOT_API_KEY;
+      process.env.MOONSHOT_API_KEY = "sk-moonshot-test";
+      try {
+        const cfg: OpenClawConfig = {
+          models: {
+            providers: {
+              moonshot: {
+                baseUrl: "https://api.moonshot.ai/v1",
+                api: "openai-completions",
+                models: [
+                  {
+                    id: "kimi-k2.5",
+                    name: "Kimi K2.5",
+                    reasoning: false,
+                    input: ["text"],
+                    cost: { input: 123, output: 456, cacheRead: 0, cacheWrite: 0 },
+                    contextWindow: 1024,
+                    maxTokens: 256,
+                  },
+                ],
+              },
+            },
+          },
+        };
+
+        await ensureOpenClawModelsJson(cfg);
+
+        const modelPath = path.join(resolveOpenClawAgentDir(), "models.json");
+        const raw = await fs.readFile(modelPath, "utf8");
+        const parsed = JSON.parse(raw) as {
+          providers: Record<
+            string,
+            {
+              models?: Array<{
+                id: string;
+                input?: string[];
+                reasoning?: boolean;
+                contextWindow?: number;
+                maxTokens?: number;
+                cost?: { input?: number; output?: number };
+              }>;
+            }
+          >;
+        };
+        const kimi = parsed.providers.moonshot?.models?.find((model) => model.id === "kimi-k2.5");
+        expect(kimi?.input).toEqual(["text", "image"]);
+        expect(kimi?.reasoning).toBe(false);
+        expect(kimi?.contextWindow).toBe(256000);
+        expect(kimi?.maxTokens).toBe(8192);
+        // Preserve explicit user pricing overrides when refreshing capabilities.
+        expect(kimi?.cost?.input).toBe(123);
+        expect(kimi?.cost?.output).toBe(456);
+      } finally {
+        if (prevKey === undefined) {
+          delete process.env.MOONSHOT_API_KEY;
+        } else {
+          process.env.MOONSHOT_API_KEY = prevKey;
+        }
+      }
+    });
+  });
 });

src/agents/models-config.providers.ts

@@ -513,7 +513,7 @@ function buildMoonshotProvider(): ProviderConfig {
         id: MOONSHOT_DEFAULT_MODEL_ID,
         name: "Kimi K2.5",
         reasoning: false,
-        input: ["text"],
+        input: ["text", "image"],
         cost: MOONSHOT_DEFAULT_COST,
         contextWindow: MOONSHOT_DEFAULT_CONTEXT_WINDOW,
         maxTokens: MOONSHOT_DEFAULT_MAX_TOKENS,

src/agents/models-config.ts

@@ -29,22 +29,41 @@ function mergeProviderModels(implicit: ProviderConfig, explicit: ProviderConfig)
     const id = (model as { id?: unknown }).id;
     return typeof id === "string" ? id.trim() : "";
   };
-  const seen = new Set(explicitModels.map(getId).filter(Boolean));
+  const implicitById = new Map(
+    implicitModels.map((model) => [getId(model), model] as const).filter(([id]) => Boolean(id)),
+  );
+  const seen = new Set<string>();
 
-  const mergedModels = [
-    ...explicitModels,
-    ...implicitModels.filter((model) => {
-      const id = getId(model);
-      if (!id) {
-        return false;
-      }
-      if (seen.has(id)) {
-        return false;
-      }
-      seen.add(id);
-      return true;
-    }),
-  ];
+  const mergedModels = explicitModels.map((explicitModel) => {
+    const id = getId(explicitModel);
+    if (!id) {
+      return explicitModel;
+    }
+    seen.add(id);
+    const implicitModel = implicitById.get(id);
+    if (!implicitModel) {
+      return explicitModel;
+    }
+
+    // Refresh capability metadata from the implicit catalog while preserving
+    // user-specific fields (cost, headers, compat, etc.) on explicit entries.
+    return {
+      ...explicitModel,
+      input: implicitModel.input,
+      reasoning: implicitModel.reasoning,
+      contextWindow: implicitModel.contextWindow,
+      maxTokens: implicitModel.maxTokens,
+    };
+  });
+
+  for (const implicitModel of implicitModels) {
+    const id = getId(implicitModel);
+    if (!id || seen.has(id)) {
+      continue;
+    }
+    seen.add(id);
+    mergedModels.push(implicitModel);
+  }
 
   return {
     ...implicit,

src/agents/synthetic-models.ts

@@ -103,7 +103,7 @@ export const SYNTHETIC_MODEL_CATALOG = [
     id: "hf:moonshotai/Kimi-K2.5",
     name: "Kimi K2.5",
     reasoning: true,
-    input: ["text"],
+    input: ["text", "image"],
     contextWindow: 256000,
     maxTokens: 8192,
   },