dsh-auto-thinking-levels 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 lolkda
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,131 @@
+# dsh-auto-thinking-levels
+
+[DeepSeek Harness](https://github.com/deepseek-ai/deepseek-harness) (dsh) 的 Host 插件：
+**自动给每个提供商、每个模型补上完整的思考等级表（`reasoningEfforts`）**，不用再逐模型手写。
+
+> **English TL;DR** — A dsh Host plugin that keeps every `llm-pi-ai` provider route
+> offering the full thinking-level set. It writes the missing `reasoningEfforts`
+> tables into that namespace's settings layer, so both the model selector *and*
+> the request path agree on which levels exist. Add-only and idempotent: it never
+> rewrites a level you already spelled, never removes an entry, and never touches
+> a model that declares `reasoningEfforts: false`.
+
+```yaml
+reasoningEfforts:
+  { off: null, minimal: minimal, low: low, medium: medium, high: high, xhigh: xhigh, max: max }
+```
+
+## 为什么写配置层，而不是去 patch adapter
+
+`llm-pi-ai` 在**物化模型时**读一次 `reasoningEfforts`，把它翻译成 pi-ai 描述符上的
+`thinkingLevelMap`（`resolveModelReasoning`）。之后所有判断都只从这张 map 出发：
+
+- `getSupportedThinkingLevels()` 决定选择器**显示**哪些档位；
+- **同一个函数**守着请求路径，map 里没有的档位在发出任何 I/O 之前就以
+  `UNSUPPORTED_REASONING_EFFORT` 被拒。
+
+所以只包一层 adapter 的 `resolveModel` 只能改到第一个答案、改不到第二个 —— 用户会选到
+一个真正发请求时被拒的档位。把表写进配置层，是让**配置本身正确**，两个答案都从它推导，
+且任何一次重载后依然成立，不需要重新打补丁。
+
+写入走 `settings.update`：候选值会先过该命名空间自己的 schema 与 `assertServiceable`
+校验，**注入不合法时什么都不落盘**。
+
+## 安装
+
+```sh
+dsh plugin --profile <name> add dsh-auto-thinking-levels
+```
+
+插件自带 `dsh.bundle.patch`，安装后自动挂一行，不需要手改 `cordis.patch.yml`。
+
+想改配置的话，在 profile 的 `cordis.patch.yml` 里用 id 定向 patch 覆盖那一行即可；
+改完用 `set_bundle` 关掉再打开，这一行就会用新配置重新挂载。
+
+## 配置
+
+全部字段可选，默认值见下表。
+
+| 字段 | 默认 | 含义 |
+| --- | --- | --- |
+| `namespace` | `llm-pi-ai` | 要配置的 settings 命名空间（`dsh-llm-pi-ai` 的 `NS`） |
+| `fill` | `complete` | `complete` 把**档位不足**的模型补齐（已写过的档位保留你的原值）；`missing` 只补完全没有表的模型，尊重刻意的子集 |
+| `levels` | 七档全表 | 要写入的表；值是发给网关的线材拼写，`off: null` 表示「支持，但不发送该参数」 |
+| `providers` | `[]` | 路由白名单，空 = 全部已注册路由 |
+| `enabled` | `true` | `false` 时挂载但不动配置 |
+
+## 行为
+
+只做**新增**，绝不覆盖：
+
+- 已有部分档位的模型（`fill: complete`）：补齐缺失的档位，**已写过的档位保留你的原值**；
+- 声明 `reasoningEfforts: false` 的模型：`false` 是「此模型不推理」的明确答复，永不填充；
+- 其余任何字段、任何条目都不会被删改。
+
+因此是幂等的：第二遍扫描找不到要补的，就不写、不发事件，自然收敛。
+
+插件会监听该命名空间的变更与 adapter 拓扑变化，所以**你手改 `settings.yaml` 之后它会自己补回来**。
+
+## 两种路由
+
+- **声明了 `models` 的路由**：逐条 entry 补表。
+- **没有 `models` 的路由**（catalog 路由）：只能通过 `modelOverrides` 表达，因此按
+  `ctx.llm.listModels(route)` **实际服务**的模型逐个补 —— adapter 会拒绝命名
+  catalog 里不存在的模型，所以这里用真实服务列表而不是去猜 catalog。
+  两种方式互斥：`models` 旁边放 `modelOverrides` 会被 adapter 拒绝。
+
+## 已知边界
+
+本插件只配置 `llm-pi-ai` 命名空间。**其它 adapter 不在作用域内，且有些无法被配置**：
+
+`deepseek-official`（`llm-deepseek` adapter）拿不到七档 —— 它的档位写死在 adapter 里
+（`off/low/high/max`），线材校验函数 `reasoningEffort()` 对其余值直接抛
+`UNSUPPORTED_REASONING_EFFORT`；它的 settings schema 也只有 provider 级 `reasoningEffort`，
+没有 per-model 表。这是官方 API 自己的线材词汇（`medium` 会收敛到 `high`），不是配置能改的。
+强行为它注入 `minimal/medium/xhigh` 只会把请求打成必然失败。
+
+## 验证
+
+`verification/probe-result.json` 是一次性探针在运行中的 harness 上抓的实测结果：对每个
+已注册路由/模型调用 `llm.resolveModelInfo`（选择器看到的档位）与
+`llm.resolveCallConfig`（请求路径是否接受该档位）。
+
+```
+## provider: cpa
+   deepseek-v4-flash-0731   efforts: off/minimal/low/medium/high/xhigh/max   rejected: none
+   glm-5.3-flash            efforts: off/minimal/low/medium/high/xhigh/max   rejected: none
+   deepseek-flash           efforts: off/minimal/low/medium/high/xhigh/max   rejected: none
+   gpt-6-astra              efforts: off/minimal/low/medium/high/xhigh/max   rejected: none
+   claude-fable-5-1         efforts: off/minimal/low/medium/high/xhigh/max   rejected: none
+   glm-5.3-flashx           efforts: off/minimal/low/medium/high/xhigh/max   rejected: none
+
+## provider: deepseek-official
+   deepseek-flash           efforts: off/low/high/max   rejected: minimal,medium,xhigh
+   deepseek-v4-pro          efforts: off/low/high/max   rejected: minimal,medium,xhigh
+```
+
+（`resolveModelInfo` 里的 `auto` 由另一个插件注入，不属于本插件。）
+
+## 开发
+
+```sh
+npm test          # node:test，20 个用例，零依赖
+```
+
+`lib/plan.js` 是纯决策逻辑（可测、无 I/O），`index.js` 只负责读写 settings 与事件触发。
+
+发布走 tag：
+
+```sh
+npm version patch
+git push --follow-tags
+```
+
+`.github/workflows/publish.yml` 会校验 tag 与 `package.json` 版本一致、跑测试、以
+provenance 发布到 npm，并开一个 GitHub Release。认证用 npm 的
+[trusted publishing](https://docs.npmjs.com/trusted-publishers)（OIDC），**不需要
+`NPM_TOKEN` secret** —— 前提是在 npmjs.com 的包设置里登记过本仓库与 workflow 名。
+
+## License
+
+MIT

package/cordis.patch.yml

@@ -0,0 +1,30 @@
+# dsh-auto-thinking-levels — mounts one Host row.
+#
+# `fill: complete` is the shipped policy: every model of every route in the
+# namespace below is brought to the full thinking-level set, and a model that
+# already spells some levels keeps its own spellings. Use `fill: missing` to
+# leave a deliberately partial table alone instead.
+- insert:
+    - id: dsh-auto-thinking-levels
+      name: dsh-auto-thinking-levels
+      config:
+        fill: complete
+        # Settings namespace to configure. Default: llm-pi-ai
+        #   namespace: llm-pi-ai
+        #
+        # The table written, as level -> wire spelling. `off: null` means
+        # "supported, send nothing". Default:
+        #   levels:
+        #     off: null
+        #     minimal: minimal
+        #     low: low
+        #     medium: medium
+        #     high: high
+        #     xhigh: xhigh
+        #     max: max
+        #
+        # Provider routes to configure; empty means every registered route.
+        #   providers: []
+        #
+        # false mounts the row without touching settings.
+        #   enabled: true

package/index.js

@@ -0,0 +1,215 @@
+/**
+ * dsh-auto-thinking-levels — Host plugin entry.
+ *
+ * The decision logic lives in `./lib/plan.js` and is pure. This module owns the
+ * I/O: reading the settings namespace, writing through `settings.update`, and
+ * the triggers that keep the plan applied.
+ *
+ * Why the settings layer is the right seam: `llm-pi-ai` reads a model's
+ * `reasoningEfforts` table at materialization time and turns it into the pi-ai
+ * descriptor's `thinkingLevelMap` (`resolveModelReasoning`). Every later
+ * question is answered from that map, and only from it:
+ *
+ *   - `getSupportedThinkingLevels()` decides which levels a selector offers;
+ *   - the same function gates the request path, so a level the map does not
+ *     carry is refused with `UNSUPPORTED_REASONING_EFFORT` before any I/O.
+ *
+ * So patching an adapter's `resolveModel` could only ever move the first
+ * answer, not the second, and the user would pick a level the provider call
+ * then rejects. Writing the table into the namespace's user layer instead makes
+ * the *configuration* correct, so both answers follow from it and survive every
+ * reload without a re-patch. Writes go through `settings.update`, which
+ * resolves and validates the candidate through the namespace's own schema and
+ * `assertServiceable` before persisting — an injection that would not serve is
+ * refused with nothing written.
+ *
+ * The plugin only ever ADDS the field. It never rewrites a level the user
+ * already spelled, never removes an entry, and never touches a model that
+ * declares `reasoningEfforts: false` (the explicit "this model does not
+ * reason" answer). That makes it idempotent: a second pass finds nothing to do
+ * and writes nothing.
+ *
+ * @module dsh-auto-thinking-levels
+ */
+
+import { plainObject, planModels, planOverrides, readOptions, summarize } from './lib/plan.js';
+
+/**
+ * Delays before re-reading a namespace that is not registered yet. The pi-ai
+ * adapter installs its settings section during its own `apply`, and row order
+ * decides whether that happened before this one — and `settings.register()`
+ * emits no event, so a section appearing after us is not observable. A short
+ * bounded ladder covers the startup race; the event listeners below cover
+ * everything after it.
+ */
+const RETRY_LADDER_MS = Object.freeze([200, 500, 1000, 2000, 4000, 8000]);
+
+export const name = 'dsh-auto-thinking-levels';
+
+/** The adapter must exist before there is a namespace worth configuring. */
+export const inject = ['llm'];
+
+/**
+ * Mount the row. The plugin is inert until a settings provider is present,
+ * because without one there is no user layer to write and no resolved value to
+ * compare against.
+ * @param ctx - the row's Cordis context.
+ * @param config - the row's `config` block, when the patch supplies one.
+ * @throws {TypeError} when a supplied field is not one this plugin understands.
+ */
+export function apply(ctx, config) {
+  const options = readOptions(config);
+  if (!options.enabled) {
+    ctx.logger.info('[%s] disabled by configuration; no namespace will be written', name);
+    return;
+  }
+
+  ctx.inject(['settings'], (settingsCtx) => {
+    const settings = settingsCtx.settings;
+    /** One pass at a time; a trigger arriving mid-pass sets the rerun flag instead. */
+    let running = false;
+    let rerun = false;
+    /** Pending retry handle, and how many ladder steps it has consumed. */
+    let timer;
+    let attempt = 0;
+    let disposed = false;
+
+    const cancel = () => {
+      if (timer === undefined) return;
+      clearTimeout(timer);
+      timer = undefined;
+    };
+
+    const schedule = (delayMs) => {
+      if (disposed) return;
+      cancel();
+      timer = setTimeout(() => {
+        timer = undefined;
+        void pump();
+      }, delayMs);
+      // `setTimeout` alone would keep a disposed profile alive for one tick.
+      timer.unref?.();
+    };
+
+    /** Run passes until a pass settles, then stop; never overlaps. */
+    async function pump() {
+      if (disposed) return;
+      if (running) {
+        rerun = true;
+        return;
+      }
+      running = true;
+      try {
+        do {
+          rerun = false;
+          const outcome = await sync();
+          if (outcome === 'deferred') {
+            const delay = RETRY_LADDER_MS[Math.min(attempt, RETRY_LADDER_MS.length - 1)];
+            const more = attempt < RETRY_LADDER_MS.length;
+            attempt += 1;
+            if (more) schedule(delay);
+            return;
+          }
+          attempt = 0;
+        } while (rerun);
+      } catch (error) {
+        // A failed pass must never escape into the event bus: the settings
+        // document is untouched, and the next trigger tries again.
+        ctx.logger.warn('[%s] sync failed; the settings document was left untouched', name);
+        ctx.logger.warn(error);
+      } finally {
+        running = false;
+      }
+    }
+
+    /**
+     * One reconcile pass.
+     * @returns `'done'` when the namespace was read (whether or not it needed a
+     *   write), or `'deferred'` when it is not registered yet.
+     */
+    async function sync() {
+      const descriptor = settings
+        .describe()
+        .find((entry) => String(entry.ns) === options.namespace);
+      if (descriptor === undefined) return 'deferred';
+
+      const user = plainObject(descriptor.user) ? descriptor.user : {};
+      const resolved = plainObject(descriptor.value) ? descriptor.value : {};
+      const userProviders = plainObject(user.providers) ? user.providers : {};
+      const resolvedProviders = plainObject(resolved.providers) ? resolved.providers : {};
+
+      const routes = Object.keys(resolvedProviders).filter(
+        (route) => options.providers.length === 0 || options.providers.includes(route),
+      );
+
+      const patch = {};
+      const added = [];
+      for (const route of routes) {
+        const raw = plainObject(userProviders[route]) ? userProviders[route] : {};
+        // A route that declares `models` gets the table on each entry. A route
+        // that does not is a catalog route, whose served models are only
+        // nameable through `modelOverrides` — and `modelOverrides` beside a
+        // `models` list is refused by the adapter, so the two never combine.
+        const declared = raw.models;
+        if (Array.isArray(declared) && declared.length > 0) {
+          const next = planModels(route, declared, options, added);
+          if (next !== undefined) patch[route] = { models: next };
+          continue;
+        }
+        const overrides = await planRouteOverrides(route, raw.modelOverrides, added);
+        if (overrides !== undefined) patch[route] = { modelOverrides: overrides };
+      }
+
+      if (Object.keys(patch).length === 0) return 'done';
+
+      ctx.logger.info(
+        '[%s] %s: adding reasoningEfforts for %d model(s) across %d provider route(s) — %s',
+        name,
+        options.namespace,
+        added.length,
+        Object.keys(patch).length,
+        summarize(added),
+      );
+      await settings.update(options.namespace, { providers: patch }, descriptor.revision);
+      return 'done';
+    }
+
+    /**
+     * Ask the adapter which models a catalog route actually serves, then plan
+     * overrides for them.
+     * @param route - route key.
+     * @param existing - the route's raw `modelOverrides`, when it has any.
+     * @param added - collector of `route/model` labels actually changed.
+     * @returns the replacement dict, or `undefined` when nothing was missing.
+     */
+    async function planRouteOverrides(route, existing, added) {
+      const llm = ctx.get('llm');
+      if (llm === undefined) return undefined;
+      let served;
+      try {
+        served = await llm.listModels(route);
+      } catch (error) {
+        // A route whose adapter is mid-replacement reports nothing to serve;
+        // the next trigger retries rather than failing the pass.
+        ctx.logger.warn('[%s] could not list models for route "%s"', name, route);
+        ctx.logger.warn(error);
+        return undefined;
+      }
+      const ids = served.map((model) => model?.id).filter((id) => typeof id === 'string');
+      return planOverrides(route, existing, ids, options, added);
+    }
+
+    settingsCtx.effect(() => () => {
+      disposed = true;
+      cancel();
+    });
+
+    settingsCtx.on('settings/updated', (ns) => {
+      if (String(ns) === options.namespace) void pump();
+    });
+    // Routes appearing or disappearing re-shapes which models exist to cover.
+    settingsCtx.on('llm/adapters-updated', () => void pump());
+
+    void pump();
+  });
+}

package/lib/plan.js

@@ -0,0 +1,172 @@
+/**
+ * Pure planning logic for dsh-auto-thinking-levels.
+ *
+ * Everything here is a total function over plain data: it decides *what* the
+ * settings document should say, and never reads or writes anything. The plugin
+ * entry (`../index.js`) owns the I/O. Keeping the split means the interesting
+ * rules — which models get filled, which are deliberately left alone, what the
+ * merged table looks like — are testable without a running harness.
+ *
+ * @module dsh-auto-thinking-levels/plan
+ */
+
+/** The pi-ai adapter's settings namespace (`dsh-llm-pi-ai`'s `NS` constant). */
+export const DEFAULT_NAMESPACE = 'llm-pi-ai';
+
+/**
+ * The seven levels pi-ai's `ModelThinkingLevel` declares, in escalation order,
+ * with the wire spelling each sends. `off: null` is the one level allowed to
+ * carry no value — it means "supported, send nothing", which is the correct
+ * dispatch wherever not thinking is the reasoning parameter's absence.
+ */
+export const DEFAULT_LEVELS = Object.freeze({
+  off: null,
+  minimal: 'minimal',
+  low: 'low',
+  medium: 'medium',
+  high: 'high',
+  xhigh: 'xhigh',
+  max: 'max',
+});
+
+/** How much of each model's table this plugin is allowed to own. */
+export const FILL_MODES = Object.freeze(['missing', 'complete']);
+
+/** Whether a value is a plain data object, the only shape a settings layer holds. */
+export function plainObject(value) {
+  if (typeof value !== 'object' || value === null || Array.isArray(value)) return false;
+  const proto = Object.getPrototypeOf(value);
+  return proto === Object.prototype || proto === null;
+}
+
+/**
+ * Validate the row's `config` block. Every field is optional; the defaults
+ * already mean "every provider, every model, the full seven levels".
+ * @param config - the raw row config, when the patch supplies one.
+ * @returns the resolved options.
+ * @throws {TypeError} naming the offending field.
+ */
+export function readOptions(config) {
+  if (config !== undefined && !plainObject(config)) {
+    throw new TypeError('dsh-auto-thinking-levels: config must be a mapping of keys');
+  }
+  const raw = config ?? {};
+
+  const namespace = raw.namespace ?? DEFAULT_NAMESPACE;
+  if (typeof namespace !== 'string' || namespace.length === 0) {
+    throw new TypeError('dsh-auto-thinking-levels: config.namespace must be a non-empty string');
+  }
+
+  const fill = raw.fill ?? 'complete';
+  if (!FILL_MODES.includes(fill)) {
+    throw new TypeError(`dsh-auto-thinking-levels: config.fill must be one of ${FILL_MODES.join(', ')}`);
+  }
+
+  const levels = raw.levels ?? DEFAULT_LEVELS;
+  if (!plainObject(levels) || Object.keys(levels).length === 0) {
+    throw new TypeError('dsh-auto-thinking-levels: config.levels must be a non-empty mapping of level -> wire value');
+  }
+  for (const [level, wire] of Object.entries(levels)) {
+    if (wire === null) continue;
+    if (typeof wire !== 'string' || wire.length === 0) {
+      throw new TypeError(`dsh-auto-thinking-levels: config.levels.${level} must be a non-empty string, or null for "send nothing"`);
+    }
+  }
+
+  const providers = raw.providers ?? [];
+  if (!Array.isArray(providers) || providers.some((entry) => typeof entry !== 'string')) {
+    throw new TypeError('dsh-auto-thinking-levels: config.providers must be an array of provider route names');
+  }
+
+  const enabled = raw.enabled ?? true;
+  if (typeof enabled !== 'boolean') {
+    throw new TypeError('dsh-auto-thinking-levels: config.enabled must be a boolean');
+  }
+
+  const known = new Set(['namespace', 'fill', 'levels', 'providers', 'enabled']);
+  const unknown = Object.keys(raw).filter((key) => !known.has(key));
+  if (unknown.length > 0) {
+    throw new TypeError(`dsh-auto-thinking-levels: unknown config key(s): ${unknown.join(', ')}`);
+  }
+
+  return { namespace, fill, levels, providers, enabled };
+}
+
+/**
+ * Decide the table one model should carry.
+ * @param current - the model's declared `reasoningEfforts`, when it has one.
+ * @param options - resolved plugin options.
+ * @returns the table to write, or `undefined` to leave the model alone.
+ */
+export function mergeEfforts(current, options) {
+  // `false` is the model's own "does not reason" answer — an explicit
+  // declaration, not a gap, and the one value this plugin must not fill in.
+  if (current === false) return undefined;
+  if (current === undefined) return { ...options.levels };
+  if (!plainObject(current)) return undefined;
+  if (options.fill !== 'complete') return undefined;
+  const incomplete = Object.keys(options.levels).some((level) => !(level in current));
+  if (!incomplete) return undefined;
+  // The user's own spellings win over the plugin's defaults, key for key.
+  return { ...options.levels, ...current };
+}
+
+/**
+ * Top up a route's declared `models` list.
+ * @param route - route key, for the change report.
+ * @param models - the route's raw `models` array.
+ * @param options - resolved plugin options.
+ * @param added - collector of `route/model` labels actually changed.
+ * @returns the replacement array, or `undefined` when every entry is already complete.
+ */
+export function planModels(route, models, options, added) {
+  let changed = false;
+  const next = models.map((entry) => {
+    if (!plainObject(entry)) return entry;
+    const merged = mergeEfforts(entry.reasoningEfforts, options);
+    if (merged === undefined) return entry;
+    changed = true;
+    added.push(`${route}/${String(entry.id)}`);
+    return { ...entry, reasoningEfforts: merged };
+  });
+  return changed ? next : undefined;
+}
+
+/**
+ * Top up a catalog route through `modelOverrides`, one entry per model the
+ * adapter actually serves. The adapter refuses an override naming a model the
+ * installed catalog does not describe, so the served list — not a guess at the
+ * catalog — is what gets named here.
+ * @param route - route key, for the change report.
+ * @param existing - the route's raw `modelOverrides`, when it has any.
+ * @param servedIds - ids the adapter reports serving for this route.
+ * @param options - resolved plugin options.
+ * @param added - collector of `route/model` labels actually changed.
+ * @returns the replacement dict, or `undefined` when nothing was missing.
+ */
+export function planOverrides(route, existing, servedIds, options, added) {
+  const current = plainObject(existing) ? existing : {};
+  const next = { ...current };
+  let changed = false;
+  for (const id of servedIds) {
+    if (typeof id !== 'string' || id.length === 0) continue;
+    const entry = plainObject(current[id]) ? current[id] : {};
+    const merged = mergeEfforts(entry.reasoningEfforts, options);
+    if (merged === undefined) continue;
+    next[id] = { ...entry, reasoningEfforts: merged };
+    changed = true;
+    added.push(`${route}/${id}`);
+  }
+  return changed ? next : undefined;
+}
+
+/**
+ * Bound a change report: a catalog route can carry dozens of models, and one
+ * log line should stay one log line.
+ * @param labels - `route/model` labels that were changed.
+ * @returns the labels, truncated with a remainder count.
+ */
+export function summarize(labels) {
+  const shown = labels.slice(0, 8).join(', ');
+  return labels.length > 8 ? `${shown}, +${labels.length - 8} more` : shown;
+}

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "dsh-auto-thinking-levels",
+  "version": "0.1.0",
+  "description": "DSH Host plugin: keep every llm-pi-ai provider route offering the full thinking-level set by writing the missing reasoningEfforts tables into that namespace's settings.",
+  "type": "module",
+  "main": "index.js",
+  "exports": {
+    ".": "./index.js",
+    "./plan": "./lib/plan.js",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "index.js",
+    "lib/",
+    "cordis.patch.yml",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "scripts": {
+    "test": "node --test",
+    "check:pack": "node scripts/check-pack.mjs"
+  },
+  "keywords": [
+    "dsh",
+    "deepseek-harness",
+    "cordis",
+    "cordis-plugin",
+    "plugin",
+    "llm",
+    "reasoning-effort",
+    "thinking-levels",
+    "reasoningEfforts"
+  ],
+  "license": "MIT",
+  "author": "lolkda",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/lolkda/dsh-auto-thinking-levels.git"
+  },
+  "homepage": "https://github.com/lolkda/dsh-auto-thinking-levels#readme",
+  "bugs": {
+    "url": "https://github.com/lolkda/dsh-auto-thinking-levels/issues"
+  },
+  "dsh": {
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    }
+  }
+}