@stigmer/react 3.12.1 → 3.12.2

package/src/models/ModelSelector.tsx

@@ -629,6 +629,17 @@ function ModelRow({
       <div className="stg:flex stg:w-full stg:items-center stg:gap-2">
         <span className="stg:flex-1 stg:truncate stg:text-left stg:font-medium">{model.displayName}</span>
 
+        {/* Explicit vision:false only (stigmer/stigmer#386) — an unassessed
+            model (absent capabilities block) shows nothing, per the
+            registry's tri-state convention. Visible text, not a tooltip:
+            keyboard and touch users must see it before picking the model. */}
+        {model.visionCapability === false && (
+          <span className="stg:flex stg:shrink-0 stg:items-center stg:gap-0.5 stg:text-[0.6rem] stg:text-muted-foreground">
+            <NoImageInputIcon />
+            No image input
+          </span>
+        )}
+
         <span className="stg:shrink-0 stg:text-[0.6rem] stg:text-muted-foreground">
           {showSpeedBadge
             ? `${SPEED_TIER_LABEL[model.speedTier]} ${COST_TIER_LABEL[model.costTier]}`
@@ -683,6 +694,32 @@ function CheckIcon({ className }: { className?: string }) {
   );
 }
 
+/**
+ * "Image with a slash" glyph for models explicitly assessed as unable to
+ * see images. Decorative (`aria-hidden`) — the wrapping span carries the
+ * accessible text.
+ */
+function NoImageInputIcon() {
+  return (
+    <svg
+      width="11"
+      height="11"
+      viewBox="0 0 12 12"
+      fill="none"
+      stroke="currentColor"
+      strokeWidth="1.2"
+      strokeLinecap="round"
+      strokeLinejoin="round"
+      aria-hidden
+    >
+      <rect x="1.5" y="2" width="9" height="8" rx="1.2" />
+      <path d="M1.5 8L4.2 5.6L6.4 7.6" />
+      <circle cx="7.6" cy="4.6" r="0.8" fill="currentColor" stroke="none" />
+      <path d="M1 1L11 11" />
+    </svg>
+  );
+}
+
 function BoltIcon() {
   return (
     <svg

package/src/models/__tests__/ModelSelector-visionIndicator.test.tsx

@@ -0,0 +1,129 @@
+import { describe, it, expect, vi, afterEach, beforeAll } from "vitest";
+import { render, screen, cleanup, fireEvent } from "@testing-library/react";
+import { ModelSelector } from "../ModelSelector";
+import { ModelRegistryContext } from "../ModelRegistryContext";
+import type { ModelInfo } from "../registry";
+
+// Shim ResizeObserver for Base UI's positioner (the
+// scheduleCreation.test.tsx pattern).
+beforeAll(() => {
+  if (!("ResizeObserver" in globalThis)) {
+    (globalThis as unknown as { ResizeObserver: unknown }).ResizeObserver =
+      class {
+        observe() {}
+        unobserve() {}
+        disconnect() {}
+      };
+  }
+});
+
+/**
+ * "No image input" indicator on model rows (stigmer/stigmer#386).
+ *
+ * Tri-state contract: the indicator renders ONLY for models the registry
+ * explicitly assessed as blind (`visionCapability === false`). A sighted
+ * model shows nothing, and — the load-bearing case — an UNASSESSED model
+ * (absent capabilities block) also shows nothing: most registry entries
+ * were never capability-assessed, and flagging them all as blind would
+ * be wrong for nearly every one.
+ */
+
+const BLIND: ModelInfo = {
+  modelId: "kimi-k3",
+  provider: "moonshot",
+  displayName: "Kimi K3",
+  shortDescription: "Text-only economy model",
+  speedTier: "fast",
+  costTier: "economy",
+  harness: "cursor",
+  featured: true,
+  serviceTiers: [],
+  visionCapability: false,
+};
+
+const SIGHTED: ModelInfo = {
+  modelId: "composer-2.5",
+  provider: "cursor",
+  displayName: "Composer 2.5",
+  shortDescription: "Fast agentic model",
+  speedTier: "fastest",
+  costTier: "economy",
+  harness: "cursor",
+  featured: true,
+  serviceTiers: [],
+  visionCapability: true,
+};
+
+const UNASSESSED: ModelInfo = {
+  modelId: "mystery-model",
+  provider: "cursor",
+  displayName: "Mystery Model",
+  shortDescription: "Never capability-assessed",
+  speedTier: "fast",
+  costTier: "standard",
+  harness: "cursor",
+  featured: true,
+  serviceTiers: [],
+};
+
+function renderSelector() {
+  return render(
+    <ModelRegistryContext.Provider
+      value={{
+        models: [BLIND, SIGHTED, UNASSESSED],
+        isLoading: false,
+        error: null,
+        refetch: vi.fn(),
+      }}
+    >
+      <ModelSelector
+        value="composer-2.5"
+        onValueChange={vi.fn()}
+        harness="cursor"
+      />
+    </ModelRegistryContext.Provider>,
+  );
+}
+
+async function openPopover(triggerLabel: string) {
+  fireEvent.click(screen.getByRole("button", { name: new RegExp(triggerLabel) }));
+  await screen.findByPlaceholderText("Search models…");
+}
+
+/** A model row inside the popup list (never matches the trigger). */
+function modelOption(displayName: string): HTMLElement {
+  const option = screen
+    .getAllByText(displayName)
+    .map((el) => el.closest<HTMLElement>("[data-model-option]"))
+    .find((el) => el != null);
+  if (!option) throw new Error(`No popup option for "${displayName}"`);
+  return option;
+}
+
+afterEach(cleanup);
+
+describe("ModelSelector — no-image-input indicator", () => {
+  it("marks an explicitly blind model with visible badge text", async () => {
+    renderSelector();
+    await openPopover("Composer 2.5");
+
+    // Visible text, not a tooltip — keyboard and touch users must see it
+    // before picking the model (stigmer/no-native-title).
+    const row = modelOption("Kimi K3");
+    expect(row.textContent).toContain("No image input");
+  });
+
+  it("shows nothing on an explicitly sighted model", async () => {
+    renderSelector();
+    await openPopover("Composer 2.5");
+
+    expect(modelOption("Composer 2.5").textContent).not.toContain("No image input");
+  });
+
+  it("shows nothing on an unassessed model (tri-state: absent is not false)", async () => {
+    renderSelector();
+    await openPopover("Composer 2.5");
+
+    expect(modelOption("Mystery Model").textContent).not.toContain("No image input");
+  });
+});

package/src/models/__tests__/resolveDefaultModel.test.ts

@@ -0,0 +1,115 @@
+import { describe, it, expect } from "vitest";
+import {
+  DEFAULT_CURSOR_MODEL_ID,
+  DEFAULT_MODEL_ID,
+  resolveDefaultModelId,
+  type ModelInfo,
+} from "../registry";
+
+/**
+ * The harness-default arm is a contract, not a suggestion
+ * (stigmer/stigmer#663): this resolution feeds the composer's pill, and
+ * the submission adopts what the pill displays — so the default must be
+ * what the platform actually runs for an unpinned execution:
+ *
+ * - cursor → the registry's Auto entry (the runner coerces an empty
+ *   model_name to "default")
+ * - native → the runner's getDefaultModel() rule (featured + standard
+ *   cost, then any standard cost)
+ */
+
+function model(overrides: Partial<ModelInfo> & { modelId: string }): ModelInfo {
+  return {
+    provider: "anthropic",
+    displayName: overrides.modelId,
+    shortDescription: "",
+    speedTier: "fast",
+    costTier: "standard",
+    harness: "native",
+    featured: false,
+    serviceTiers: [],
+    ...overrides,
+  };
+}
+
+describe("resolveDefaultModelId — cursor harness", () => {
+  it("prefers the Auto entry over featured models listed before it (the production order that caused #663)", () => {
+    // Mirrors the live registry: featured premium models precede Auto.
+    const models = [
+      model({ modelId: "claude-opus-4-8", harness: "cursor", featured: true, costTier: "premium" }),
+      model({ modelId: DEFAULT_CURSOR_MODEL_ID, harness: "cursor", featured: true }),
+    ];
+    expect(resolveDefaultModelId("cursor", models)).toEqual({
+      modelId: DEFAULT_CURSOR_MODEL_ID,
+      source: "harness_default",
+    });
+  });
+
+  it("falls back to the first featured cursor model when the registry has no Auto entry", () => {
+    const models = [
+      model({ modelId: "composer-2.5", harness: "cursor", featured: true }),
+    ];
+    expect(resolveDefaultModelId("cursor", models).modelId).toBe("composer-2.5");
+  });
+
+  it("falls back to the hardcoded cursor id on an empty registry", () => {
+    expect(resolveDefaultModelId("cursor", [])).toEqual({
+      modelId: DEFAULT_CURSOR_MODEL_ID,
+      source: "platform_fallback",
+    });
+  });
+
+  it("lets an explicit user preference win over Auto", () => {
+    const models = [
+      model({ modelId: DEFAULT_CURSOR_MODEL_ID, harness: "cursor", featured: true }),
+      model({ modelId: "composer-2.5", harness: "cursor", featured: true }),
+    ];
+    expect(
+      resolveDefaultModelId("cursor", models, { userPreference: "composer-2.5" }),
+    ).toEqual({ modelId: "composer-2.5", source: "user_preference" });
+  });
+});
+
+describe("resolveDefaultModelId — native harness", () => {
+  it("skips a featured premium model for the featured standard-cost one (the runner's own rule)", () => {
+    const models = [
+      model({ modelId: "claude-opus-4.6", featured: true, costTier: "premium" }),
+      model({ modelId: "claude-sonnet-4.6", featured: true, costTier: "standard" }),
+    ];
+    expect(resolveDefaultModelId("native", models)).toEqual({
+      modelId: "claude-sonnet-4.6",
+      source: "harness_default",
+    });
+  });
+
+  it("falls back to any standard-cost model when no featured one is standard", () => {
+    const models = [
+      model({ modelId: "claude-opus-4.6", featured: true, costTier: "premium" }),
+      model({ modelId: "gpt-4o", featured: false, costTier: "standard" }),
+    ];
+    expect(resolveDefaultModelId("native", models).modelId).toBe("gpt-4o");
+  });
+
+  it("falls back to the first featured model when the registry lists no standard-cost model at all", () => {
+    const models = [
+      model({ modelId: "claude-opus-4.6", featured: true, costTier: "premium" }),
+      model({ modelId: "ollama-local", featured: false, costTier: "economy" }),
+    ];
+    expect(resolveDefaultModelId("native", models).modelId).toBe("claude-opus-4.6");
+  });
+
+  it("falls back to the hardcoded native id on an empty registry", () => {
+    expect(resolveDefaultModelId("native", [])).toEqual({
+      modelId: DEFAULT_MODEL_ID,
+      source: "platform_fallback",
+    });
+  });
+
+  it("never resolves across harnesses (a cursor Auto entry is invisible to native)", () => {
+    const models = [
+      model({ modelId: DEFAULT_CURSOR_MODEL_ID, harness: "cursor", featured: true }),
+      model({ modelId: "claude-sonnet-4.6", featured: true, costTier: "standard" }),
+    ];
+    expect(resolveDefaultModelId("native", models).modelId).toBe("claude-sonnet-4.6");
+  });
+});

package/src/models/__tests__/useModelRegistry.test.tsx

@@ -7,6 +7,7 @@ import {
   DEFAULT_CURSOR_MODEL_ID,
   DISABLED_PROVIDERS,
   modelKey,
+  parseRegistryDocument,
   parseRegistryJson,
 } from "../registry";
 import { ModelRegistryContext } from "../ModelRegistryContext";
@@ -106,6 +107,101 @@ function createWrapper(models: readonly ModelInfo[] = TEST_MODELS) {
   };
 }
 
+describe("parseRegistryDocument vision data (#365, #386)", () => {
+  const entry = (overrides: Record<string, unknown>) => ({
+    id: "m",
+    displayName: "M",
+    provider: "anthropic",
+    harness: "native",
+    costTier: "standard",
+    pricing: { inputPricePerMillion: 1, outputPricePerMillion: 2, cacheWritePricePerMillion: 0, cacheReadPricePerMillion: 0 },
+    ...overrides,
+  });
+
+  it("parses explicit vision:false into visionCapability", () => {
+    const doc = parseRegistryDocument({
+      models: [entry({ capabilities: { toolUse: true, vision: false, streaming: true, thinking: false, adaptiveThinking: false } })],
+    });
+    expect(doc.models[0].visionCapability).toBe(false);
+  });
+
+  it("parses explicit vision:true into visionCapability", () => {
+    const doc = parseRegistryDocument({
+      models: [entry({ capabilities: { toolUse: true, vision: true, streaming: true, thinking: true, adaptiveThinking: false } })],
+    });
+    expect(doc.models[0].visionCapability).toBe(true);
+  });
+
+  it("keeps an unassessed model free of the visionCapability key (tri-state, never coerced to false)", () => {
+    const doc = parseRegistryDocument({ models: [entry({})] });
+    expect(doc.models[0].visionCapability).toBeUndefined();
+    expect("visionCapability" in doc.models[0]).toBe(false);
+  });
+
+  it("treats a malformed capabilities block as unassessed", () => {
+    const doc = parseRegistryDocument({
+      models: [entry({ capabilities: "broken" }), entry({ id: "m2", capabilities: { vision: "yes" } })],
+    });
+    expect(doc.models[0].visionCapability).toBeUndefined();
+    expect(doc.models[1].visionCapability).toBeUndefined();
+  });
+
+  it("parses the document-level limits.vision block", () => {
+    const doc = parseRegistryDocument({
+      limits: { vision: { maxImageBytes: 3145728, maxTotalBytes: 4194304, maxImages: 10 } },
+      models: [entry({})],
+    });
+    expect(doc.visionLimits).toEqual({
+      maxImageBytes: 3145728,
+      maxTotalBytes: 4194304,
+      maxImages: 10,
+    });
+  });
+
+  it("leaves visionLimits undefined for documents predating the limits block", () => {
+    const doc = parseRegistryDocument({ models: [entry({})] });
+    expect(doc.visionLimits).toBeUndefined();
+  });
+
+  it.each([
+    ["missing field", { vision: { maxImageBytes: 1, maxTotalBytes: 2 } }],
+    ["non-numeric field", { vision: { maxImageBytes: "3MB", maxTotalBytes: 2, maxImages: 1 } }],
+    ["zero cap", { vision: { maxImageBytes: 0, maxTotalBytes: 2, maxImages: 1 } }],
+    ["negative cap", { vision: { maxImageBytes: 1, maxTotalBytes: -2, maxImages: 1 } }],
+    ["vision not an object", { vision: 42 }],
+  ])("rejects a garbled limits block (%s) rather than half-parsing it", (_name, limits) => {
+    const doc = parseRegistryDocument({ limits, models: [entry({})] });
+    expect(doc.visionLimits).toBeUndefined();
+  });
+
+  it("keeps parseRegistryJson byte-compatible (models only, same rows)", () => {
+    const raw = {
+      limits: { vision: { maxImageBytes: 1, maxTotalBytes: 2, maxImages: 3 } },
+      models: [entry({})],
+    };
+    expect(parseRegistryJson(raw)).toEqual([...parseRegistryDocument(raw).models]);
+  });
+});
+
+describe("useModelRegistry visionLimits pass-through (#365)", () => {
+  it("exposes visionLimits from context", () => {
+    const limits = { maxImageBytes: 3145728, maxTotalBytes: 4194304, maxImages: 10 };
+    const state: ModelRegistryState = {
+      models: TEST_MODELS, visionLimits: limits, isLoading: false, error: null, refetch: noopRefetch,
+    };
+    const wrapper = ({ children }: { children: ReactNode }) => (
+      <ModelRegistryContext.Provider value={state}>{children}</ModelRegistryContext.Provider>
+    );
+    const { result } = renderHook(() => useModelRegistry(), { wrapper });
+    expect(result.current.visionLimits).toEqual(limits);
+  });
+
+  it("stays undefined when the context has no limits (older server)", () => {
+    const { result } = renderHook(() => useModelRegistry(), { wrapper: createWrapper() });
+    expect(result.current.visionLimits).toBeUndefined();
+  });
+});
+
 describe("parseRegistryJson service tiers (#357)", () => {
   it("surfaces pricingVariants keys as serviceTiers", () => {
     const withVariants = TEST_MODELS.find((m) => m.modelId === "claude-4.6-sonnet");
@@ -246,13 +342,12 @@ describe("useModelRegistry", () => {
       expect(cursorModels).toHaveLength(0);
     });
 
-    it("resolves defaultModel to the first featured native model", () => {
+    it("resolves defaultModel to the featured standard-cost native model (what an unpinned execution runs, #663)", () => {
       const { result } = renderHook(() =>
         useModelRegistry({ harness: "native" }),
       { wrapper: createWrapper() });
-      const featured = result.current.featured;
-      expect(featured.length).toBeGreaterThan(0);
-      expect(result.current.defaultModel!.modelId).toBe(featured[0].modelId);
+      expect(result.current.defaultModel!.modelId).toBe("claude-sonnet-4.6");
+      expect(result.current.defaultModel!.costTier).toBe("standard");
     });
   });
 

package/src/models/index.ts

@@ -1,6 +1,6 @@
-export { DEFAULT_MODEL_ID, DEFAULT_CURSOR_MODEL_ID, DISABLED_PROVIDERS, modelKey, parseModelKey, resolveDefaultModelId, fetchModelRegistry, parseRegistryJson } from "./registry.js";
+export { DEFAULT_MODEL_ID, DEFAULT_CURSOR_MODEL_ID, DISABLED_PROVIDERS, modelKey, parseModelKey, resolveDefaultModelId, fetchModelRegistry, fetchModelRegistryDocument, parseRegistryJson, parseRegistryDocument } from "./registry.js";
 export type { ParsedModelKey, DefaultModelResolution, DefaultModelSource } from "./registry.js";
-export type { ModelInfo, Provider, CostTier, SpeedTier } from "./registry.js";
+export type { ModelInfo, ModelRegistryDocument, Provider, CostTier, SpeedTier, VisionLimits } from "./registry.js";
 export { useModelRegistry } from "./useModelRegistry.js";
 export type { UseModelRegistryReturn, UseModelRegistryOptions } from "./useModelRegistry.js";
 export { ModelRegistryContext, useModelRegistryContext } from "./ModelRegistryContext.js";