@duckmind/dm-windows-x64 0.61.3 → 0.61.5

package/extensions/dm-localllm-provider/detect.test.js

@@ -0,0 +1,1051 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+import {
+  detectLlamaCpp,
+  detectLmStudio,
+  detectModels,
+  detectMtplx,
+  detectOllama,
+  detectOmlx,
+  detectOpenAI,
+  detectSglang,
+  detectVllm,
+  isNinferCards,
+  nearestTier,
+  parseNinferContext,
+  probeNinfer,
+  probeRequestCompat
+} from "./detect.js";
+function mockFetch(routes) {
+  vi.stubGlobal("fetch", vi.fn(async (url) => {
+    const key = String(url);
+    if (!(key in routes)) {
+      return { ok: false, json: async () => ({}) };
+    }
+    return { ok: true, json: async () => routes[key] };
+  }));
+}
+function mockFetchAllStatus(status) {
+  vi.stubGlobal("fetch", vi.fn(async () => ({ ok: false, status, json: async () => ({}) })));
+}
+function mockFetchAllReject(err) {
+  vi.stubGlobal("fetch", vi.fn(async () => {
+    throw err;
+  }));
+}
+function mockOllama(tagsResponse, showResponsesByModel, psResponse = { models: [] }) {
+  vi.stubGlobal("fetch", vi.fn(async (url, init) => {
+    const u = String(url);
+    if (u.endsWith("/api/tags")) {
+      return { ok: true, json: async () => tagsResponse };
+    }
+    if (u.endsWith("/api/ps")) {
+      return { ok: true, json: async () => psResponse };
+    }
+    if (u.endsWith("/api/show")) {
+      const body = init?.body ? JSON.parse(String(init.body)) : {};
+      const resp = showResponsesByModel[body.model];
+      if (!resp)
+        return { ok: false, json: async () => ({}) };
+      return { ok: true, json: async () => resp };
+    }
+    return { ok: false, json: async () => ({}) };
+  }));
+}
+afterEach(() => {
+  vi.unstubAllGlobals();
+});
+describe("detectMtplx", () => {
+  it("returns null when /health lacks model or context_window", async () => {
+    mockFetch({ "http://x/health": {} });
+    expect(await detectMtplx("http://x", "")).toBeNull();
+  });
+  it("returns null on network failure / non-200", async () => {
+    mockFetch({});
+    expect(await detectMtplx("http://x", "")).toBeNull();
+  });
+  it("parses a full /health response", async () => {
+    mockFetch({
+      "http://x/health": {
+        model: "org/Model-7B",
+        context_window: 65536,
+        max_response_tokens: 4096,
+        enable_thinking: true,
+        vision: { enabled: true }
+      }
+    });
+    expect(await detectMtplx("http://x", "")).toEqual({
+      apiType: "mtplx",
+      models: [
+        {
+          id: "org/Model-7B",
+          name: "Model-7B",
+          contextWindow: 65536,
+          maxTokens: 4096,
+          reasoning: true,
+          input: ["text", "image"]
+        }
+      ]
+    });
+  });
+  it("falls back to capped maxTokens when max_response_tokens is absent", async () => {
+    mockFetch({ "http://x/health": { model: "m", context_window: 4000 } });
+    const result = await detectMtplx("http://x", "");
+    expect(result?.models[0].maxTokens).toBe(2000);
+  });
+  it("treats reasoning:'on' the same as enable_thinking:true", async () => {
+    mockFetch({ "http://x/health": { model: "m", context_window: 4000, reasoning: "on" } });
+    const result = await detectMtplx("http://x", "");
+    expect(result?.models[0].reasoning).toBe(true);
+  });
+  it("defaults to text-only input when vision is absent or disabled", async () => {
+    mockFetch({ "http://x/health": { model: "m", context_window: 4000 } });
+    const result = await detectMtplx("http://x", "");
+    expect(result?.models[0].input).toEqual(["text"]);
+  });
+});
+describe("detectOmlx", () => {
+  it("returns null when the server has no models", async () => {
+    mockFetch({ "http://x/v1/models/status": { models: [] } });
+    expect(await detectOmlx("http://x", "")).toBeNull();
+  });
+  it("filters out non llm/vlm model types", async () => {
+    mockFetch({
+      "http://x/v1/models/status": {
+        models: [
+          { id: "a", model_type: "llm", max_context_window: 8192 },
+          { id: "b", model_type: "embedding", max_context_window: 8192 },
+          { id: "c" }
+        ]
+      }
+    });
+    const result = await detectOmlx("http://x", "");
+    expect(result?.models.map((m) => m.id)).toEqual(["a"]);
+  });
+  it("prefers model_alias, falls back to display_name then id", async () => {
+    mockFetch({
+      "http://x/v1/models/status": {
+        models: [{ id: "id1", display_name: "Display", model_type: "llm", max_context_window: 4096 }]
+      }
+    });
+    const result = await detectOmlx("http://x", "");
+    expect(result?.models[0].name).toBe("Display");
+  });
+  it("marks vlm models as vision-capable and reads thinking_default", async () => {
+    mockFetch({
+      "http://x/v1/models/status": {
+        models: [
+          {
+            id: "id1",
+            model_alias: "Alias",
+            model_type: "vlm",
+            max_context_window: 4096,
+            thinking_default: true
+          }
+        ]
+      }
+    });
+    const result = await detectOmlx("http://x", "");
+    expect(result?.models[0]).toMatchObject({
+      name: "Alias",
+      input: ["text", "image"],
+      reasoning: true
+    });
+  });
+  it("reads loaded status and estimated_size", async () => {
+    mockFetch({
+      "http://x/v1/models/status": {
+        models: [
+          {
+            id: "id1",
+            model_type: "llm",
+            max_context_window: 4096,
+            loaded: true,
+            estimated_size: 4912898304
+          }
+        ]
+      }
+    });
+    const result = await detectOmlx("http://x", "");
+    expect(result?.models[0]).toMatchObject({ loaded: true, sizeBytes: 4912898304 });
+  });
+  it("treats a missing loaded field as not loaded", async () => {
+    mockFetch({
+      "http://x/v1/models/status": {
+        models: [{ id: "id1", model_type: "llm", max_context_window: 4096 }]
+      }
+    });
+    const result = await detectOmlx("http://x", "");
+    expect(result?.models[0].loaded).toBe(false);
+  });
+});
+describe("detectLmStudio", () => {
+  it("returns null when the server has no models", async () => {
+    mockFetch({ "http://x/api/v1/models": { models: [] } });
+    expect(await detectLmStudio("http://x", "")).toBeNull();
+  });
+  it("filters by type and reads capabilities", async () => {
+    mockFetch({
+      "http://x/api/v1/models": {
+        models: [
+          {
+            key: "k1",
+            type: "llm",
+            max_context_length: 32768,
+            capabilities: { reasoning: { allowed_options: ["low"] } }
+          },
+          { key: "k2", type: "embedding" }
+        ]
+      }
+    });
+    const result = await detectLmStudio("http://x", "");
+    expect(result?.models).toHaveLength(1);
+    expect(result?.models[0]).toMatchObject({ id: "k1", contextWindow: 32768, reasoning: true });
+  });
+  it("marks vision-capable models via capabilities.vision or vlm type", async () => {
+    mockFetch({
+      "http://x/api/v1/models": {
+        models: [{ key: "k1", type: "vlm", capabilities: { vision: true } }]
+      }
+    });
+    const result = await detectLmStudio("http://x", "");
+    expect(result?.models[0].input).toEqual(["text", "image"]);
+  });
+  it("reads loaded status, size, and quantization", async () => {
+    mockFetch({
+      "http://x/api/v1/models": {
+        models: [
+          {
+            key: "k1",
+            type: "llm",
+            max_context_length: 4096,
+            loaded_instances: [{}],
+            size_bytes: 4912898304,
+            quantization: { name: "Q4_K_M" }
+          }
+        ]
+      }
+    });
+    const result = await detectLmStudio("http://x", "");
+    expect(result?.models[0]).toMatchObject({
+      loaded: true,
+      sizeBytes: 4912898304,
+      quantization: "Q4_K_M"
+    });
+  });
+  it("treats an empty loaded_instances array as not loaded", async () => {
+    mockFetch({
+      "http://x/api/v1/models": {
+        models: [{ key: "k1", type: "llm", loaded_instances: [] }]
+      }
+    });
+    const result = await detectLmStudio("http://x", "");
+    expect(result?.models[0].loaded).toBe(false);
+  });
+});
+describe("detectLlamaCpp", () => {
+  it("returns null when /props lacks n_ctx or model_path", async () => {
+    mockFetch({ "http://x/props": { default_generation_settings: {} } });
+    expect(await detectLlamaCpp("http://x", "")).toBeNull();
+  });
+  it("combines /props (context, vision) with /v1/models (alias-aware id)", async () => {
+    mockFetch({
+      "http://x/props": {
+        default_generation_settings: { n_ctx: 8192 },
+        model_path: "../models/Meta-Llama-3.1-8B-Instruct-Q4_K_M.gguf",
+        modalities: { vision: true }
+      },
+      "http://x/v1/models": {
+        data: [{ id: "gpt-4o-mini", meta: { n_ctx_train: 131072 } }]
+      }
+    });
+    const result = await detectLlamaCpp("http://x", "");
+    expect(result).toEqual({
+      apiType: "llamacpp",
+      models: [
+        {
+          id: "gpt-4o-mini",
+          name: "gpt-4o-mini",
+          contextWindow: 8192,
+          maxTokens: 4096,
+          reasoning: false,
+          input: ["text", "image"]
+        }
+      ]
+    });
+  });
+  it("derives a name from the model file basename when no --alias is set", async () => {
+    mockFetch({
+      "http://x/props": {
+        default_generation_settings: { n_ctx: 4096 },
+        model_path: "../models/Meta-Llama-3.1-8B-Instruct-Q4_K_M.gguf"
+      }
+    });
+    const result = await detectLlamaCpp("http://x", "");
+    expect(result?.models[0]).toMatchObject({
+      id: "../models/Meta-Llama-3.1-8B-Instruct-Q4_K_M.gguf",
+      name: "Meta-Llama-3.1-8B-Instruct-Q4_K_M.gguf"
+    });
+  });
+  it("falls back to n_ctx_train when /props doesn't report a running context", async () => {
+    mockFetch({
+      "http://x/props": {
+        default_generation_settings: { n_ctx: 0 },
+        model_path: "/models/m.gguf"
+      },
+      "http://x/v1/models": { data: [{ id: "/models/m.gguf", meta: { n_ctx_train: 131072 } }] }
+    });
+    const result = await detectLlamaCpp("http://x", "");
+    expect(result?.models[0].contextWindow).toBe(131072);
+  });
+  it("reads file size from /v1/models meta", async () => {
+    mockFetch({
+      "http://x/props": { default_generation_settings: { n_ctx: 4096 }, model_path: "/models/m.gguf" },
+      "http://x/v1/models": { data: [{ id: "/models/m.gguf", meta: { size: 4912898304 } }] }
+    });
+    const result = await detectLlamaCpp("http://x", "");
+    expect(result?.models[0].sizeBytes).toBe(4912898304);
+  });
+});
+function mockSglang(overrides = {}) {
+  mockFetch({
+    "http://x/get_model_info": overrides.modelInfo ?? {
+      model_path: "/models/Qwen3.8-27B-NVFP4",
+      is_generation: true,
+      has_image_understanding: true
+    },
+    "http://x/get_server_info": overrides.serverInfo ?? { reasoning_parser: "qwen3", context_length: null },
+    "http://x/v1/models": overrides.models ?? {
+      data: [{ id: "/models/Qwen3.8-27B-NVFP4", owned_by: "sglang", max_model_len: 262144 }]
+    },
+    "http://x/api/tags": {
+      models: [
+        {
+          name: "/models/Qwen3.8-27B-NVFP4",
+          model: "/models/Qwen3.8-27B-NVFP4",
+          details: { format: "sglang" }
+        }
+      ]
+    },
+    "http://x/api/show": { model_info: {}, capabilities: ["completion"] }
+  });
+}
+function mockSglangProbe(statuses, routes = {}) {
+  vi.stubGlobal("fetch", vi.fn(async (url, init) => {
+    const u = String(url);
+    if (u.endsWith("/chat/completions")) {
+      const body = init?.body ? JSON.parse(String(init.body)) : {};
+      const isDeveloper = (body.messages ?? []).some((m) => m.role === "developer");
+      const key = isDeveloper ? "__developer__" : String(body.reasoning_effort);
+      const status = statuses[key] ?? 400;
+      if (status === "network-error")
+        throw new Error("connection refused");
+      return { ok: status === 200, status, text: async () => "", json: async () => ({}) };
+    }
+    if (u in routes)
+      return { ok: true, status: 200, json: async () => routes[u] };
+    return { ok: false, status: 404, json: async () => ({}) };
+  }));
+}
+const QWEN38_STATUSES = {
+  none: 200,
+  minimal: 400,
+  low: 200,
+  medium: 200,
+  high: 400,
+  xhigh: 200,
+  max: 400,
+  __developer__: 400
+};
+describe("nearestTier", () => {
+  const accepted = ["none", "low", "medium", "xhigh"];
+  it("passes through a level the model accepts verbatim", () => {
+    expect(nearestTier("low", accepted)).toBe("low");
+    expect(nearestTier("xhigh", accepted)).toBe("xhigh");
+  });
+  it("lifts a level below the model's floor up to it", () => {
+    expect(nearestTier("minimal", accepted)).toBe("low");
+  });
+  it("drops a level above the model's ceiling down to it", () => {
+    expect(nearestTier("max", accepted)).toBe("xhigh");
+  });
+  it("breaks a tie toward the weaker tier", () => {
+    expect(nearestTier("high", accepted)).toBe("medium");
+  });
+  it("never resolves a thinking level to none", () => {
+    expect(nearestTier("minimal", ["none", "xhigh"])).toBe("xhigh");
+  });
+  it("returns undefined when the model accepts no thinking tier", () => {
+    expect(nearestTier("medium", ["none"])).toBeUndefined();
+  });
+});
+describe("probeRequestCompat", () => {
+  it("reproduces the map hand-verified against a Qwen3.8 server", async () => {
+    mockSglangProbe(QWEN38_STATUSES);
+    const result = await probeRequestCompat("http://x/v1", "", "m");
+    expect(result).toEqual({
+      compat: { supportsReasoningEffort: true, supportsDeveloperRole: false },
+      thinkingLevelMap: {
+        off: "none",
+        minimal: "low",
+        low: "low",
+        medium: "medium",
+        high: "medium",
+        xhigh: "xhigh",
+        max: "xhigh"
+      }
+    });
+  });
+  it("records the developer role when the template accepts it", async () => {
+    mockSglangProbe({ ...QWEN38_STATUSES, __developer__: 200 });
+    const result = await probeRequestCompat("http://x/v1", "", "m");
+    expect(result.compat?.supportsDeveloperRole).toBe(true);
+  });
+  it("leaves off unmapped when the model cannot disable reasoning", async () => {
+    mockSglangProbe({ ...QWEN38_STATUSES, none: 400 });
+    const result = await probeRequestCompat("http://x/v1", "", "m");
+    expect(result.thinkingLevelMap).not.toHaveProperty("off");
+    expect(result.thinkingLevelMap?.medium).toBe("medium");
+  });
+  it("claims nothing when the server rejects every tier", async () => {
+    mockSglangProbe({ __developer__: 400 });
+    expect(await probeRequestCompat("http://x/v1", "", "m")).toEqual({});
+  });
+  it("claims nothing when a single tier fails for a reason other than rejection", async () => {
+    mockSglangProbe({ ...QWEN38_STATUSES, medium: 503 });
+    expect(await probeRequestCompat("http://x/v1", "", "m")).toEqual({});
+  });
+  it("treats a rate-limited tier as unanswered, not as unsupported", async () => {
+    mockSglangProbe({ ...QWEN38_STATUSES, xhigh: 429 });
+    expect(await probeRequestCompat("http://x/v1", "", "m")).toEqual({});
+  });
+  it("still trusts a sweep when only the developer probe fails", async () => {
+    mockSglangProbe({ ...QWEN38_STATUSES, __developer__: "network-error" });
+    const result = await probeRequestCompat("http://x/v1", "", "m");
+    expect(result.compat).toEqual({ supportsReasoningEffort: true, supportsDeveloperRole: false });
+    expect(result.thinkingLevelMap?.high).toBe("medium");
+  });
+  it("claims nothing when no probe gets a reply at all", async () => {
+    mockSglangProbe({
+      none: "network-error",
+      minimal: "network-error",
+      low: "network-error",
+      medium: "network-error",
+      high: "network-error",
+      xhigh: "network-error",
+      max: "network-error",
+      __developer__: "network-error"
+    });
+    expect(await probeRequestCompat("http://x/v1", "", "m")).toEqual({});
+  });
+});
+describe("detectSglang", () => {
+  it("reads context from /v1/models and capabilities from the SGLang endpoints", async () => {
+    mockSglang();
+    const result = await detectSglang("http://x", "http://x/v1", "");
+    expect(result?.apiType).toBe("sglang");
+    expect(result?.models).toHaveLength(1);
+    expect(result?.models[0]).toMatchObject({
+      id: "/models/Qwen3.8-27B-NVFP4",
+      name: "Qwen3.8-27B-NVFP4",
+      contextWindow: 262144,
+      maxTokens: 65536,
+      reasoning: true,
+      input: ["text", "image"]
+    });
+  });
+  it("applies Qwen's published thinking temperature", async () => {
+    mockSglang({
+      modelInfo: {
+        model_path: "/models/m",
+        is_generation: true,
+        model_type: "qwen3_5",
+        has_image_understanding: true
+      }
+    });
+    const result = await detectSglang("http://x", "http://x/v1", "");
+    expect(result?.models[0].samplingParams).toEqual({ temperature: 0.6 });
+  });
+  it("leaves an unfamiliar family on the server's own default", async () => {
+    mockSglang({
+      modelInfo: { model_path: "/models/m", is_generation: true, model_type: "llama" }
+    });
+    const result = await detectSglang("http://x", "http://x/v1", "");
+    expect(result?.models[0].samplingParams).toBeUndefined();
+  });
+  it("leaves a non-reasoning Qwen alone", async () => {
+    mockSglang({
+      modelInfo: { model_path: "/models/m", is_generation: true, model_type: "qwen3_5" },
+      serverInfo: { reasoning_parser: null }
+    });
+    const result = await detectSglang("http://x", "http://x/v1", "");
+    expect(result?.models[0].samplingParams).toBeUndefined();
+  });
+  it("attaches the measured request compat to every model", async () => {
+    mockSglangProbe(QWEN38_STATUSES, {
+      "http://x/get_model_info": {
+        model_path: "/models/m",
+        is_generation: true,
+        has_image_understanding: true
+      },
+      "http://x/get_server_info": { reasoning_parser: "qwen3" },
+      "http://x/v1/models": { data: [{ id: "/models/m", max_model_len: 262144 }] }
+    });
+    const result = await detectSglang("http://x", "http://x/v1", "");
+    expect(result?.models[0].compat).toEqual({
+      supportsReasoningEffort: true,
+      supportsDeveloperRole: false
+    });
+    expect(result?.models[0].thinkingLevelMap?.high).toBe("medium");
+  });
+  it("reports no reasoning, and probes nothing, without a reasoning_parser", async () => {
+    mockSglang({ serverInfo: { reasoning_parser: null } });
+    const result = await detectSglang("http://x", "http://x/v1", "");
+    expect(result?.models[0].reasoning).toBe(false);
+    expect(result?.models[0].compat).toBeUndefined();
+    const calls = fetch.mock.calls;
+    expect(calls.some((c) => String(c[0]).endsWith("/chat/completions"))).toBe(false);
+  });
+  it("reports text-only when the model has no image understanding", async () => {
+    mockSglang({
+      modelInfo: { model_path: "/models/m", is_generation: true, has_image_understanding: false }
+    });
+    const result = await detectSglang("http://x", "http://x/v1", "");
+    expect(result?.models[0].input).toEqual(["text"]);
+  });
+  it("declines an embedding-only server so the chain keeps looking", async () => {
+    mockSglang({ modelInfo: { model_path: "/models/e", is_generation: false } });
+    expect(await detectSglang("http://x", "http://x/v1", "")).toBeNull();
+  });
+  it("returns null when /get_model_info is absent", async () => {
+    mockFetch({ "http://x/v1/models": { data: [{ id: "m", max_model_len: 4096 }] } });
+    expect(await detectSglang("http://x", "http://x/v1", "")).toBeNull();
+  });
+  it("wins over Ollama in the chain despite the compatibility shim", async () => {
+    mockSglang();
+    const result = await detectModels("http://x/v1", "");
+    expect(result.apiType).toBe("sglang");
+    expect(result.models[0].input).toEqual(["text", "image"]);
+  });
+  it("leaves a real Ollama server to the Ollama probe", async () => {
+    mockOllama({ models: [{ name: "llama3:8b", model: "llama3:8b" }] }, {
+      "llama3:8b": {
+        model_info: { "general.architecture": "llama", "llama.context_length": 8192 },
+        capabilities: ["completion", "thinking"]
+      }
+    });
+    const result = await detectModels("http://x/v1", "");
+    expect(result.apiType).toBe("ollama");
+  });
+});
+describe("detectOllama", () => {
+  it("returns null when there are no local models", async () => {
+    mockOllama({ models: [] }, {});
+    expect(await detectOllama("http://x", "")).toBeNull();
+  });
+  it("reads context_length via the architecture-prefixed key and thinking/vision capabilities", async () => {
+    mockOllama({ models: [{ name: "deepseek-r1:latest", model: "deepseek-r1:latest" }] }, {
+      "deepseek-r1:latest": {
+        model_info: { "general.architecture": "qwen2", "qwen2.context_length": 32768 },
+        capabilities: ["completion", "thinking"]
+      }
+    });
+    const result = await detectOllama("http://x", "");
+    expect(result).toEqual({
+      apiType: "ollama",
+      models: [
+        {
+          id: "deepseek-r1:latest",
+          name: "deepseek-r1:latest",
+          contextWindow: 32768,
+          maxTokens: 16384,
+          reasoning: true,
+          input: ["text"],
+          loaded: false
+        }
+      ]
+    });
+  });
+  it("marks vision-capable models via the vision capability", async () => {
+    mockOllama({ models: [{ name: "llava:latest", model: "llava:latest" }] }, { "llava:latest": { model_info: {}, capabilities: ["completion", "vision"] } });
+    const result = await detectOllama("http://x", "");
+    expect(result?.models[0].input).toEqual(["text", "image"]);
+  });
+  it("queries /api/show independently per model", async () => {
+    mockOllama({
+      models: [
+        { name: "a:latest", model: "a:latest" },
+        { name: "b:latest", model: "b:latest" }
+      ]
+    }, {
+      "a:latest": { model_info: { "general.architecture": "llama", "llama.context_length": 8192 }, capabilities: [] },
+      "b:latest": { model_info: { "general.architecture": "llama", "llama.context_length": 4096 }, capabilities: ["thinking"] }
+    });
+    const result = await detectOllama("http://x", "");
+    expect(result?.models.map((m) => [m.id, m.contextWindow, m.reasoning])).toEqual([
+      ["a:latest", 8192, false],
+      ["b:latest", 4096, true]
+    ]);
+  });
+  it("defaults to 32768 when /api/show fails or lacks context_length", async () => {
+    mockOllama({ models: [{ name: "a:latest", model: "a:latest" }] }, {});
+    const result = await detectOllama("http://x", "");
+    expect(result?.models[0].contextWindow).toBe(32768);
+  });
+  it("reads size and quantization directly from /api/tags, and loaded state from /api/ps", async () => {
+    mockOllama({
+      models: [
+        { name: "a:latest", model: "a:latest", size: 4683075271, details: { quantization_level: "Q4_K_M" } },
+        { name: "b:latest", model: "b:latest", size: 2019393189, details: { quantization_level: "Q8_0" } }
+      ]
+    }, {}, { models: [{ model: "a:latest" }] });
+    const result = await detectOllama("http://x", "");
+    expect(result?.models).toEqual([
+      expect.objectContaining({
+        id: "a:latest",
+        sizeBytes: 4683075271,
+        quantization: "Q4_K_M",
+        loaded: true
+      }),
+      expect.objectContaining({
+        id: "b:latest",
+        sizeBytes: 2019393189,
+        quantization: "Q8_0",
+        loaded: false
+      })
+    ]);
+  });
+});
+describe("detectVllm", () => {
+  it("returns null when /version doesn't respond", async () => {
+    mockFetch({ "http://x/v1/models": { data: [{ id: "m1", max_model_len: 4096 }] } });
+    expect(await detectVllm("http://x", "http://x/v1", "")).toBeNull();
+  });
+  it("returns null when /version responds but no model has max_model_len", async () => {
+    mockFetch({
+      "http://x/version": { version: "0.6.3" },
+      "http://x/v1/models": { data: [{ id: "m1" }] }
+    });
+    expect(await detectVllm("http://x", "http://x/v1", "")).toBeNull();
+  });
+  it("requires both /version and a max_model_len-bearing /v1/models entry", async () => {
+    mockFetch({
+      "http://x/version": { version: "0.6.3" },
+      "http://x/v1/models": { data: [{ id: "org/Model-7B", max_model_len: 32768 }] }
+    });
+    const result = await detectVllm("http://x", "http://x/v1", "");
+    expect(result).toEqual({
+      apiType: "vllm",
+      models: [
+        {
+          id: "org/Model-7B",
+          name: "Model-7B",
+          contextWindow: 32768,
+          maxTokens: 8192,
+          reasoning: false,
+          input: ["text"]
+        }
+      ]
+    });
+  });
+});
+describe("detectOpenAI", () => {
+  it("reads max_model_len, then context_window, then defaults to 32768", async () => {
+    mockFetch({
+      "http://x/v1/models": {
+        data: [{ id: "m1", max_model_len: 16384 }, { id: "m2", context_window: 8192 }, { id: "m3" }]
+      }
+    });
+    const result = await detectOpenAI("http://x/v1", "");
+    expect(result.models.map((m) => m.contextWindow)).toEqual([16384, 8192, 32768]);
+  });
+  it("reads OpenRouter-style context_length and top_provider.context_length", async () => {
+    mockFetch({
+      "http://x/v1/models": {
+        data: [
+          { id: "m1", context_length: 131072 },
+          { id: "m2", context_length: 8192, top_provider: { context_length: 131072 } }
+        ]
+      }
+    });
+    const result = await detectOpenAI("http://x/v1", "");
+    expect(result.models.map((m) => m.contextWindow)).toEqual([131072, 131072]);
+  });
+  it("reads name, reasoning and vision from an OpenRouter-style card", async () => {
+    mockFetch({
+      "http://x/v1/models": {
+        data: [
+          {
+            id: "deepseek-v4-flash",
+            name: "DeepSeek V4 Flash",
+            context_length: 131072,
+            top_provider: { context_length: 131072, max_completion_tokens: 131072 },
+            architecture: { input_modalities: ["text", "image"] },
+            supported_parameters: ["tools", "temperature", "reasoning_effort"]
+          }
+        ]
+      }
+    });
+    const result = await detectOpenAI("http://x/v1", "");
+    expect(result.models[0]).toMatchObject({
+      id: "deepseek-v4-flash",
+      name: "DeepSeek V4 Flash",
+      contextWindow: 131072,
+      reasoning: true,
+      input: ["text", "image"]
+    });
+  });
+  it("ignores a max_completion_tokens that just repeats the context window", async () => {
+    mockFetch({
+      "http://x/v1/models": {
+        data: [
+          { id: "m1", context_length: 131072, top_provider: { max_completion_tokens: 131072 } },
+          { id: "m2", context_length: 131072, top_provider: { max_completion_tokens: 4096 } }
+        ]
+      }
+    });
+    const result = await detectOpenAI("http://x/v1", "");
+    expect(result.models.map((m) => m.maxTokens)).toEqual([8192, 4096]);
+  });
+  it("returns an empty model list when the response has no data", async () => {
+    mockFetch({ "http://x/v1/models": {} });
+    const result = await detectOpenAI("http://x/v1", "");
+    expect(result).toEqual({ apiType: "openai", models: [] });
+  });
+  it("gives a reasoning model more headroom than a plain one", async () => {
+    mockFetch({
+      "http://x/v1/models": {
+        data: [
+          { id: "plain", context_length: 262144 },
+          { id: "thinker", context_length: 262144, supported_parameters: ["reasoning_effort"] }
+        ]
+      }
+    });
+    const result = await detectOpenAI("http://x/v1", "");
+    expect(result.models.map((m) => m.maxTokens)).toEqual([8192, 65536]);
+  });
+  it("keeps the half-context floor below either ceiling", async () => {
+    mockFetch({
+      "http://x/v1/models": {
+        data: [{ id: "small", context_length: 8192, supported_parameters: ["reasoning_effort"] }]
+      }
+    });
+    const result = await detectOpenAI("http://x/v1", "");
+    expect(result.models[0].maxTokens).toBe(4096);
+  });
+});
+function ds4Card(id, ctx = 131072, maxCompletion = 131072) {
+  return {
+    id,
+    object: "model",
+    created: 1767225600,
+    owned_by: "ds4.c",
+    name: "DeepSeek V4 Flash",
+    context_length: ctx,
+    top_provider: { context_length: ctx, max_completion_tokens: maxCompletion, is_moderated: false },
+    supported_parameters: ["tools", "tool_choice", "max_tokens", "temperature", "reasoning_effort"]
+  };
+}
+describe("ds4", () => {
+  it("identifies ds4 by owned_by and registers every alias", async () => {
+    mockFetch({
+      "http://x/v1/models": { data: [ds4Card("deepseek-v4-flash"), ds4Card("deepseek-v4-pro")] }
+    });
+    const result = await detectOpenAI("http://x/v1", "");
+    expect(result.apiType).toBe("ds4");
+    expect(result.models.map((m) => m.id)).toEqual(["deepseek-v4-flash", "deepseek-v4-pro"]);
+    expect(result.models[0]).toMatchObject({
+      name: "DeepSeek V4 Flash",
+      contextWindow: 131072,
+      maxTokens: 65536,
+      reasoning: true,
+      input: ["text"],
+      compat: { supportsReasoningEffort: true, supportsDeveloperRole: true }
+    });
+  });
+  it("maps the two thinking levels ds4 would otherwise get wrong", async () => {
+    mockFetch({ "http://x/v1/models": { data: [ds4Card("deepseek-v4-flash")] } });
+    const result = await detectOpenAI("http://x/v1", "");
+    expect(result.models[0].thinkingLevelMap).toEqual({ off: "none", max: "max" });
+  });
+  it("leaves xhigh unmapped so DM does not offer a duplicate of high", async () => {
+    mockFetch({ "http://x/v1/models": { data: [ds4Card("deepseek-v4-flash")] } });
+    const result = await detectOpenAI("http://x/v1", "");
+    expect(result.models[0].thinkingLevelMap).not.toHaveProperty("xhigh");
+  });
+  it("identifies a GLM-DSA engine's alias set too", async () => {
+    mockFetch({
+      "http://x/v1/models": {
+        data: [ds4Card("glm-5.2"), ds4Card("glm-5.2-chat"), ds4Card("glm-5.2-reasoner")]
+      }
+    });
+    const result = await detectOpenAI("http://x/v1", "");
+    expect(result.apiType).toBe("ds4");
+    expect(result.models).toHaveLength(3);
+  });
+  it("honours --default-tokens when it restricts output below the context", async () => {
+    mockFetch({ "http://x/v1/models": { data: [ds4Card("deepseek-v4-flash", 131072, 4096)] } });
+    const result = await detectOpenAI("http://x/v1", "");
+    expect(result.models[0].maxTokens).toBe(4096);
+  });
+  it("stays generic when only some cards carry the ds4 owner", async () => {
+    mockFetch({
+      "http://x/v1/models": { data: [ds4Card("deepseek-v4-flash"), { id: "other", owned_by: "acme" }] }
+    });
+    const result = await detectOpenAI("http://x/v1", "");
+    expect(result.apiType).toBe("openai");
+    expect(result.models.every((m) => m.compat === undefined)).toBe(true);
+  });
+  it("reaches ds4 through the full detection chain", async () => {
+    mockFetch({ "http://x/v1/models": { data: [ds4Card("deepseek-v4-flash")] } });
+    const result = await detectModels("http://x/v1", "");
+    expect(result.apiType).toBe("ds4");
+  });
+});
+describe("detectModels chain", () => {
+  it("prefers MTPLX when its /health responds with valid data", async () => {
+    mockFetch({ "http://x/health": { model: "m", context_window: 4096 } });
+    const result = await detectModels("http://x/v1", "");
+    expect(result.apiType).toBe("mtplx");
+  });
+  it("falls through to oMLX when MTPLX is absent", async () => {
+    mockFetch({
+      "http://x/v1/models/status": {
+        models: [{ id: "a", model_type: "llm", max_context_window: 4096 }]
+      }
+    });
+    const result = await detectModels("http://x/v1", "");
+    expect(result.apiType).toBe("omlx");
+  });
+  it("falls through to LM Studio when MTPLX and oMLX are absent", async () => {
+    mockFetch({
+      "http://x/api/v1/models": {
+        models: [{ key: "k1", type: "llm", max_context_length: 4096 }]
+      }
+    });
+    const result = await detectModels("http://x/v1", "");
+    expect(result.apiType).toBe("lmstudio");
+  });
+  it("falls through to llama.cpp when MTPLX/oMLX/LM Studio are absent", async () => {
+    mockFetch({
+      "http://x/props": {
+        default_generation_settings: { n_ctx: 4096 },
+        model_path: "/models/m.gguf"
+      }
+    });
+    const result = await detectModels("http://x/v1", "");
+    expect(result.apiType).toBe("llamacpp");
+  });
+  it("falls through to Ollama when the above are all absent", async () => {
+    mockFetch({
+      "http://x/api/tags": { models: [{ name: "a:latest", model: "a:latest" }] }
+    });
+    const result = await detectModels("http://x/v1", "");
+    expect(result.apiType).toBe("ollama");
+  });
+  it("falls through to vLLM when only /version + max_model_len are present", async () => {
+    mockFetch({
+      "http://x/version": { version: "0.6.3" },
+      "http://x/v1/models": { data: [{ id: "m1", max_model_len: 4096 }] }
+    });
+    const result = await detectModels("http://x/v1", "");
+    expect(result.apiType).toBe("vllm");
+  });
+  it("falls all the way through to the generic OpenAI probe", async () => {
+    mockFetch({ "http://x/v1/models": { data: [{ id: "m1" }] } });
+    const result = await detectModels("http://x/v1", "");
+    expect(result.apiType).toBe("openai");
+  });
+  it("shares one AbortSignal across every probe instead of a fresh one each", async () => {
+    const seenSignals = [];
+    vi.stubGlobal("fetch", vi.fn(async (_url, init) => {
+      seenSignals.push(init?.signal);
+      return { ok: false, json: async () => ({}) };
+    }));
+    await detectModels("http://x/v1", "");
+    expect(seenSignals.length).toBeGreaterThanOrEqual(7);
+    expect(new Set(seenSignals).size).toBe(1);
+    expect(seenSignals[0]).toBeInstanceOf(AbortSignal);
+  });
+  it("combines an externally-provided signal with the chain deadline rather than replacing it", async () => {
+    const seenSignals = [];
+    vi.stubGlobal("fetch", vi.fn(async (_url, init) => {
+      seenSignals.push(init?.signal);
+      return { ok: false, json: async () => ({}) };
+    }));
+    const external = new AbortController().signal;
+    await detectModels("http://x/v1", "", external);
+    expect(new Set(seenSignals).size).toBe(1);
+    expect(seenSignals[0]).not.toBe(external);
+  });
+});
+describe("detectModels error summarization", () => {
+  it("reports an auth failure when every probe returns 401", async () => {
+    mockFetchAllStatus(401);
+    const result = await detectModels("http://x/v1", "wrong-key");
+    expect(result.models).toEqual([]);
+    expect(result.error).toBe("Authentication failed (HTTP 401) — check the API key.");
+  });
+  it("reports an auth failure when every probe returns 403", async () => {
+    mockFetchAllStatus(403);
+    const result = await detectModels("http://x/v1", "");
+    expect(result.error).toBe("Authentication failed (HTTP 403) — check the API key.");
+  });
+  it("reports a timeout when every probe aborts", async () => {
+    const abortError = new DOMException("The operation was aborted.", "AbortError");
+    mockFetchAllReject(abortError);
+    const result = await detectModels("http://x/v1", "");
+    expect(result.error).toBe("Timed out waiting for a response — check the server is running and reachable.");
+  });
+  it("reports a connection failure when every probe throws a network error", async () => {
+    mockFetchAllReject(new TypeError("fetch failed"));
+    const result = await detectModels("http://x/v1", "");
+    expect(result.error).toBe("Could not connect to the server — check the URL and that it's running.");
+  });
+  it("leaves error undefined when the server genuinely has zero models (no auth/timeout signal)", async () => {
+    mockFetch({ "http://x/v1/models": { data: [] } });
+    const result = await detectModels("http://x/v1", "");
+    expect(result.models).toEqual([]);
+    expect(result.error).toBeUndefined();
+  });
+});
+function ninferCard(id = "qwen3.8-27b") {
+  return { id, object: "model", created: 1786000000, owned_by: "ninfer" };
+}
+function mockNinfer(cards, replies = {}, tiers = { none: 200, low: 200, medium: 200, xhigh: 200 }) {
+  vi.stubGlobal("fetch", vi.fn(async (url, init) => {
+    const u = String(url);
+    const reply = (status, body) => ({ ok: status === 200, status, text: async () => body, json: async () => ({}) });
+    if (u.endsWith("/v1/models")) {
+      return { ok: true, status: 200, json: async () => ({ object: "list", data: cards }) };
+    }
+    if (u.endsWith("/responses/input_tokens")) {
+      const v = replies.vision ?? { status: 400, body: '{"error":{"code":"vision_disabled"}}' };
+      return reply(v.status, v.body);
+    }
+    if (u.endsWith("/chat/completions")) {
+      const body = init?.body ? JSON.parse(String(init.body)) : {};
+      if (typeof body.reasoning_effort === "string") {
+        return reply(tiers[body.reasoning_effort] ?? 400, "");
+      }
+      if (body.messages?.some((m) => m.role === "developer")) {
+        return reply(400, '{"error":{"message":"Unexpected message role"}}');
+      }
+      const c = replies.context ?? {
+        status: 400,
+        body: '{"error":{"message":"prepared prompt has 300004 tokens, exceeding Engine max_context 16384"}}'
+      };
+      return reply(c.status, c.body);
+    }
+    return reply(404, "");
+  }));
+}
+describe("parseNinferContext", () => {
+  it("reads the ceiling out of a real rejection", () => {
+    const body = '{"error":{"code":"context_length_exceeded","message":"prepared prompt has 25052 tokens, ' + 'exceeding Engine max_context 16384","param":"messages","type":"invalid_request_error"}}';
+    expect(parseNinferContext(body)).toBe(16384);
+  });
+  it("reads the ceiling out of the rejection", () => {
+    expect(parseNinferContext("prepared prompt has 300004 tokens, exceeding Engine max_context 16384")).toBe(16384);
+  });
+  it("survives the message arriving wrapped in JSON", () => {
+    expect(parseNinferContext('{"error":{"message":"... Engine max_context 8192"}}')).toBe(8192);
+  });
+  it("gives up rather than guess", () => {
+    expect(parseNinferContext("context length exceeded")).toBeUndefined();
+    expect(parseNinferContext("")).toBeUndefined();
+    expect(parseNinferContext("max_context none")).toBeUndefined();
+  });
+});
+describe("isNinferCards", () => {
+  it("identifies the owner the schema hard-codes", () => {
+    expect(isNinferCards([ninferCard()])).toBe(true);
+  });
+  it("stays out of the way of a card that is not ninfer's", () => {
+    expect(isNinferCards([{ id: "m", owned_by: "sglang" }])).toBe(false);
+    expect(isNinferCards([{ id: "m" }])).toBe(false);
+    expect(isNinferCards([])).toBe(false);
+  });
+  it("declines a mixed list, as a gateway aggregating backends would send", () => {
+    expect(isNinferCards([ninferCard(), { id: "other", owned_by: "vllm" }])).toBe(false);
+  });
+});
+describe("probeNinfer", () => {
+  it("learns the context ceiling from the rejection", async () => {
+    mockNinfer([ninferCard()]);
+    expect((await probeNinfer("http://x/v1", "", "m")).contextWindow).toBe(16384);
+  });
+  it("falls back to ninfer's default when the rejection says nothing useful", async () => {
+    mockNinfer([ninferCard()], { context: { status: 400, body: "context_length_exceeded" } });
+    expect((await probeNinfer("http://x/v1", "", "m")).contextWindow).toBe(8192);
+  });
+  it("takes an accepted prompt as a floor when the overshoot was not enough", async () => {
+    mockNinfer([ninferCard()], {
+      context: { status: 200, body: '{"usage":{"prompt_tokens":300004,"completion_tokens":1}}' }
+    });
+    expect((await probeNinfer("http://x/v1", "", "m")).contextWindow).toBe(300004);
+  });
+  it("falls back when an accepted probe reports no usable prompt size", async () => {
+    mockNinfer([ninferCard()], { context: { status: 200, body: "not json" } });
+    expect((await probeNinfer("http://x/v1", "", "m")).contextWindow).toBe(8192);
+  });
+  it("falls back when the probe never gets an answer", async () => {
+    vi.stubGlobal("fetch", vi.fn(async () => {
+      throw new Error("connection refused");
+    }));
+    expect((await probeNinfer("http://x/v1", "", "m")).contextWindow).toBe(8192);
+  });
+  it("reads vision off the token-count rejection", async () => {
+    mockNinfer([ninferCard()]);
+    expect((await probeNinfer("http://x/v1", "", "m")).vision).toBe(false);
+  });
+  it("reads vision on when the token count is accepted", async () => {
+    mockNinfer([ninferCard()], { vision: { status: 200, body: '{"input_tokens":12}' } });
+    expect((await probeNinfer("http://x/v1", "", "m")).vision).toBe(true);
+  });
+  it("leaves vision unknown when the rejection is about something else", async () => {
+    mockNinfer([ninferCard()], { vision: { status: 400, body: '{"error":{"code":"invalid_request"}}' } });
+    expect((await probeNinfer("http://x/v1", "", "m")).vision).toBeUndefined();
+  });
+});
+describe("ninfer through the chain", () => {
+  it("is detected, measured, and mapped", async () => {
+    mockNinfer([ninferCard()]);
+    const result = await detectModels("http://x/v1", "");
+    expect(result.apiType).toBe("ninfer");
+    expect(result.models[0]).toMatchObject({
+      id: "qwen3.8-27b",
+      contextWindow: 16384,
+      reasoning: true,
+      input: ["text"]
+    });
+  });
+  it("maps DM's levels onto the tiers the artifact accepts", async () => {
+    mockNinfer([ninferCard()]);
+    const result = await detectModels("http://x/v1", "");
+    expect(result.models[0].thinkingLevelMap).toEqual({
+      off: "none",
+      minimal: "low",
+      low: "low",
+      medium: "medium",
+      high: "medium",
+      xhigh: "xhigh",
+      max: "xhigh"
+    });
+  });
+  it("reports a text-only artifact as text-only", async () => {
+    mockNinfer([ninferCard()]);
+    const result = await detectModels("http://x/v1", "");
+    expect(result.models[0].input).toEqual(["text"]);
+  });
+  it("reports vision when the server was started with it", async () => {
+    mockNinfer([ninferCard()], { vision: { status: 200, body: '{"input_tokens":12}' } });
+    const result = await detectModels("http://x/v1", "");
+    expect(result.models[0].input).toEqual(["text", "image"]);
+  });
+  it("claims no reasoning when the template exposes no tiers", async () => {
+    mockNinfer([ninferCard()], {}, {});
+    const result = await detectModels("http://x/v1", "");
+    expect(result.models[0].reasoning).toBe(false);
+    expect(result.models[0].thinkingLevelMap).toBeUndefined();
+  });
+});