@megen-lebar/dsh-reasoning-effort 0.2.0

package/lib/index.js

@@ -0,0 +1,565 @@
+/**
+ * dsh-reasoning-effort — host half.
+ *
+ * Sidebar "思考强度" configurator for the DSH Web GUI. DSH stores every
+ * third-party provider's reasoning capability in the `llm-pi-ai` settings
+ * namespace (same section as settings.yaml's `llm-pi-ai:` block), validated by
+ * dsh-llm-pi-ai's `assertServiceable` and hot-reloaded into the adapter on the
+ * next request. This plugin exposes a tiny loopback-only HTTP surface that
+ * (a) reads the current configuration plus each model's *official* thinking
+ * levels from the pi-ai built-in catalog, and (b) writes user choices back
+ * through the settings service — no hand-edited YAML.
+ *
+ * Capabilities (loopback-only HTTP, same-origin with the web shell):
+ *   - list providers/models with current reasoningEfforts + official levels
+ *   - save a model's reasoningEfforts (+ optional route default / compat)
+ *   - save/remove a provider-level default reasoning level
+ *
+ * Robustness: never throws out of `apply` (a throwing plugin kills the whole
+ * web boot). Missing settings service or missing pi-ai dependency downgrade to
+ * a read-only list / manual fallback, never a crash.
+ * @module @megen-lebar/dsh-reasoning-effort
+ */
+
+import { readFileSync } from "node:fs";
+import { createRequire } from "node:module";
+import { dirname, join } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+
+const NAME = "reasoning-effort";
+const API_PREFIX = "/api/dsh-reasoning";
+const NS = "llm-pi-ai";
+
+const LEVELS = ["off", "minimal", "low", "medium", "high", "xhigh", "max"];
+const SUPPORTED_THINKING_FORMATS = ["openai", "deepseek", "openrouter", "together", "zai", "qwen", "string-thinking", "ant-ling"];
+
+// ---- official thinking-level catalog ----
+// Prefer the pi-ai catalog bundled with the running DSH installation. The
+// plugin snapshot remains an offline fallback for layouts where an out-of-tree
+// linked package cannot resolve DSH's private dependency tree.
+let officialData;
+function officialDataMap() {
+  if (officialData === undefined) {
+    try {
+      const file = join(dirname(fileURLToPath(import.meta.url)), "official-levels.json");
+      const raw = JSON.parse(readFileSync(file, "utf8"));
+      officialData = raw && typeof raw === "object" ? raw : {};
+    } catch {
+      officialData = {};
+    }
+  }
+  return officialData;
+}
+
+let runtimeCatalogPromise;
+async function runtimeCatalog() {
+  if (runtimeCatalogPromise === undefined) {
+    runtimeCatalogPromise = (async () => {
+      try {
+        const req = createRequire(import.meta.url);
+        let entry;
+        try {
+          entry = req.resolve("@earendil-works/pi-ai/providers/all");
+        } catch {
+          const roots = [
+            typeof process.resourcesPath === "string" ? process.resourcesPath : undefined,
+            process.argv[1] ? dirname(process.argv[1]) : undefined,
+            dirname(dirname(process.execPath)),
+          ].filter(Boolean);
+          for (const root of roots) {
+            const candidate = join(root, "runtime", "node_modules", "@earendil-works", "pi-ai", "dist", "providers", "all.js");
+            try {
+              readFileSync(candidate, "utf8");
+              entry = candidate;
+              break;
+            } catch {}
+          }
+        }
+        if (!entry) return undefined;
+        const piAi = await import(pathToFileURL(entry).href);
+        if (typeof piAi.getBuiltinProviders !== "function" || typeof piAi.getBuiltinModels !== "function") return undefined;
+        return {
+          generatedAt: typeof piAi.getBuiltinModelDataGeneratedAt === "function" ? piAi.getBuiltinModelDataGeneratedAt() : undefined,
+          providers: piAi.getBuiltinProviders(),
+          getModels: piAi.getBuiltinModels,
+        };
+      } catch {
+        return undefined;
+      }
+    })();
+  }
+  return runtimeCatalogPromise;
+}
+
+// ---- tiny helpers ----
+function isLoopbackRequest(request) {
+  const address = request.socket?.remoteAddress;
+  if (address !== "127.0.0.1" && address !== "::1" && address !== "::ffff:127.0.0.1") return false;
+  const host = request.headers?.host;
+  if (typeof host !== "string") return false;
+  let hostUrl;
+  try {
+    hostUrl = new URL("http://" + host);
+  } catch {
+    return false;
+  }
+  if (hostUrl.hostname !== "127.0.0.1" && hostUrl.hostname !== "localhost" && hostUrl.hostname !== "[::1]") return false;
+  if (request.headers["sec-fetch-site"] === "cross-site") return false;
+  const origin = request.headers.origin;
+  if (origin === undefined) return true;
+  try {
+    return new URL(origin).host === hostUrl.host;
+  } catch {
+    return false;
+  }
+}
+
+function writeJson(res, status, body) {
+  const payload = JSON.stringify(body);
+  res.writeHead(status, {
+    "content-type": "application/json; charset=utf-8",
+    "referrer-policy": "no-referrer",
+  });
+  res.end(payload);
+}
+
+async function readJsonBody(req) {
+  const chunks = [];
+  let size = 0;
+  for await (const chunk of req) {
+    size += chunk.length;
+    if (size > 256 * 1024) return undefined;
+    chunks.push(chunk);
+  }
+  try {
+    const parsed = JSON.parse(Buffer.concat(chunks).toString("utf8"));
+    return parsed !== null && typeof parsed === "object" ? parsed : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+// ---- official catalog lookup (live pi-ai catalog first, bundled fallback) ----
+function levelsFromRuntimeModel(model) {
+  if (!model || model.reasoning !== true) return [];
+  const map = model.thinkingLevelMap && typeof model.thinkingLevelMap === "object" ? model.thinkingLevelMap : {};
+  const levels = [];
+  for (const level of LEVELS) {
+    const mapped = map[level];
+    if (mapped === null) continue;
+    if ((level === "xhigh" || level === "max") && mapped === undefined) continue;
+    levels.push({ level, wire: mapped === undefined ? (level === "off" ? null : level) : mapped });
+  }
+  return levels;
+}
+
+function modelNameKey(value) {
+  return typeof value === "string" ? value.trim().toLowerCase() : "";
+}
+
+function preferredProviders(modelId, modelName) {
+  const key = modelNameKey(modelId + " " + (modelName || ""));
+  if (/(^|[\s/_-])(kimi|k3)([\s/_.-]|$)/.test(key)) return ["moonshotai-cn", "moonshotai", "kimi-coding"];
+  if (/(^|[\s/_-])deepseek([\s/_.-]|$)/.test(key)) return ["deepseek"];
+  if (/(^|[\s/_-])glm([\s/_.-]|$)/.test(key)) return ["zai", "zai-coding-cn"];
+  if (/(^|[\s/_-])qwen([\s/_.-]|$)/.test(key)) return ["qwen-token-plan-cn", "qwen-token-plan"];
+  if (/(^|[\s/_-])minimax([\s/_.-]|$)/.test(key)) return ["minimax-cn", "minimax"];
+  if (/(^|[\s/_-])(gpt|o[134])([\s/_.-]|$)/.test(key)) return ["openai", "openai-codex", "azure-openai-responses"];
+  if (/(^|[\s/_-])claude([\s/_.-]|$)/.test(key)) return ["anthropic"];
+  return [];
+}
+
+function selectRuntimeModel(catalog, providerId, modelId, modelName) {
+  if (!catalog) return undefined;
+  const exactProvider = catalog.getModels(providerId).find((model) => model.id === modelId);
+  if (exactProvider) return { model: exactProvider, provider: providerId, match: "provider" };
+
+  const idMatches = [];
+  const nameMatches = [];
+  const wantedName = modelNameKey(modelName);
+  for (const provider of catalog.providers) {
+    for (const model of catalog.getModels(provider)) {
+      if (model.id === modelId) idMatches.push({ model, provider, match: "id" });
+      else if (wantedName && modelNameKey(model.name) === wantedName) nameMatches.push({ model, provider, match: "name" });
+    }
+  }
+  if (idMatches.length === 1) return idMatches[0];
+  if (idMatches.length > 1) {
+    for (const preferred of preferredProviders(modelId, modelName)) {
+      const match = idMatches.find((candidate) => candidate.provider === preferred);
+      if (match) return match;
+    }
+    const sameName = idMatches.find((candidate) => modelNameKey(candidate.model.name) === wantedName);
+    return sameName || idMatches[0];
+  }
+  return nameMatches.length === 1 ? nameMatches[0] : undefined;
+}
+
+function bundledOfficialLevels(providerId, modelId, modelName) {
+  const data = officialDataMap();
+  let entry = data[modelId];
+  if (!entry && modelName) entry = data[modelName];
+  if (!entry) return { found: false, reasoning: false, levels: [] };
+
+  const map = entry.levels && typeof entry.levels === "object" ? entry.levels : {};
+  const levels = [];
+  for (const level of LEVELS) {
+    if (Object.prototype.hasOwnProperty.call(map, level) && (entry.reasoning === true || level !== "off")) {
+      levels.push({ level, wire: map[level] });
+    }
+  }
+  return {
+    found: true,
+    reasoning: entry.reasoning === true,
+    thinkingFormat: entry.thinkingFormat,
+    provider: entry.provider,
+    match: entry.provider === providerId ? "provider" : "fallback",
+    source: "bundled",
+    levels,
+  };
+}
+
+function officialLevels(catalog, providerId, modelId, modelName) {
+  const selected = selectRuntimeModel(catalog, providerId, modelId, modelName);
+  if (!selected) return bundledOfficialLevels(providerId, modelId, modelName);
+  const model = selected.model;
+  return {
+    found: true,
+    reasoning: model.reasoning === true,
+    thinkingFormat: model.compat && model.compat.thinkingFormat,
+    provider: selected.provider,
+    match: selected.match,
+    source: "runtime",
+    levels: levelsFromRuntimeModel(model),
+  };
+}
+
+// ---- build directory from the settings namespace ----
+function providersOf(value) {
+  const providers = value && typeof value === "object" ? value.providers : undefined;
+  return providers && typeof providers === "object" ? providers : {};
+}
+
+async function buildList(settings) {
+  let descriptor;
+  let value;
+  let registered = false;
+  if (settings) {
+    try {
+      const list = settings.describe ? settings.describe() : undefined;
+      const hit = list && list.find((d) => d.ns === NS);
+      if (hit) {
+        registered = true;
+        descriptor = { revision: hit.revision };
+        value = hit.value;
+      }
+    } catch {
+      registered = false;
+    }
+  }
+
+  const catalog = await runtimeCatalog();
+  const catalogProviders = new Set(catalog ? catalog.providers : []);
+  const providers = [];
+  const rawProviders = providersOf(value);
+  for (const providerId of Object.keys(rawProviders)) {
+    const profile = rawProviders[providerId];
+    if (!profile || typeof profile !== "object") continue;
+
+    const configuredModels = Array.isArray(profile.models) ? profile.models : [];
+    const overrides = profile.modelOverrides && typeof profile.modelOverrides === "object" ? profile.modelOverrides : {};
+    const useCatalog = configuredModels.length === 0 && catalogProviders.has(providerId);
+    const models = useCatalog ? catalog.getModels(providerId) : configuredModels;
+    const modelRows = [];
+    for (let i = 0; i < models.length; i++) {
+      const base = models[i];
+      if (!base || typeof base !== "object" || typeof base.id !== "string") continue;
+      const override = useCatalog && overrides[base.id] && typeof overrides[base.id] === "object" ? overrides[base.id] : undefined;
+      const model = override ? { ...base, ...override } : base;
+      const official = officialLevels(catalog, providerId, model.id, model.name);
+      modelRows.push({
+        index: i,
+        id: model.id,
+        name: model.name !== undefined ? model.name : model.id,
+        storage: useCatalog ? "override" : "models",
+        current: { reasoningEfforts: model.reasoningEfforts },
+        official,
+      });
+    }
+    providers.push({
+      id: providerId,
+      displayName: profile.displayName !== undefined ? profile.displayName : providerId,
+      api: profile.api,
+      reasoning: profile.reasoning,
+      compat: profile.compat,
+      catalogProvider: catalogProviders.has(providerId),
+      models: modelRows,
+    });
+  }
+  return {
+    namespace: NS,
+    registered,
+    revision: descriptor ? descriptor.revision : undefined,
+    catalogAvailable: catalog !== undefined || Object.keys(officialDataMap()).length > 0,
+    catalogSource: catalog ? "runtime" : "bundled",
+    catalogGeneratedAt: catalog && catalog.generatedAt,
+    providers,
+    levels: LEVELS,
+    thinkingFormats: SUPPORTED_THINKING_FORMATS,
+  };
+}
+
+// ---- mutate op builders ----
+function assertValidLevelInput(reasoningEfforts) {
+  // `false` is the llm-pi-ai schema's explicit non-reasoning/off-only mode.
+  if (reasoningEfforts === false) return false;
+  if (!reasoningEfforts || typeof reasoningEfforts !== "object") {
+    throw new Error("reasoningEfforts must be an object or false");
+  }
+  const declared = [];
+  for (const level of Object.keys(reasoningEfforts)) {
+    if (!LEVELS.includes(level)) throw new Error("unknown thinking level: " + level);
+    const wire = reasoningEfforts[level];
+    if (level === "off") {
+      if (wire !== null && wire !== undefined) throw new Error('"off" only accepts null (no thinking)');
+      continue;
+    }
+    if (wire === null || wire === undefined) {
+      throw new Error('only "off" may have an empty wire value; level "' + level + '" needs a wire spelling');
+    }
+    if (typeof wire !== "string" || wire.length === 0) {
+      throw new Error('level "' + level + '" wire must be a non-empty string');
+    }
+    declared.push(level);
+  }
+  if (declared.length === 0) {
+    throw new Error("reasoningEfforts offers no level beyond off; declare at least one thinking level");
+  }
+  const normalized = { off: null };
+  for (const level of LEVELS) {
+    if (level === "off") continue;
+    const wire = reasoningEfforts[level];
+    if (wire !== undefined && wire !== null) normalized[level] = wire;
+  }
+  return normalized;
+}
+
+// ---- handlers ----
+function makeHandlers(getSettings) {
+  const settings = () => getSettings();
+
+  async function list() {
+    return buildList(settings());
+  }
+
+  async function saveModel(body) {
+    const svc = settings();
+    if (!svc || typeof svc.mutate !== "function") {
+      throw new Error("settings service is unavailable; cannot write");
+    }
+    const provider = typeof body.provider === "string" ? body.provider : undefined;
+    const modelIndex = Number.isInteger(body.modelIndex) ? body.modelIndex : undefined;
+    const modelId = typeof body.modelId === "string" ? body.modelId : undefined;
+    if (!provider || (modelIndex === undefined && !modelId)) {
+      throw new Error("provider and model identity are required");
+    }
+    const reasoningEfforts = assertValidLevelInput(body.reasoningEfforts);
+
+    let desc;
+    try {
+      desc = svc.describe().find((d) => d.ns === NS);
+    } catch {
+      desc = undefined;
+    }
+    const revision = desc ? desc.revision : undefined;
+    const value = desc ? desc.value : undefined;
+    const userProfile = desc && desc.user && desc.user.providers && desc.user.providers[provider];
+    const resolvedProfile = value && value.providers && value.providers[provider];
+    if (!userProfile && !resolvedProfile) throw new Error(`unknown provider "${provider}"`);
+
+    const ops = [];
+    const storage = body.storage === "override" ? "override" : "models";
+    if (storage === "override") {
+      if (!modelId) throw new Error("catalog model id is required");
+      const catalog = await runtimeCatalog();
+      if (!catalog || !catalog.getModels(provider).some((model) => model.id === modelId)) {
+        throw new Error(`provider "${provider}" has no catalog model "${modelId}"`);
+      }
+      ops.push({
+        op: "set",
+        path: ["providers", provider, "modelOverrides", modelId, "reasoningEfforts"],
+        value: reasoningEfforts,
+      });
+    } else {
+      const source =
+        userProfile && Array.isArray(userProfile.models)
+          ? userProfile.models
+          : (resolvedProfile && Array.isArray(resolvedProfile.models) ? resolvedProfile.models : undefined);
+      if (!source) throw new Error(`provider "${provider}" has no configured model list`);
+      const models = source.map((model) => ({ ...model }));
+      let targetIndex = modelId ? models.findIndex((model) => model && model.id === modelId) : modelIndex;
+      if (targetIndex < 0 || targetIndex >= models.length) throw new Error(`model "${modelId || modelIndex}" no longer exists; refresh and retry`);
+      models[targetIndex] = { ...models[targetIndex], reasoningEfforts };
+      ops.push({ op: "set", path: ["providers", provider, "models"], value: models });
+    }
+
+    // Model-only off must not erase shared provider defaults or transport settings.
+    if (reasoningEfforts !== false) {
+      const defaultReasoning = body.defaultReasoning;
+      if (defaultReasoning !== undefined) {
+        if (defaultReasoning === null || defaultReasoning === "") {
+          ops.push({ op: "unset", path: ["providers", provider, "reasoning"] });
+        } else {
+          if (!LEVELS.includes(defaultReasoning)) throw new Error("invalid default reasoning level");
+          if (defaultReasoning !== "off" && !Object.prototype.hasOwnProperty.call(reasoningEfforts, defaultReasoning)) {
+            throw new Error(`default reasoning level "${defaultReasoning}" is not enabled for this model`);
+          }
+          ops.push({ op: "set", path: ["providers", provider, "reasoning"], value: defaultReasoning });
+        }
+      }
+
+      const compat = body.compat;
+      if (compat && typeof compat === "object") {
+        const tf = compat.thinkingFormat;
+        if (tf !== undefined) {
+          if (tf === null || tf === "") ops.push({ op: "unset", path: ["providers", provider, "compat", "thinkingFormat"] });
+          else {
+            if (!SUPPORTED_THINKING_FORMATS.includes(tf)) throw new Error("invalid thinkingFormat");
+            ops.push({ op: "set", path: ["providers", provider, "compat", "thinkingFormat"], value: tf });
+          }
+        }
+        if (compat.supportsReasoningEffort === null || compat.supportsReasoningEffort === "") {
+          ops.push({ op: "unset", path: ["providers", provider, "compat", "supportsReasoningEffort"] });
+        } else if (typeof compat.supportsReasoningEffort === "boolean") {
+          ops.push({ op: "set", path: ["providers", provider, "compat", "supportsReasoningEffort"], value: compat.supportsReasoningEffort });
+        }
+      }
+    }
+
+    try {
+      await svc.mutate(NS, ops, revision);
+    } catch (error) {
+      if (error && error.code === "SETTINGS_CONFLICT") {
+        const err = new Error("configuration changed elsewhere; refresh and retry");
+        err.conflict = true;
+        throw err;
+      }
+      throw error;
+    }
+    return { saved: true, offOnly: reasoningEfforts === false };
+  }
+
+  async function saveProviderDefault(body) {
+    const svc = settings();
+    if (!svc || typeof svc.mutate !== "function") throw new Error("settings service is unavailable");
+    const provider = typeof body.provider === "string" ? body.provider : undefined;
+    if (!provider) throw new Error("provider is required");
+    let revision;
+    try {
+      const desc = svc.describe().find((d) => d.ns === NS);
+      revision = desc ? desc.revision : undefined;
+    } catch {
+      revision = undefined;
+    }
+    const level = body.reasoning;
+    const ops =
+      level === null || level === ""
+        ? [{ op: "unset", path: ["providers", provider, "reasoning"] }]
+        : (LEVELS.includes(level)
+            ? [{ op: "set", path: ["providers", provider, "reasoning"], value: level }]
+            : (() => { throw new Error("invalid reasoning level"); })());
+    await svc.mutate(NS, ops, revision);
+    return { saved: true };
+  }
+
+  return { list, saveModel, saveProviderDefault };
+}
+
+const inject = ["webServer"];
+export { inject };
+export { NAME as name };
+export { makeHandlers };
+
+function apply(ctx) {
+  const getSettings = () => {
+    try {
+      return ctx.get("settings");
+    } catch {
+      return undefined;
+    }
+  };
+  const handlers = makeHandlers(getSettings);
+
+  const guard = (req, res) => {
+    if (!isLoopbackRequest(req)) {
+      writeJson(res, 403, { ok: false, code: "forbidden", error: "loopback only" });
+      return false;
+    }
+    if (req.method !== "POST") {
+      writeJson(res, 405, { ok: false, code: "method", error: "POST only" });
+      return false;
+    }
+    return true;
+  };
+
+  const routes = [
+    {
+      kind: "exact",
+      path: API_PREFIX + "/list",
+      handler: async (req, res) => {
+        if (!guard(req, res)) return;
+        try {
+          const value = await handlers.list();
+          writeJson(res, 200, { ok: true, value });
+        } catch (error) {
+          writeJson(res, 500, { ok: false, code: "internal", error: error instanceof Error ? error.message : String(error) });
+        }
+      },
+    },
+    {
+      kind: "exact",
+      path: API_PREFIX + "/save-model",
+      handler: async (req, res) => {
+        if (!guard(req, res)) return;
+        const body = await readJsonBody(req);
+        if (body === undefined) {
+          writeJson(res, 400, { ok: false, code: "bad-request", error: "invalid JSON body" });
+          return;
+        }
+        try {
+          const value = await handlers.saveModel(body);
+          writeJson(res, 200, { ok: true, value });
+        } catch (error) {
+          const status = error && error.conflict ? 409 : 400;
+          writeJson(res, status, { ok: false, code: error && error.conflict ? "conflict" : "rejected", error: error instanceof Error ? error.message : String(error) });
+        }
+      },
+    },
+    {
+      kind: "exact",
+      path: API_PREFIX + "/save-provider-default",
+      handler: async (req, res) => {
+        if (!guard(req, res)) return;
+        const body = await readJsonBody(req);
+        if (body === undefined) {
+          writeJson(res, 400, { ok: false, code: "bad-request", error: "invalid JSON body" });
+          return;
+        }
+        try {
+          const value = await handlers.saveProviderDefault(body);
+          writeJson(res, 200, { ok: true, value });
+        } catch (error) {
+          writeJson(res, 400, { ok: false, code: "rejected", error: error instanceof Error ? error.message : String(error) });
+        }
+      },
+    },
+  ];
+
+  const disposers = routes.map((route) => ctx.webServer.register(route));
+  ctx.effect(() => () => {
+    for (const dispose of disposers) dispose();
+  }, NAME + ": routes");
+  ctx.logger?.info?.("[" + NAME + "] mounted " + routes.length + " reasoning routes");
+}
+
+export { apply };