@duckmind/dm-windows-x64 0.61.3 → 0.61.5

package/extensions/.dm-extensions.json

@@ -1,6 +1,6 @@
 {
   "status": "ok",
-  "prepared_at": "2026-08-03T02:55:20.310618+00:00",
+  "prepared_at": "2026-08-19T15:37:04.127639+00:00",
   "managed_entries": [
     {
       "id": "dm-context",
@@ -46,6 +46,11 @@
       "id": "dm-caveman",
       "target_dir": "extensions/dm-caveman",
       "bundle_mode": "source-package"
+    },
+    {
+      "id": "dm-localllm-provider",
+      "target_dir": "extensions/dm-localllm-provider",
+      "bundle_mode": "source-package"
     }
   ],
   "local_entries": [
@@ -559,6 +564,44 @@
         "runtime_specifier_rewrites": 0
       }
     },
+    {
+      "id": "dm-localllm-provider",
+      "staged_dir": "extensions/dm-localllm-provider",
+      "bundle_mode": "source-package",
+      "dependencies_installed": false,
+      "dependency_mode": "platform-package-dependency",
+      "dependencies_declared": [
+        "@duckmind/dm-coding-agent"
+      ],
+      "dependency_patches": [
+        "dm.extensions ts->js",
+        "main ts->js",
+        "drop-devDependencies",
+        "drop-peerDependencies",
+        "drop-scripts",
+        "drop-files"
+      ],
+      "stripped_documentation": [
+        "LICENSE",
+        "README.md"
+      ],
+      "javascript_compile": {
+        "tool": "bun build --no-bundle",
+        "mode": "module-preserving-transpile",
+        "files": [
+          "detect.test.js",
+          "detect.js",
+          "index.test.js",
+          "index.js",
+          "keychain.test.js",
+          "keychain.js"
+        ],
+        "file_count": 6,
+        "before_bytes": 131212,
+        "after_bytes": 82230,
+        "runtime_specifier_rewrites": 4
+      }
+    },
     {
       "id": "dm-cua",
       "staged_dir": "extensions/dm-cua",
@@ -628,7 +671,7 @@
   },
   "runtime_loader": {
     "status": "verified",
-    "entries": 12,
+    "entries": 13,
     "loader": "dm-coding-agent",
     "platform_dependencies": [
       "@ff-labs/fff-node",

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

@@ -0,0 +1,460 @@
+const STANDALONE_PROBE_TIMEOUT_MS = 5000;
+function recordFailure(diagnostics, url, status) {
+  diagnostics?.push({
+    url,
+    status,
+    reason: status === 401 ? "unauthorized" : status === 403 ? "forbidden" : "http-error"
+  });
+}
+function recordException(diagnostics, url, err) {
+  diagnostics?.push({
+    url,
+    reason: err instanceof Error && err.name === "AbortError" ? "timeout" : "network-error"
+  });
+}
+async function fetchJson(url, apiKey, signal, diagnostics) {
+  try {
+    const headers = {};
+    if (apiKey)
+      headers["Authorization"] = `Bearer ${apiKey}`;
+    const res = await fetch(url, {
+      headers,
+      signal: signal ?? AbortSignal.timeout(STANDALONE_PROBE_TIMEOUT_MS)
+    });
+    if (!res.ok) {
+      recordFailure(diagnostics, url, res.status);
+      return null;
+    }
+    return await res.json();
+  } catch (err) {
+    recordException(diagnostics, url, err);
+    return null;
+  }
+}
+async function postJson(url, apiKey, body, signal, diagnostics) {
+  try {
+    const headers = { "Content-Type": "application/json" };
+    if (apiKey)
+      headers["Authorization"] = `Bearer ${apiKey}`;
+    const res = await fetch(url, {
+      method: "POST",
+      headers,
+      body: JSON.stringify(body),
+      signal: signal ?? AbortSignal.timeout(STANDALONE_PROBE_TIMEOUT_MS)
+    });
+    if (!res.ok) {
+      recordFailure(diagnostics, url, res.status);
+      return null;
+    }
+    return await res.json();
+  } catch (err) {
+    recordException(diagnostics, url, err);
+    return null;
+  }
+}
+function capTokens(contextWindow, reasoning = false) {
+  return Math.min(Math.floor(contextWindow / 2), reasoning ? 65536 : 8192);
+}
+export async function detectMtplx(root, apiKey, signal, diagnostics) {
+  const health = await fetchJson(`${root}/health`, apiKey, signal, diagnostics);
+  if (!health?.model || typeof health.context_window !== "number")
+    return null;
+  const reasoning = health.enable_thinking === true || health.reasoning === "on";
+  const vision = health.vision?.enabled === true;
+  return {
+    apiType: "mtplx",
+    models: [
+      {
+        id: health.model,
+        name: health.model.split("/").pop() ?? health.model,
+        contextWindow: health.context_window,
+        maxTokens: health.max_response_tokens ?? capTokens(health.context_window, reasoning),
+        reasoning,
+        input: vision ? ["text", "image"] : ["text"]
+      }
+    ]
+  };
+}
+export async function detectOmlx(root, apiKey, signal, diagnostics) {
+  const res = await fetchJson(`${root}/v1/models/status`, apiKey, signal, diagnostics);
+  if (!res?.models?.length)
+    return null;
+  const models = [];
+  for (const m of res.models) {
+    if (!m.id || !m.model_type)
+      continue;
+    const type = m.model_type.toLowerCase();
+    if (type !== "llm" && type !== "vlm")
+      continue;
+    const contextWindow = m.max_context_window ?? 32768;
+    models.push({
+      id: m.id,
+      name: m.model_alias || m.display_name || m.id,
+      contextWindow,
+      maxTokens: m.max_tokens ?? capTokens(contextWindow, m.thinking_default === true),
+      reasoning: m.thinking_default === true,
+      input: type === "vlm" ? ["text", "image"] : ["text"],
+      loaded: m.loaded === true,
+      sizeBytes: firstNumber(m.estimated_size)
+    });
+  }
+  return models.length > 0 ? { apiType: "omlx", models } : null;
+}
+export async function detectLmStudio(root, apiKey, signal, diagnostics) {
+  const res = await fetchJson(`${root}/api/v1/models`, apiKey, signal, diagnostics);
+  if (!res?.models?.length)
+    return null;
+  const models = [];
+  for (const m of res.models) {
+    const type = (m.type ?? "").toLowerCase();
+    if (type !== "llm" && type !== "vlm")
+      continue;
+    const contextWindow = m.max_context_length ?? 32768;
+    models.push({
+      id: m.key,
+      name: m.display_name || m.key,
+      contextWindow,
+      maxTokens: capTokens(contextWindow, !!m.capabilities?.reasoning),
+      reasoning: !!m.capabilities?.reasoning,
+      input: m.capabilities?.vision || type === "vlm" ? ["text", "image"] : ["text"],
+      loaded: (m.loaded_instances?.length ?? 0) > 0,
+      sizeBytes: firstNumber(m.size_bytes),
+      quantization: m.quantization?.name
+    });
+  }
+  return models.length > 0 ? { apiType: "lmstudio", models } : null;
+}
+export async function detectLlamaCpp(root, apiKey, signal, diagnostics) {
+  const props = await fetchJson(`${root}/props`, apiKey, signal, diagnostics);
+  if (typeof props?.default_generation_settings?.n_ctx !== "number" || !props.model_path) {
+    return null;
+  }
+  const modelsRes = await fetchJson(`${root}/v1/models`, apiKey, signal, diagnostics);
+  const entry = modelsRes?.data?.[0];
+  const contextWindow = props.default_generation_settings.n_ctx || entry?.meta?.n_ctx_train || 32768;
+  const id = entry?.id ?? props.model_path;
+  return {
+    apiType: "llamacpp",
+    models: [
+      {
+        id,
+        name: id.split(/[\\/]/).pop() ?? id,
+        contextWindow,
+        maxTokens: capTokens(contextWindow),
+        reasoning: false,
+        input: props.modalities?.vision ? ["text", "image"] : ["text"],
+        sizeBytes: firstNumber(entry?.meta?.size)
+      }
+    ]
+  };
+}
+export async function detectOllama(root, apiKey, signal, diagnostics) {
+  const tags = await fetchJson(`${root}/api/tags`, apiKey, signal, diagnostics);
+  if (!tags?.models?.length)
+    return null;
+  const [shows, ps] = await Promise.all([
+    Promise.all(tags.models.map((m) => postJson(`${root}/api/show`, apiKey, { model: m.model }, signal, diagnostics))),
+    fetchJson(`${root}/api/ps`, apiKey, signal, diagnostics)
+  ]);
+  const runningModels = new Set(ps?.models?.map((m) => m.model) ?? []);
+  const models = tags.models.map((m, i) => {
+    const show = shows[i];
+    const info = show?.model_info;
+    const arch = typeof info?.["general.architecture"] === "string" ? info["general.architecture"] : undefined;
+    const rawContextWindow = arch ? info?.[`${arch}.context_length`] : undefined;
+    const contextWindow = typeof rawContextWindow === "number" ? rawContextWindow : 32768;
+    const capabilities = show?.capabilities ?? [];
+    return {
+      id: m.model,
+      name: m.name,
+      contextWindow,
+      maxTokens: capTokens(contextWindow, capabilities.includes("thinking")),
+      reasoning: capabilities.includes("thinking"),
+      input: capabilities.includes("vision") ? ["text", "image"] : ["text"],
+      loaded: runningModels.has(m.model),
+      sizeBytes: firstNumber(m.size),
+      quantization: m.details?.quantization_level
+    };
+  });
+  return { apiType: "ollama", models };
+}
+const THINKING_TIERS = ["none", "minimal", "low", "medium", "high", "xhigh", "max"];
+const PI_LEVELS = [
+  "off",
+  "minimal",
+  "low",
+  "medium",
+  "high",
+  "xhigh",
+  "max"
+];
+async function probe(url, apiKey, payload, signal) {
+  try {
+    const headers = { "Content-Type": "application/json" };
+    if (apiKey)
+      headers["Authorization"] = `Bearer ${apiKey}`;
+    const res = await fetch(url, {
+      method: "POST",
+      headers,
+      body: JSON.stringify(payload),
+      signal: signal ?? AbortSignal.timeout(STANDALONE_PROBE_TIMEOUT_MS)
+    });
+    const body = await res.text().catch(() => "");
+    return { status: res.status, body };
+  } catch {
+    return null;
+  }
+}
+async function probeStatus(url, apiKey, payload, signal) {
+  return (await probe(url, apiKey, payload, signal))?.status ?? null;
+}
+export function nearestTier(level, accepted) {
+  const wanted = PI_LEVELS.indexOf(level);
+  if (wanted < 0)
+    return;
+  const candidates = THINKING_TIERS.map((tier, i) => ({ tier, i })).filter((c) => c.tier !== "none" && accepted.includes(c.tier));
+  let best;
+  for (const c of candidates) {
+    if (!best || Math.abs(c.i - wanted) < Math.abs(best.i - wanted))
+      best = c;
+  }
+  return best?.tier;
+}
+export async function probeRequestCompat(baseUrl, apiKey, modelId, signal) {
+  const url = `${baseUrl}/chat/completions`;
+  const base = { model: modelId, max_tokens: 1, stream: false };
+  const user = { role: "user", content: "hi" };
+  const [tierStatuses, developerStatus] = await Promise.all([
+    Promise.all(THINKING_TIERS.map((tier) => probeStatus(url, apiKey, { ...base, messages: [user], reasoning_effort: tier }, signal))),
+    probeStatus(url, apiKey, { ...base, messages: [{ role: "developer", content: "You are terse." }, user] }, signal)
+  ]);
+  const isDefinitive = (s) => s === 200 || s === 400 || s === 422;
+  if (!tierStatuses.every(isDefinitive))
+    return {};
+  const accepted = THINKING_TIERS.filter((_, i) => tierStatuses[i] === 200);
+  const result = {};
+  if (accepted.length > 0) {
+    result.compat = { supportsReasoningEffort: true, supportsDeveloperRole: developerStatus === 200 };
+    const map = {};
+    if (accepted.includes("none"))
+      map.off = "none";
+    for (const level of PI_LEVELS) {
+      if (level === "off")
+        continue;
+      const tier = nearestTier(level, accepted);
+      if (tier)
+        map[level] = tier;
+    }
+    if (Object.keys(map).length > 0)
+      result.thinkingLevelMap = map;
+  } else if (developerStatus === 200) {
+    result.compat = { supportsDeveloperRole: true };
+  }
+  return result;
+}
+const QWEN_THINKING_TEMPERATURE = 0.6;
+function samplingParamsFor(modelType, reasoning) {
+  if (!reasoning || !modelType)
+    return;
+  return /^qwen/i.test(modelType) ? { temperature: QWEN_THINKING_TEMPERATURE } : undefined;
+}
+export async function detectSglang(root, baseUrl, apiKey, signal, diagnostics) {
+  const info = await fetchJson(`${root}/get_model_info`, apiKey, signal, diagnostics);
+  if (!info?.model_path || info.is_generation !== true)
+    return null;
+  const [serverInfo, modelsRes] = await Promise.all([
+    fetchJson(`${root}/get_server_info`, apiKey, signal, diagnostics),
+    fetchJson(`${baseUrl}/models`, apiKey, signal, diagnostics)
+  ]);
+  const reasoning = typeof serverInfo?.reasoning_parser === "string" && serverInfo.reasoning_parser !== "";
+  const vision = info.has_image_understanding === true;
+  const entries = modelsRes?.data?.length ? modelsRes.data : [{ id: info.model_path }];
+  const requestCompat = reasoning ? await probeRequestCompat(baseUrl, apiKey, entries[0].id, signal) : {};
+  const samplingParams = samplingParamsFor(info.model_type, reasoning);
+  return {
+    apiType: "sglang",
+    models: entries.map((m) => {
+      const contextWindow = firstNumber(m.max_model_len) ?? 32768;
+      return {
+        id: m.id,
+        name: m.id.split(/[\\/]/).filter(Boolean).pop() ?? m.id,
+        contextWindow,
+        maxTokens: capTokens(contextWindow, reasoning),
+        reasoning,
+        input: vision ? ["text", "image"] : ["text"],
+        ...requestCompat,
+        ...samplingParams ? { samplingParams } : {}
+      };
+    })
+  };
+}
+export async function detectVllm(root, baseUrl, apiKey, signal, diagnostics) {
+  const version = await fetchJson(`${root}/version`, apiKey, signal, diagnostics);
+  if (typeof version?.version !== "string")
+    return null;
+  const modelsRes = await fetchJson(`${baseUrl}/models`, apiKey, signal, diagnostics);
+  const entries = (modelsRes?.data ?? []).filter((m) => typeof m.max_model_len === "number");
+  if (entries.length === 0)
+    return null;
+  return {
+    apiType: "vllm",
+    models: entries.map((m) => ({
+      id: m.id,
+      name: m.id.split("/").pop() ?? m.id,
+      contextWindow: m.max_model_len,
+      maxTokens: capTokens(m.max_model_len),
+      reasoning: false,
+      input: ["text"]
+    }))
+  };
+}
+function firstNumber(...values) {
+  for (const v of values)
+    if (typeof v === "number" && v > 0)
+      return v;
+  return;
+}
+const NINFER_OWNER = "ninfer";
+export function isNinferCards(cards) {
+  return cards.length > 0 && cards.every((m) => m.owned_by === NINFER_OWNER);
+}
+const NINFER_DEFAULT_CONTEXT = 8192;
+const NINFER_CONTEXT_PROBE_TOKENS = 300000;
+const NINFER_PROBE_CHARS_PER_TOKEN = 2;
+export function parseNinferContext(body) {
+  const match = /max_context\s+(\d+)/.exec(body);
+  if (!match)
+    return;
+  const value = Number(match[1]);
+  return Number.isFinite(value) && value > 0 ? value : undefined;
+}
+function acceptedPromptTokens(reply) {
+  if (reply.status !== 200)
+    return;
+  try {
+    const tokens = JSON.parse(reply.body).usage?.prompt_tokens;
+    return typeof tokens === "number" && tokens > 0 ? tokens : undefined;
+  } catch {
+    return;
+  }
+}
+export async function probeNinfer(baseUrl, apiKey, modelId, signal) {
+  const oversized = "x ".repeat(Math.ceil(NINFER_CONTEXT_PROBE_TOKENS * NINFER_PROBE_CHARS_PER_TOKEN / 2));
+  const [context, vision] = await Promise.all([
+    probe(`${baseUrl}/chat/completions`, apiKey, { model: modelId, max_tokens: 1, stream: false, messages: [{ role: "user", content: oversized }] }, signal),
+    probe(`${baseUrl}/responses/input_tokens`, apiKey, {
+      model: modelId,
+      input: [
+        {
+          role: "user",
+          content: [
+            {
+              type: "input_image",
+              image_url: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNk+M9QDwADhgGAWjR9awAAAABJRU5ErkJggg=="
+            }
+          ]
+        }
+      ]
+    }, signal)
+  ]);
+  return {
+    contextWindow: (context && parseNinferContext(context.body)) ?? (context && acceptedPromptTokens(context)) ?? NINFER_DEFAULT_CONTEXT,
+    vision: vision === null ? undefined : vision.status === 200 ? true : /vision_disabled/.test(vision.body) ? false : undefined
+  };
+}
+async function ninferModels(cards, baseUrl, apiKey, signal) {
+  const [measured, compat] = await Promise.all([
+    probeNinfer(baseUrl, apiKey, cards[0].id, signal),
+    probeRequestCompat(baseUrl, apiKey, cards[0].id, signal)
+  ]);
+  const reasoning = Boolean(compat.thinkingLevelMap);
+  return cards.map((card) => ({
+    id: card.id,
+    name: card.name || (card.id.split(/[\\/]/).filter(Boolean).pop() ?? card.id),
+    contextWindow: measured.contextWindow,
+    maxTokens: capTokens(measured.contextWindow, reasoning),
+    reasoning,
+    input: measured.vision ? ["text", "image"] : ["text"],
+    ...compat
+  }));
+}
+const DS4_OWNER = "ds4.c";
+const DS4_THINKING_LEVELS = {
+  off: "none",
+  max: "max"
+};
+export function isDs4Cards(cards) {
+  return cards.length > 0 && cards.every((m) => m.owned_by === DS4_OWNER);
+}
+export async function detectOpenAI(baseUrl, apiKey, signal, diagnostics) {
+  const res = await fetchJson(`${baseUrl}/models`, apiKey, signal, diagnostics);
+  if (!res?.data?.length)
+    return { apiType: "openai", models: [] };
+  if (isNinferCards(res.data)) {
+    return { apiType: "ninfer", models: await ninferModels(res.data, baseUrl, apiKey, signal) };
+  }
+  if (isDs4Cards(res.data)) {
+    return {
+      apiType: "ds4",
+      models: res.data.map((m) => {
+        const contextWindow = firstNumber(m.top_provider?.context_length, m.context_length) ?? 32768;
+        const declaredMax = firstNumber(m.top_provider?.max_completion_tokens);
+        return {
+          id: m.id,
+          name: m.name || m.id,
+          contextWindow,
+          maxTokens: declaredMax !== undefined && declaredMax < contextWindow ? declaredMax : capTokens(contextWindow, true),
+          reasoning: true,
+          input: ["text"],
+          compat: { supportsReasoningEffort: true, supportsDeveloperRole: true },
+          thinkingLevelMap: DS4_THINKING_LEVELS
+        };
+      })
+    };
+  }
+  return {
+    apiType: "openai",
+    models: res.data.map((m) => {
+      const contextWindow = firstNumber(m.max_model_len, m.top_provider?.context_length, m.context_window, m.context_length) ?? 32768;
+      const params = m.supported_parameters ?? [];
+      const modalities = m.architecture?.input_modalities ?? [];
+      const reasoning = params.includes("reasoning_effort") || params.includes("include_reasoning");
+      const declaredMax = firstNumber(m.top_provider?.max_completion_tokens);
+      const maxTokens = declaredMax !== undefined && declaredMax < contextWindow ? declaredMax : capTokens(contextWindow, reasoning);
+      return {
+        id: m.id,
+        name: m.name || (m.id.split("/").pop() ?? m.id),
+        contextWindow,
+        maxTokens,
+        reasoning,
+        input: modalities.includes("image") ? ["text", "image"] : ["text"]
+      };
+    })
+  };
+}
+function summarizeFailure(diagnostics) {
+  const authFailure = diagnostics.find((d) => d.reason === "unauthorized" || d.reason === "forbidden");
+  if (authFailure) {
+    return `Authentication failed (HTTP ${authFailure.status}) — check the API key.`;
+  }
+  if (diagnostics.length > 0 && diagnostics.every((d) => d.reason === "timeout")) {
+    return "Timed out waiting for a response — check the server is running and reachable.";
+  }
+  if (diagnostics.length > 0 && diagnostics.every((d) => d.reason === "timeout" || d.reason === "network-error")) {
+    return "Could not connect to the server — check the URL and that it's running.";
+  }
+  return;
+}
+const CHAIN_TIMEOUT_MS = 8000;
+export async function detectModels(baseUrl, apiKey, signal) {
+  const chainSignal = signal ? AbortSignal.any([signal, AbortSignal.timeout(CHAIN_TIMEOUT_MS)]) : AbortSignal.timeout(CHAIN_TIMEOUT_MS);
+  const root = baseUrl.replace(/\/v1$/, "");
+  const diagnostics = [];
+  const result = await detectMtplx(root, apiKey, chainSignal, diagnostics) ?? await detectOmlx(root, apiKey, chainSignal, diagnostics) ?? await detectLmStudio(root, apiKey, chainSignal, diagnostics) ?? await detectLlamaCpp(root, apiKey, chainSignal, diagnostics) ?? await detectSglang(root, baseUrl, apiKey, chainSignal, diagnostics) ?? await detectOllama(root, apiKey, chainSignal, diagnostics) ?? await detectVllm(root, baseUrl, apiKey, chainSignal, diagnostics) ?? await detectOpenAI(baseUrl, apiKey, chainSignal, diagnostics);
+  if (result.models.length === 0) {
+    const error = summarizeFailure(diagnostics);
+    if (error)
+      return { ...result, error };
+  }
+  return result;
+}