@duckmind/dm-windows-x64 0.61.3 → 0.61.5

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

@@ -0,0 +1,385 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import * as os from "node:os";
+import { detectModels } from "./detect.js";
+import { deleteFromKeychain, isDirectApiKey, keychainCommand, storeInKeychain } from "./keychain.js";
+const SETTINGS_FILE = path.join(os.homedir(), ".dm", "agent", "settings.json");
+const SETTINGS_KEY = "localllm";
+function readSettings() {
+  try {
+    if (!fs.existsSync(SETTINGS_FILE))
+      return { servers: [] };
+    const all = JSON.parse(fs.readFileSync(SETTINGS_FILE, "utf8"));
+    return all[SETTINGS_KEY] ?? { servers: [] };
+  } catch {
+    return { servers: [] };
+  }
+}
+function writeSettings(settings) {
+  let all = {};
+  try {
+    if (fs.existsSync(SETTINGS_FILE)) {
+      all = JSON.parse(fs.readFileSync(SETTINGS_FILE, "utf8"));
+    }
+  } catch {}
+  all[SETTINGS_KEY] = settings;
+  fs.writeFileSync(SETTINGS_FILE, JSON.stringify(all, null, 2), "utf8");
+}
+function generateId() {
+  return Math.random().toString(36).slice(2, 8);
+}
+function toProviderId(server) {
+  const slug = server.name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 32);
+  return `dm-localllm-${slug || server.id}`;
+}
+export function normalizeBaseUrl(raw) {
+  let stripped = raw.trim().replace(/\/+$/, "");
+  if (!/^[a-zA-Z][a-zA-Z0-9+.-]*:\/\//.test(stripped)) {
+    stripped = `http://${stripped}`;
+  }
+  return stripped.endsWith("/v1") ? stripped : `${stripped}/v1`;
+}
+function apiTypeLabel(apiType) {
+  switch (apiType) {
+    case "mtplx":
+      return "MTPLX";
+    case "omlx":
+      return "oMLX";
+    case "lmstudio":
+      return "LM Studio";
+    case "llamacpp":
+      return "llama.cpp";
+    case "ollama":
+      return "Ollama";
+    case "sglang":
+      return "SGLang";
+    case "vllm":
+      return "vLLM";
+    case "ds4":
+      return "ds4";
+    case "ninfer":
+      return "NInfer";
+    case "openai":
+      return "OpenAI-compatible";
+  }
+}
+function formatK(n) {
+  return n >= 1024 ? `${Math.round(n / 1024)}k` : `${n}`;
+}
+function formatBytes(bytes) {
+  return `${(bytes / 1024 ** 3).toFixed(1)}G`;
+}
+export function modelIdsChanged(before, after) {
+  if (before.length !== after.length)
+    return true;
+  const beforeIds = new Set(before.map((m) => m.id));
+  return after.some((m) => !beforeIds.has(m.id));
+}
+function loadedIcon(loaded) {
+  if (loaded === true)
+    return "✓ ";
+  if (loaded === false)
+    return "○ ";
+  return "";
+}
+export function modelsHeading(models) {
+  const reportsLoaded = models.some((m) => m.loaded !== undefined);
+  return reportsLoaded ? "Models:  (✓ = loaded in memory, ○ = will be loaded on first message)" : "Models:";
+}
+export function formatModelLine(m) {
+  const caps = [m.reasoning ? "reasoning" : null, m.input.includes("image") ? "vision" : null].filter((c) => c !== null);
+  const parts = [`ctx ${formatK(m.contextWindow)}`, `max ${formatK(m.maxTokens)}`];
+  if (typeof m.sizeBytes === "number" && m.sizeBytes > 0)
+    parts.push(formatBytes(m.sizeBytes));
+  if (m.quantization)
+    parts.push(m.quantization);
+  parts.push(...caps);
+  return `  • ${loadedIcon(m.loaded)}${m.name}  (${parts.join(", ")})`;
+}
+function registerServer(dm, server) {
+  dm.registerProvider(toProviderId(server), {
+    name: server.name,
+    baseUrl: server.baseUrl,
+    apiKey: server.apiKey || "no-key",
+    api: "openai-completions",
+    models: server.models.map((m) => ({
+      id: m.id,
+      name: m.name,
+      reasoning: m.reasoning,
+      input: m.input,
+      cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+      contextWindow: m.contextWindow,
+      maxTokens: m.maxTokens,
+      compat: {
+        supportsReasoningEffort: m.compat?.supportsReasoningEffort ?? false,
+        supportsDeveloperRole: m.compat?.supportsDeveloperRole ?? false
+      },
+      ...m.thinkingLevelMap ? { thinkingLevelMap: m.thinkingLevelMap } : {},
+      ...m.samplingParams ? { samplingParams: m.samplingParams } : {}
+    }))
+  });
+}
+function unregisterServer(dm, server) {
+  dm.unregisterProvider(toProviderId(server));
+}
+async function removeServer(dm, ctx, server) {
+  const ok = await ctx.ui.confirm(`Remove "${server.name}"?`, "Unregisters the provider and deletes its configuration.");
+  if (!ok)
+    return false;
+  unregisterServer(dm, server);
+  if (os.platform() === "darwin") {
+    await deleteFromKeychain(server.id);
+  }
+  const s = readSettings();
+  s.servers = s.servers.filter((sv) => sv.id !== server.id);
+  writeSettings(s);
+  ctx.ui.notify(`${server.name} removed.`, "info");
+  return true;
+}
+async function runWizard(ctx, existing) {
+  const name = await ctx.ui.input('Step 1/3 - Server name (e.g. "My vLLM", "Ollama", "LM Studio")', existing?.name ?? "");
+  if (!name?.trim())
+    return null;
+  const urlInput = await ctx.ui.input("Step 2/3 - Base URL", existing ? existing.baseUrl.replace(/\/v1$/, "") : "http://localhost:8000");
+  if (!urlInput?.trim())
+    return null;
+  const baseUrl = normalizeBaseUrl(urlInput);
+  const id = existing?.id ?? generateId();
+  const apiKeyInput = await ctx.ui.input("Step 3/3 - API key (leave blank if not required)", existing?.apiKey ?? "");
+  let apiKey = apiKeyInput?.trim() ?? "";
+  if (os.platform() === "darwin" && isDirectApiKey(apiKey)) {
+    const store = await ctx.ui.confirm("Store API key in macOS Keychain?", "Keeps the raw key out of settings.json — it'll be referenced via a !security command instead.");
+    if (store) {
+      try {
+        await storeInKeychain(id, apiKey);
+        apiKey = keychainCommand(id);
+        ctx.ui.notify("API key stored in Keychain.", "info");
+      } catch (err) {
+        ctx.ui.notify(`Failed to store in Keychain, keeping key in settings.json: ${err instanceof Error ? err.message : String(err)}`, "warning");
+      }
+    }
+  }
+  ctx.ui.notify(`Connecting to ${baseUrl} ...`, "info");
+  let result;
+  try {
+    result = await detectModels(baseUrl, apiKey, ctx.signal);
+  } catch (err) {
+    ctx.ui.notify(`Cannot reach server: ${err instanceof Error ? err.message : String(err)}`, "error");
+    return null;
+  }
+  if (result.models.length === 0) {
+    ctx.ui.notify(result.error ?? "Server responded but has no loaded models.", "error");
+    return null;
+  }
+  let selectedApiModels = result.models;
+  if (result.models.length > 1) {
+    const allOption = `All (${result.models.length} models)`;
+    const modelOptions = [allOption, ...result.models.map((m) => m.id)];
+    const picked = await ctx.ui.select(`${result.models.length} models found via ${apiTypeLabel(result.apiType)} - which to enable?`, modelOptions);
+    if (!picked)
+      return null;
+    if (picked !== allOption) {
+      selectedApiModels = result.models.filter((m) => m.id === picked);
+    }
+  }
+  return {
+    id,
+    name: name.trim(),
+    baseUrl,
+    apiKey,
+    apiType: result.apiType,
+    models: selectedApiModels
+  };
+}
+async function editModelCapabilities(dm, ctx, serverId) {
+  const server = readSettings().servers.find((s) => s.id === serverId);
+  if (!server || server.models.length === 0)
+    return;
+  let modelId = server.models[0].id;
+  if (server.models.length > 1) {
+    const picked = await ctx.ui.select("Which model?", server.models.map((m) => m.id));
+    if (!picked)
+      return;
+    modelId = picked;
+  }
+  while (true) {
+    const current = readSettings().servers.find((s) => s.id === serverId)?.models.find((m) => m.id === modelId);
+    if (!current)
+      return;
+    const vision = current.input.includes("image");
+    const temp = current.samplingParams?.temperature;
+    const OPT_VISION = `Vision: ${vision ? "on" : "off"}  (tap to turn ${vision ? "off" : "on"})`;
+    const OPT_REASONING = `Reasoning: ${current.reasoning ? "on" : "off"}  (tap to turn ${current.reasoning ? "off" : "on"})`;
+    const OPT_TEMP = `Temperature: ${temp ?? "server default"}  (tap to change)`;
+    const OPT_DONE = "✓ Done";
+    const picked = await ctx.ui.select(`${current.name} - manual capability override
+Overwritten by the next ↺ Refresh.`, [OPT_VISION, OPT_REASONING, OPT_TEMP, OPT_DONE]);
+    if (!picked || picked === OPT_DONE)
+      break;
+    let nextTemp;
+    if (picked === OPT_TEMP) {
+      const raw = await ctx.ui.input("Temperature (0 - 2, or empty to let the server decide)", temp === undefined ? "" : String(temp));
+      if (raw === undefined)
+        continue;
+      const trimmed = raw.trim();
+      if (trimmed === "") {
+        nextTemp = undefined;
+      } else {
+        const parsed = Number(trimmed);
+        if (!Number.isFinite(parsed) || parsed < 0 || parsed > 2) {
+          ctx.ui.notify("Temperature must be a number between 0 and 2.", "error");
+          continue;
+        }
+        nextTemp = { temperature: parsed };
+      }
+    }
+    const s = readSettings();
+    const sv = s.servers.find((sv) => sv.id === serverId);
+    if (!sv)
+      return;
+    sv.models = sv.models.map((m) => {
+      if (m.id !== modelId)
+        return m;
+      if (picked === OPT_VISION) {
+        return { ...m, input: vision ? ["text"] : ["text", "image"] };
+      }
+      if (picked === OPT_TEMP) {
+        const { samplingParams: _dropped, ...rest } = m;
+        return nextTemp ? { ...rest, samplingParams: nextTemp } : rest;
+      }
+      return { ...m, reasoning: !m.reasoning };
+    });
+    writeSettings(s);
+  }
+  const s = readSettings();
+  const sv = s.servers.find((sv) => sv.id === serverId);
+  if (!sv)
+    return;
+  unregisterServer(dm, server);
+  registerServer(dm, sv);
+  ctx.ui.notify("Capabilities updated.", "info");
+}
+const OPT_REFRESH = "↺ Refresh model list from server";
+const OPT_CAPS = "✎ Edit model capabilities (vision / reasoning / temperature)";
+const OPT_EDIT = "✎ Reconfigure (name / URL / key)";
+const OPT_REMOVE = "✕ Remove this server";
+const OPT_BACK = "← Back";
+async function showServerMenu(dm, ctx, serverId) {
+  while (true) {
+    const server = readSettings().servers.find((s) => s.id === serverId);
+    if (!server)
+      return;
+    const modelSummary = server.models.length === 0 ? "  (no models)" : server.models.map(formatModelLine).join(`
+`);
+    const backend = apiTypeLabel(server.apiType);
+    const picked = await ctx.ui.select(`${server.name}  [${backend}]
+URL: ${server.baseUrl}
+${modelsHeading(server.models)}
+${modelSummary}`, [OPT_REFRESH, ...server.models.length > 0 ? [OPT_CAPS] : [], OPT_EDIT, OPT_REMOVE, OPT_BACK]);
+    if (!picked || picked === OPT_BACK)
+      return;
+    if (picked === OPT_REFRESH) {
+      ctx.ui.notify(`Refreshing ${server.name} ...`, "info");
+      let result;
+      try {
+        result = await detectModels(server.baseUrl, server.apiKey, ctx.signal);
+      } catch (err) {
+        ctx.ui.notify(`Failed: ${err instanceof Error ? err.message : String(err)}`, "error");
+        continue;
+      }
+      if (result.models.length === 0 && result.error) {
+        ctx.ui.notify(`Refresh failed, keeping existing configuration: ${result.error}`, "error");
+        continue;
+      }
+      const updated = { ...server, apiType: result.apiType, models: result.models };
+      const modelsChanged = modelIdsChanged(server.models, updated.models);
+      const s = readSettings();
+      s.servers = s.servers.map((sv) => sv.id === serverId ? updated : sv);
+      writeSettings(s);
+      unregisterServer(dm, server);
+      registerServer(dm, updated);
+      ctx.ui.notify(`${server.name} (${apiTypeLabel(result.apiType)}): ${result.models.length} model(s) - ${result.models.map((m) => m.name).join(", ")}`, "info");
+      if (modelsChanged && updated.models.length === 1) {
+        await offerModelSwitch(dm, ctx, updated, updated.models[0]);
+      }
+      continue;
+    }
+    if (picked === OPT_CAPS) {
+      await editModelCapabilities(dm, ctx, serverId);
+      continue;
+    }
+    if (picked === OPT_EDIT) {
+      const updated = await runWizard(ctx, server);
+      if (!updated)
+        continue;
+      const s = readSettings();
+      s.servers = s.servers.map((sv) => sv.id === serverId ? updated : sv);
+      writeSettings(s);
+      unregisterServer(dm, server);
+      registerServer(dm, updated);
+      ctx.ui.notify(`${updated.name} updated.` + (updated.models.length > 1 ? " Switch models with /model." : ""), "info");
+      if (updated.models.length === 1) {
+        await offerModelSwitch(dm, ctx, updated, updated.models[0]);
+      }
+      return;
+    }
+    if (picked === OPT_REMOVE) {
+      if (await removeServer(dm, ctx, server))
+        return;
+      continue;
+    }
+  }
+}
+async function offerModelSwitch(dm, ctx, server, model) {
+  const switchNow = await ctx.ui.confirm(`Switch to ${model.name} now?`, `Makes it the active model for this session. You can always change it later with /model.`);
+  if (!switchNow)
+    return;
+  const resolved = ctx.modelRegistry.find(toProviderId(server), model.id);
+  if (!resolved) {
+    ctx.ui.notify("Couldn't find the newly registered model — switch with /model instead.", "warning");
+    return;
+  }
+  const ok = await dm.setModel(resolved);
+  if (!ok) {
+    ctx.ui.notify("Couldn't switch — no API key available for this model.", "warning");
+  }
+}
+const OPT_ADD = "＋ Add server";
+async function showMainMenu(dm, ctx) {
+  while (true) {
+    const { servers } = readSettings();
+    const serverLabels = servers.map((s) => `${s.name}  [${apiTypeLabel(s.apiType)}]  (${s.baseUrl})  ${s.models.length} model(s)`);
+    const picked = await ctx.ui.select(servers.length === 0 ? "LocalLLM - no servers configured" : `LocalLLM - ${servers.length} server(s)`, [...serverLabels, OPT_ADD]);
+    if (!picked)
+      return;
+    if (picked === OPT_ADD) {
+      const server = await runWizard(ctx);
+      if (!server)
+        continue;
+      const s = readSettings();
+      s.servers.push(server);
+      writeSettings(s);
+      registerServer(dm, server);
+      ctx.ui.notify(`${server.name} added - ${server.models.length} model(s): ${server.models.map((m) => m.name).join(", ")}.` + (server.models.length > 1 ? " Switch with /model." : ""), "info");
+      if (server.models.length === 1) {
+        await offerModelSwitch(dm, ctx, server, server.models[0]);
+      }
+      continue;
+    }
+    const idx = serverLabels.indexOf(picked);
+    if (idx >= 0) {
+      await showServerMenu(dm, ctx, servers[idx].id);
+    }
+  }
+}
+export default function dm_localllm_provider_default(dm) {
+  for (const server of readSettings().servers) {
+    registerServer(dm, server);
+  }
+  dm.registerCommand("localllm", {
+    description: "Manage LocalLLM providers - wizard-based setup for any OpenAI-compatible local server",
+    async handler(_args, ctx) {
+      await showMainMenu(dm, ctx);
+    }
+  });
+}

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

@@ -0,0 +1,149 @@
+import { describe, expect, it } from "vitest";
+import { formatModelLine, modelIdsChanged, modelsHeading, normalizeBaseUrl } from "./index.js";
+describe("normalizeBaseUrl", () => {
+  it("appends /v1 when missing", () => {
+    expect(normalizeBaseUrl("http://localhost:8000")).toBe("http://localhost:8000/v1");
+  });
+  it("leaves an existing /v1 suffix alone", () => {
+    expect(normalizeBaseUrl("http://localhost:8000/v1")).toBe("http://localhost:8000/v1");
+  });
+  it("strips trailing slashes before checking the suffix", () => {
+    expect(normalizeBaseUrl("http://localhost:8000/v1/")).toBe("http://localhost:8000/v1");
+    expect(normalizeBaseUrl("http://localhost:8000/")).toBe("http://localhost:8000/v1");
+  });
+  it("defaults to http:// for a bare host:port with no scheme", () => {
+    expect(normalizeBaseUrl("localhost:11434")).toBe("http://localhost:11434/v1");
+    expect(normalizeBaseUrl("192.168.1.50:8000")).toBe("http://192.168.1.50:8000/v1");
+  });
+  it("preserves an explicit https:// scheme", () => {
+    expect(normalizeBaseUrl("https://my.server.com")).toBe("https://my.server.com/v1");
+  });
+  it("trims surrounding whitespace", () => {
+    expect(normalizeBaseUrl("  localhost:11434  ")).toBe("http://localhost:11434/v1");
+  });
+});
+describe("formatModelLine", () => {
+  it("formats context window and max tokens in k, with no capability tags", () => {
+    expect(formatModelLine({
+      id: "m1",
+      name: "some-model",
+      contextWindow: 65536,
+      maxTokens: 8192,
+      reasoning: false,
+      input: ["text"]
+    })).toBe("  • some-model  (ctx 64k, max 8k)");
+  });
+  it("appends reasoning and vision tags when present", () => {
+    expect(formatModelLine({
+      id: "m1",
+      name: "vision-model",
+      contextWindow: 65536,
+      maxTokens: 8192,
+      reasoning: true,
+      input: ["text", "image"]
+    })).toBe("  • vision-model  (ctx 64k, max 8k, reasoning, vision)");
+  });
+  it("shows sub-1024 windows without a k suffix", () => {
+    expect(formatModelLine({
+      id: "m1",
+      name: "tiny",
+      contextWindow: 512,
+      maxTokens: 256,
+      reasoning: false,
+      input: ["text"]
+    })).toBe("  • tiny  (ctx 512, max 256)");
+  });
+  it("prefixes a checkmark when loaded is true", () => {
+    expect(formatModelLine({
+      id: "m1",
+      name: "m",
+      contextWindow: 4096,
+      maxTokens: 2048,
+      reasoning: false,
+      input: ["text"],
+      loaded: true
+    })).toBe("  • ✓ m  (ctx 4k, max 2k)");
+  });
+  it("prefixes a hollow circle when loaded is false", () => {
+    expect(formatModelLine({
+      id: "m1",
+      name: "m",
+      contextWindow: 4096,
+      maxTokens: 2048,
+      reasoning: false,
+      input: ["text"],
+      loaded: false
+    })).toBe("  • ○ m  (ctx 4k, max 2k)");
+  });
+  it("omits the loaded prefix entirely when loaded is unknown", () => {
+    expect(formatModelLine({
+      id: "m1",
+      name: "m",
+      contextWindow: 4096,
+      maxTokens: 2048,
+      reasoning: false,
+      input: ["text"]
+    })).toBe("  • m  (ctx 4k, max 2k)");
+  });
+  it("shows size and quantization when present, in order before capability tags", () => {
+    expect(formatModelLine({
+      id: "m1",
+      name: "m",
+      contextWindow: 4096,
+      maxTokens: 2048,
+      reasoning: true,
+      input: ["text", "image"],
+      sizeBytes: 4912898304,
+      quantization: "Q4_K_M"
+    })).toBe("  • m  (ctx 4k, max 2k, 4.6G, Q4_K_M, reasoning, vision)");
+  });
+});
+describe("modelIdsChanged", () => {
+  const baseModel = {
+    id: "m1",
+    name: "m1",
+    contextWindow: 4096,
+    maxTokens: 2048,
+    reasoning: false,
+    input: ["text"]
+  };
+  it("is false when the same single model is refreshed with new metadata", () => {
+    expect(modelIdsChanged([baseModel], [{ ...baseModel, contextWindow: 8192 }])).toBe(false);
+  });
+  it("is false when the same set of models comes back in a different order", () => {
+    const a = { ...baseModel, id: "a" };
+    const b = { ...baseModel, id: "b" };
+    expect(modelIdsChanged([a, b], [b, a])).toBe(false);
+  });
+  it("is true when the model count changes", () => {
+    const a = { ...baseModel, id: "a" };
+    const b = { ...baseModel, id: "b" };
+    expect(modelIdsChanged([a], [a, b])).toBe(true);
+  });
+  it("is true when a same-count refresh swaps in a different model id", () => {
+    const a = { ...baseModel, id: "a" };
+    const c = { ...baseModel, id: "c" };
+    expect(modelIdsChanged([a], [c])).toBe(true);
+  });
+  it("is false for two empty lists", () => {
+    expect(modelIdsChanged([], [])).toBe(false);
+  });
+});
+describe("modelsHeading", () => {
+  const baseModel = {
+    id: "m1",
+    name: "m1",
+    contextWindow: 4096,
+    maxTokens: 2048,
+    reasoning: false,
+    input: ["text"]
+  };
+  it("adds the loaded-state legend when at least one model reports it", () => {
+    expect(modelsHeading([{ ...baseModel, loaded: true }])).toBe("Models:  (✓ = loaded in memory, ○ = will be loaded on first message)");
+    expect(modelsHeading([{ ...baseModel }, { ...baseModel, loaded: false }])).toBe("Models:  (✓ = loaded in memory, ○ = will be loaded on first message)");
+  });
+  it("omits the legend when no model reports loaded state", () => {
+    expect(modelsHeading([baseModel])).toBe("Models:");
+    expect(modelsHeading([])).toBe("Models:");
+  });
+});

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

@@ -0,0 +1,33 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+const execFileAsync = promisify(execFile);
+const KEYCHAIN_SERVICE = "dm-localllm-provider";
+export function isDirectApiKey(key) {
+  return key.length > 0 && !key.startsWith("!") && !key.startsWith("$");
+}
+export function keychainCommand(account) {
+  return `!security find-generic-password -s '${KEYCHAIN_SERVICE}' -a '${account}' -w`;
+}
+export async function storeInKeychain(account, rawKey) {
+  await deleteFromKeychain(account);
+  await execFileAsync("security", [
+    "add-generic-password",
+    "-s",
+    KEYCHAIN_SERVICE,
+    "-a",
+    account,
+    "-w",
+    rawKey
+  ]);
+}
+export async function deleteFromKeychain(account) {
+  try {
+    await execFileAsync("security", [
+      "delete-generic-password",
+      "-s",
+      KEYCHAIN_SERVICE,
+      "-a",
+      account
+    ]);
+  } catch {}
+}

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

@@ -0,0 +1,61 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+const execFileCalls = [];
+let nextShouldFail = false;
+vi.mock("node:child_process", () => ({
+  execFile: (file, args, cb) => {
+    execFileCalls.push({ file, args });
+    if (nextShouldFail) {
+      cb(new Error("no such keychain item"));
+    } else {
+      cb(null, "", "");
+    }
+  }
+}));
+const { isDirectApiKey, keychainCommand, storeInKeychain, deleteFromKeychain } = await import("./keychain.js");
+afterEach(() => {
+  execFileCalls.length = 0;
+  nextShouldFail = false;
+});
+describe("isDirectApiKey", () => {
+  it("treats a plain string as a direct key", () => {
+    expect(isDirectApiKey("sk-abc123")).toBe(true);
+  });
+  it("rejects empty, !command, and $ENV_VAR forms", () => {
+    expect(isDirectApiKey("")).toBe(false);
+    expect(isDirectApiKey("!security find-generic-password -w")).toBe(false);
+    expect(isDirectApiKey("$MY_API_KEY")).toBe(false);
+  });
+});
+describe("keychainCommand", () => {
+  it("formats a !security find-generic-password command for the given account", () => {
+    expect(keychainCommand("abc123")).toBe("!security find-generic-password -s 'dm-localllm-provider' -a 'abc123' -w");
+  });
+});
+describe("storeInKeychain", () => {
+  it("deletes any existing entry, then adds the key as a single argv element", async () => {
+    await storeInKeychain("abc123", "sk-with-a-'-quote-and-$(dangerous)-chars");
+    expect(execFileCalls).toHaveLength(2);
+    expect(execFileCalls[0]).toEqual({
+      file: "security",
+      args: ["delete-generic-password", "-s", "dm-localllm-provider", "-a", "abc123"]
+    });
+    expect(execFileCalls[1]).toEqual({
+      file: "security",
+      args: [
+        "add-generic-password",
+        "-s",
+        "dm-localllm-provider",
+        "-a",
+        "abc123",
+        "-w",
+        "sk-with-a-'-quote-and-$(dangerous)-chars"
+      ]
+    });
+  });
+});
+describe("deleteFromKeychain", () => {
+  it("swallows errors when there is no existing entry", async () => {
+    nextShouldFail = true;
+    await expect(deleteFromKeychain("abc123")).resolves.toBeUndefined();
+  });
+});

package/extensions/dm-localllm-provider/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "dm-localllm-provider",
+  "version": "0.5.0",
+  "description": "Wizard-based setup for local OpenAI-compatible LLM servers in DM",
+  "type": "module",
+  "main": "index.js",
+  "license": "MIT",
+  "author": "Eric Qian",
+  "keywords": [
+    "duckmind",
+    "dm",
+    "dm-package",
+    "dm-extension",
+    "llm",
+    "vllm",
+    "ollama",
+    "lm-studio"
+  ],
+  "dm": {
+    "extensions": [
+      "./index.js"
+    ]
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@duckmind/dm-windows-x64",
-  "version": "0.61.3",
+  "version": "0.61.5",
   "description": "DuckMind (dm) binary payload for windows x64",
   "license": "MIT",
   "os": [