fix(models): cap downgrade picks a vision-capable target for image turns

pickHardCapTarget chose the cheapest hard-cap target regardless of vision
support, so an image-bearing turn that hit the per-user budget cap could be
routed to a text-only model (Foundry DeepSeek) and fail the request.

Gate the candidate set to vision-capable models when the turn carries an
image, so an image turn downgrades to the cheapest model that can actually
see it (Kimi before gpt-5.4-mini); text turns are unchanged. Falls back to
no-downgrade if no vision-capable target is deployed.

Note: gates on images attached to the CURRENT turn; images present only in
earlier turns of a capped follow-up are not yet covered.

Adds unit tests: text turn -> cheapest target; image turn -> cheapest
vision target, never the text-only one.

Author: saoc90

src/features/chat-page/chat-services/chat-api/__tests__/model-selection.test.ts

@@ -228,3 +228,49 @@ describe("resolveModelAndLimits — intent-based downgrade", () => {
     expect(result.selectedModel).toBe("gpt-5.4-mini");
   });
 });
+
+describe("resolveModelAndLimits — cap downgrade respects vision capability", () => {
+  // Cheapest hard-cap target first (DeepSeek, text-only) then a vision-capable
+  // one (Kimi). A text turn should take the cheapest; an image turn must skip
+  // the text-only model and take the cheapest VISION-capable target instead —
+  // otherwise the image turn would be routed to a model that can't see it.
+  const VISIONLESS = "DeepSeek-V4-Pro" as const;
+  const VISION_CHEAP = "Kimi-K2.6" as const;
+  let savedVisionless: string | undefined;
+  let savedVision: string | undefined;
+
+  beforeEach(() => {
+    savedVisionless = (MODEL_CONFIGS[VISIONLESS] as any).deploymentName;
+    savedVision = (MODEL_CONFIGS[VISION_CHEAP] as any).deploymentName;
+    (MODEL_CONFIGS[VISIONLESS] as any).deploymentName = "deepseek-test";
+    (MODEL_CONFIGS[VISION_CHEAP] as any).deploymentName = "kimi-test";
+    // Sanity: the fix relies on these real capability flags.
+    expect(MODEL_CONFIGS[VISIONLESS].capabilities ?? []).not.toContain("vision");
+    expect(MODEL_CONFIGS[VISION_CHEAP].capabilities ?? []).toContain("vision");
+    mockCheckUserBudget.mockResolvedValue({ exceeded: true, window: "weekly", currentUsd: 9, limitUsd: 7 });
+    mockGetDowngradeTargets.mockReturnValue({
+      hardCapSet: [VISIONLESS, VISION_CHEAP],
+      intentByClass: {},
+    });
+  });
+  afterEach(() => {
+    (MODEL_CONFIGS[VISIONLESS] as any).deploymentName = savedVisionless;
+    (MODEL_CONFIGS[VISION_CHEAP] as any).deploymentName = savedVision;
+  });
+
+  it("routes a TEXT-only capped turn to the cheapest target (text-only allowed)", async () => {
+    const thread = makeThread({ selectedModel: "gpt-5.5" });
+    const result = await resolveModelAndLimits({ selectedModel: "gpt-5.5" }, thread);
+    expect(result.selectedModel).toBe(VISIONLESS);
+  });
+
+  it("routes an IMAGE-bearing capped turn to the cheapest VISION target, NOT the text-only one", async () => {
+    const thread = makeThread({ selectedModel: "gpt-5.5" });
+    const result = await resolveModelAndLimits(
+      { selectedModel: "gpt-5.5", multimodalImages: ["data:image/png;base64,AAAA"] },
+      thread,
+    );
+    expect(result.selectedModel).toBe(VISION_CHEAP);
+    expect(result.selectedModel).not.toBe(VISIONLESS);
+  });
+});

src/features/chat-page/chat-services/chat-api/model-selection.ts

@@ -77,16 +77,28 @@ export interface ModelSelectionResult {
  * tools we prefer an eligible model that can host them (else the cheapest).
  * Returns undefined when no eligible+deployed target exists (caller fails safe).
  */
-function pickHardCapTarget(opts: { preferResponsesAPI: boolean }): ChatModel | undefined {
+function pickHardCapTarget(opts: {
+  preferResponsesAPI: boolean;
+  requireVision: boolean;
+}): ChatModel | undefined {
   const { hardCapSet } = getDowngradeTargets();
-  if (hardCapSet.length === 0) return undefined;
+  // When the turn carries an image, only vision-capable targets are eligible.
+  // The cheapest hard-cap target (Foundry DeepSeek) is text-only, so routing an
+  // image turn there fails the request. Gating to vision-capable models means
+  // an image turn downgrades to the cheapest model that can actually see it
+  // (e.g. Kimi before gpt-5.4-mini). If none qualify we return undefined and
+  // the caller fails safe (no downgrade) rather than break the turn.
+  const candidates = opts.requireVision
+    ? hardCapSet.filter((id) => MODEL_CONFIGS[id].capabilities?.includes("vision"))
+    : hardCapSet;
+  if (candidates.length === 0) return undefined;
   if (opts.preferResponsesAPI) {
-    const responsesCapable = hardCapSet.find(
+    const responsesCapable = candidates.find(
       (id) => MODEL_CONFIGS[id].supportsResponsesAPI,
     );
     if (responsesCapable) return responsesCapable;
   }
-  return hardCapSet[0];
+  return candidates[0];
 }
 
 export async function resolveModelAndLimits(
@@ -96,6 +108,9 @@ export async function resolveModelAndLimits(
     webSearchEnabled?: boolean;
     imageGenerationEnabled?: boolean;
     codeInterpreterEnabled?: boolean;
+    /** Images attached to THIS turn — gates the cap downgrade to vision-capable
+     *  targets so an image turn never lands on a text-only model. */
+    multimodalImages?: string[];
   },
   thread: ChatThreadModel
 ): Promise<ModelSelectionResult> {
@@ -125,7 +140,8 @@ export async function resolveModelAndLimits(
         (payload.imageGenerationEnabled ?? thread.defaultTools?.imageGeneration) ||
         (payload.webSearchEnabled ?? thread.defaultTools?.webSearch)
       );
-      const target = pickHardCapTarget({ preferResponsesAPI: wantsBuiltInTools });
+      const requireVision = (payload.multimodalImages?.length ?? 0) > 0;
+      const target = pickHardCapTarget({ preferResponsesAPI: wantsBuiltInTools, requireVision });
       const targetConfig = target ? MODEL_CONFIGS[target] : undefined;
       if (target && targetConfig?.deploymentName && target !== selectedModel) {
         fallbackInfo = {