dsh-newapi-provider 0.8.4 → 0.9.4

package/README.md

@@ -82,6 +82,31 @@ Each gateway keeps an independent list, even when two gateways point at the same
 
 Capability data is a hint, not proof: a relay may list a model and still fail to serve it.
 
+## Thinking levels
+
+Vendors do not agree on reasoning levels, so each model resolves its own set instead of every reasoning model showing the same five:
+
+| Vendor / model | Levels offered | Notes |
+| --- | --- | --- |
+| Claude adaptive thinking (Opus 5 / Sonnet 5 / Fable) | low / medium / high / xhigh / max | no `minimal`, no `off` |
+| Older Claude (budget based) | off / minimal / low / medium / high | mapped to token budgets |
+| GPT-5.1+ / GPT-6 | off / low / medium / high / xhigh / max | `off` is sent as `none`, no `minimal` |
+| GPT-5.0 / o-series | minimal / low / medium / high | GPT-5.0 cannot be turned off; o-series stops at high |
+| gpt-5-pro | high only | the vendor accepts nothing else |
+| Gemini 3 / 4 | minimal / low / medium / high | `thinking_level` has no off; no xhigh/max |
+| Gemini 2.5 | off / minimal / low / medium / high | budget based; Pro cannot really be switched off |
+| DeepSeek V4 | off / low / high / max | the vendor folds the in-between levels |
+| GLM-5.3 | low / high / max | sending `disabled` errors, so no off |
+| GLM-5.2 | all seven | most levels are folded upstream |
+| Kimi K3 | low / high / max | no medium, cannot be switched off |
+| Qwen3 / unknown | off / minimal / low / medium / high | pi-ai's own default when a model has no levels |
+
+Resolution order: **your override → pi-ai's shipped model data (same model, same behaviour as the built-in provider) → vendor-family default**.
+
+**Model capabilities → Edit model → Thinking levels** opens on a table pre-filled from the model data (turn the switch off to see the detected set read-only). The left column is the level shown in the chat selector — the built-ins (off/minimal/low/medium/high/xhigh/max) or a name you type yourself (1–24 lowercase letters, digits, `-`, `_`); a custom level must carry a value and then appears in the chat selector like any other. The right column is what that level sends upstream; an empty value sends nothing. The mapping is stored per model per gateway and affects only this plugin.
+
+> Limitation: relays rename models (`claude-opus-5-5`), so a family guess fills the gap when the exact id is unknown. Use a custom override if the upstream disagrees. A level only changes the request; whether the upstream honours that depth is up to it.
+
 ## Models and modalities
 
 models.dev data is cached. Exact matches win; when nothing matches, defaults apply. Base-model matches, defaults and manual overrides are all marked in the UI. Never treat a guessed capability as something the gateway has proven.

package/README.zh.md

@@ -87,6 +87,31 @@ DeepSeek Harness 的 New API 渠道与模型工作台：多网关同一时间激
 
 跨厂商或跨模型系列映射需要检查协议、容量和能力是否合适。模型编辑器修改参数时绑定打开时的渠道；出现配置冲突提示应刷新再编辑，避免覆盖另一个窗口的修改。
 
+## 思考等级（v0.9.0）
+
+不同厂商的推理档位并不相同，插件按模型分别解析，不再对所有推理模型显示同一组档位：
+
+| 厂商 / 模型 | 提供的档位 | 说明 |
+| --- | --- | --- |
+| Claude 自适应思考（Opus 5 / Sonnet 5 / Fable） | 低 / 中 / 高 / 很高 / 最高 | 无「最少」，`off` 不提供 |
+| 旧版 Claude（预算式） | 关闭 / 最少 / 低 / 中 / 高 | 按 token 预算换算 |
+| GPT-5.1+ / GPT-6 | 关闭 / 低 / 中 / 高 / 很高 / 最高 | `off` 发 `none`，无「最少」 |
+| GPT-5.0 / o 系列 | 最少 / 低 / 中 / 高 | GPT-5.0 无法关闭；o 系列只到高 |
+| gpt-5-pro | 仅「高」 | 官方只接受 high |
+| Gemini 3 / 4 | 最少 / 低 / 中 / 高 | `thinking_level` 无关闭项；xhigh/max 不存在 |
+| Gemini 2.5 | 关闭 / 最少 / 低 / 中 / 高 | 预算式；Pro 无法真正关闭 |
+| DeepSeek V4 | 关闭 / 低 / 高 / 最高 | 官方会折叠无意义档位 |
+| GLM-5.3 | 低 / 高 / 最高 | 传 `disabled` 会报错，故不提供关闭 |
+| GLM-5.2 | 全部 7 档 | 多数档位会被上游折叠 |
+| Kimi K3 | 低 / 高 / 最高 | 无 medium、无法关闭 |
+| Qwen3 / 未知模型 | 关闭 / 最少 / 低 / 中 / 高 | 无离散档位时沿用 pi-ai 默认 |
+
+解析顺序：**你的自定义覆盖 → pi-ai 自带模型数据（同一模型与官方 provider 行为一致）→ 厂商家族默认**。
+
+在「模型能力 → 编辑模型参数 → 推理等级」里，开关默认打开并预填模型当前档位。左列是对话选择器里的档位（英文），右列是该档位发给网关的参数值，留空表示不发送参数。左列除了 off/minimal/low/medium/high/xhigh/max 内置档位，也可以直接输入自定义名字（1–24 位小写字母、数字、`-`、`_`），自定义档位必须填写参数值，它会像内置档位一样出现在对话选择器里。配置按渠道按模型保存，只影响本插件。
+
+> 限制：中转站的模型 id 常与厂商原名不同（如 `claude-opus-5-5`），无法逐字命中时按家族推断；若上游行为与推断不符，用自定义覆盖修正。思考等级只影响发送给网关的参数，是否能达到该档位仍取决于上游。
+
 ## 模型与多模态
 
 models.dev 数据有缓存。精确匹配优先，无法匹配时使用默认值；基础模型匹配、默认值与手动覆盖均在界面标出。切勿把猜测的能力当作网关实测结果。

package/client.js

@@ -48,6 +48,17 @@ window.__ModuleLoader__.load({
       reasoning: '推理', noReasoning: '未声明推理', auto: '自动识别', overridden: '已自定义', defaults: '默认值',
       modelEmpty: '没有匹配的模型', noModels: '当前渠道暂无模型目录', hidden: '已隐藏', modelEdit: '编辑模型参数', modelEditHint: '只影响此渠道的该模型；不会修改 New API 站点。',
       kind: '模型类型', displayName: '显示名称', inputModalities: '输入能力', inputHint: 'DSH 对话层支持文本与图片；PDF、音视频标签仅用于展示，不能直接作为对话输入。',
+      reasoningLevels: '推理等级', reasoningLevelsMode: '推理等级模式',
+      levelsAutoHint: '已关闭自定义，按模型自动识别的档位发送；打开开关可以逐个修改。',
+      levelsCustomHint: '下面是从模型数据预填的档位。左侧决定对话里可选什么，右侧是发给网关的参数值；留空表示不发送参数（常用于 off）。不改动就保持跟随模型。',
+      levelsOffered: '将提供',
+      levelsRequired: '至少保留一个档位', level_off: 'off', level_minimal: 'minimal', level_low: 'low', level_medium: 'medium', level_high: 'high', level_xhigh: 'xhigh', level_max: 'max',
+      levelColumn: '档位', apiValueColumn: 'API 参数值', apiValuePlaceholder: '留空则不发送',
+      levelPlaceholder: '档位名，可自定义', levelInvalid: '档位只能用 1-24 位小写字母、数字、- 或 _',
+      levelDuplicate: '档位名重复了', levelNeedsValue: '自定义档位必须填写 API 参数值',
+      levelCustomOption: '自定义…', levelBackToPreset: '改回内置档位',
+      addLevel: '添加档位', removeLevel: '移除该档位',
+      levelsHelp: '不同厂商的推理档位并不相同：这里决定对话里可选哪些档位，以及每个档位发给网关的参数值。关闭开关则跟随模型自动识别。',
       reasoningEnabled: '声明支持推理', hideModel: '隐藏该模型', modelSave: '保存参数', reset: '恢复自动识别',
       resetHint: '清除此渠道中该模型的全部自定义参数。', modelSaved: '模型参数已更新', modelReset: '已恢复自动识别',
       inherited: '留空使用自动识别或默认值', positiveInteger: '请输入大于 0 的整数',
@@ -127,6 +138,17 @@ window.__ModuleLoader__.load({
       reasoning: 'Reasoning', noReasoning: 'No reasoning declared', auto: 'Automatic', overridden: 'Customized', defaults: 'Default',
       modelEmpty: 'No matching models', noModels: 'No model catalog for this gateway', hidden: 'Hidden', modelEdit: 'Edit model', modelEditHint: 'Changes this model on this gateway only, not the New API site.',
       kind: 'Model kind', displayName: 'Display name', inputModalities: 'Input capabilities', inputHint: 'DSH chat accepts text and image. PDF, video and audio tags are informational only.',
+      reasoningLevels: 'Thinking levels', reasoningLevelsMode: 'Thinking level mode',
+      levelsAutoHint: 'Customisation is off: the levels detected for this model are sent as-is. Turn the switch on to edit them.',
+      levelsCustomHint: 'Pre-filled from the model data. The left column decides what the chat selector offers, the right column is the value sent upstream; empty sends nothing (common for off). Leave it untouched to keep following the model.',
+      levelsOffered: 'Offers',
+      levelsRequired: 'Pick at least one thinking level', level_off: 'off', level_minimal: 'minimal', level_low: 'low', level_medium: 'medium', level_high: 'high', level_xhigh: 'xhigh', level_max: 'max',
+      levelColumn: 'Level', apiValueColumn: 'API value', apiValuePlaceholder: 'Empty sends nothing',
+      levelPlaceholder: 'Level name, custom allowed', levelInvalid: 'Levels use 1-24 lowercase letters, digits, - or _',
+      levelDuplicate: 'Duplicate level name', levelNeedsValue: 'A custom level needs an API value',
+      levelCustomOption: 'Custom…', levelBackToPreset: 'Back to built-in levels',
+      addLevel: 'Add level', removeLevel: 'Remove level',
+      levelsHelp: 'Vendors differ: this decides which levels the chat selector offers and what each one sends upstream. Leave the switch off to follow the detected set.',
       reasoningEnabled: 'Declare reasoning support', hideModel: 'Hide model', modelSave: 'Save parameters', reset: 'Use automatic values',
       resetHint: 'Removes all overrides for this model on this gateway.', modelSaved: 'Model parameters updated', modelReset: 'Automatic values restored',
       inherited: 'Leave empty for automatic or default values', positiveInteger: 'Enter a positive integer',
@@ -178,6 +200,7 @@ window.__ModuleLoader__.load({
       useEffect(() => locale?.subscribe(() => rerender((x) => x + 1)), []);
       return (key) => translate?.(key) ?? ZH[key] ?? key;
     }
+    const LEVELS = ['off', 'minimal', 'low', 'medium', 'high', 'xhigh', 'max'];
     const ICONS = {
       plus: 'M12 5v14M5 12h14', refresh: 'M20 7v5h-5M4 17v-5h5M6.1 7a7 7 0 0 1 11.6-1L20 9M4 15l2.3 3a7 7 0 0 0 11.6-1',
       check: 'm5 12 4 4L19 6', close: 'm6 6 12 12M6 18 18 6', edit: 'm15 5 4 4M4 20l4-1L20 7a2.1 2.1 0 0 0-3-3L5 16Z',
@@ -371,6 +394,38 @@ window.__ModuleLoader__.load({
       .nas-side-balance-icon{display:inline-flex;color:var(--nas-sub);flex-shrink:0}
       .nas-side-balance[data-wide=no] .nas-side-balance-btn{justify-content:center;padding:6px 0;gap:0}
       .nas-side-balance[data-wide=no] .nas-side-balance-icon{display:none}
+      /* Level chips: same look as the input-modality toggles. */
+      .nas-chips{display:flex;flex-wrap:wrap;gap:6px;margin-top:8px}
+      .nas-chips .nas-chip,.nas-chips button{display:inline-flex;align-items:center;gap:5px;border:1px solid var(--nas-line);background:var(--nas-bg);color:var(--nas-text);border-radius:7px;padding:4px 9px;font-size:12px;line-height:1.5}
+      .nas-chips button:hover{border-color:var(--nas-brand)}
+      .nas-chips button[aria-pressed=true]{border-color:var(--nas-brand);background:color-mix(in srgb,var(--nas-accent) 7%,transparent);font-weight:550}
+      .nas-chips.readonly .nas-chip{cursor:default;color:var(--nas-sub)}
+      .nas-chips.readonly .nas-chip.on{color:var(--nas-text);border-color:var(--nas-line-strong,var(--nas-line))}
+      /* Reasoning levels: switch + level/value table, mirroring the editor rows. */
+      .nas-levels{display:flex;flex-direction:column;gap:8px;margin-top:14px;padding:12px 13px;border:1px solid var(--nas-line);border-radius:10px;background:var(--nas-raised)}
+      .nas-levels-head{display:flex;align-items:center;justify-content:space-between;gap:12px}
+      .nas-levels-title{display:flex;align-items:center;gap:6px;font-size:12.5px;font-weight:550}
+      .nas-help{display:inline-flex;align-items:center;justify-content:center;width:15px;height:15px;border:1px solid var(--nas-line-strong,var(--nas-line));border-radius:50%;font-size:10px;color:var(--nas-sub);cursor:help}
+      .nas-switch{position:relative;flex-shrink:0;width:38px;height:22px;border:1px solid var(--nas-line);border-radius:999px;background:var(--nas-line);cursor:pointer;transition:background .15s,border-color .15s}
+      .nas-switch>i{position:absolute;top:2px;left:2px;width:16px;height:16px;border-radius:50%;background:#fff;box-shadow:0 1px 2px rgba(0,0,0,.2);transition:transform .15s}
+      .nas-switch.on{background:var(--nas-brand);border-color:var(--nas-brand)}
+      .nas-switch.on>i{transform:translateX(16px)}
+      .nas-switch:disabled{opacity:.5;cursor:default}
+      .nas-levels-table{display:flex;flex-direction:column;gap:8px}
+      .nas-levels-row{display:grid;grid-template-columns:minmax(96px,150px) minmax(0,1fr) 26px;align-items:center;gap:10px}
+      .nas-levels-row.head{font-size:11px;color:var(--nas-sub);padding:0 1px}
+      .nas-levels-row select,.nas-levels-row input{width:100%;min-width:0;border:1px solid var(--nas-line);border-radius:8px;background:var(--dsw-alias-bg-base);color:var(--nas-text);padding:6px 9px;font-size:12.5px;font-family:inherit}
+      .nas-levels-row select:focus-visible,.nas-levels-row input:focus-visible{outline:2px solid var(--nas-brand);outline-offset:1px}
+      .nas-levels-remove{display:inline-flex;align-items:center;justify-content:center;width:26px;height:26px;border:1px solid transparent;border-radius:7px;background:transparent;color:var(--nas-sub);cursor:pointer}
+      .nas-levels-remove:hover:not(:disabled){color:var(--dsw-alias-state-error-primary);border-color:var(--nas-line)}
+      .nas-levels-remove:disabled{opacity:.35;cursor:default}
+      .nas-levels-add{display:inline-flex;align-items:center;gap:6px;align-self:flex-start;border:1px solid var(--nas-line);border-radius:8px;background:var(--dsw-alias-bg-base);color:var(--nas-text);padding:6px 10px;font-size:12px;cursor:pointer}
+      .nas-levels-add:hover:not(:disabled){border-color:var(--nas-brand)}
+      .nas-levels-add:disabled{opacity:.5;cursor:default}
+      .nas-levels-custom{display:flex;align-items:center;gap:6px;min-width:0}
+      .nas-levels-custom input{flex:1;min-width:0}
+      .nas-levels-back{display:inline-flex;align-items:center;justify-content:center;width:24px;height:24px;flex-shrink:0;border:1px solid var(--nas-line);border-radius:6px;background:var(--dsw-alias-bg-base);color:var(--nas-sub);cursor:pointer}
+      .nas-levels-back:hover:not(:disabled){color:var(--nas-text);border-color:var(--nas-brand)}
       /* Tooltips: instant, themed, keyboard accessible. */
       .nas [data-tip]{position:relative}
       .nas [data-tip]::after{content:attr(data-tip);position:absolute;z-index:60;bottom:calc(100% + 9px);left:50%;transform:translateX(-50%);width:max-content;max-width:270px;padding:6px 9px;border-radius:7px;border:1px solid var(--nas-line);background:var(--dsw-alias-bg-overlay);color:var(--nas-text);font-size:11px;font-weight:400;line-height:1.55;text-align:left;white-space:pre-line;box-shadow:0 8px 24px color-mix(in srgb,var(--dsw-alias-label-primary) 16%,transparent);opacity:0;pointer-events:none;transition:opacity .12s}
@@ -569,6 +624,117 @@ window.__ModuleLoader__.load({
             : h('div', { className: 'nas-test-error' }, tested.error))
           : h('div', { className: 'nas-note', style: { marginTop: 14 } }, h(Icon, { name: 'info', size: 13 }), t('testHint'))));
     }
+    /**
+     * Reasoning levels: a switch plus a level→wire-value table.
+     * Off = follow what the model declares; on = the table is exactly what ships.
+     */
+    function ReasoningLevelsEditor({ enabled, rows, detected, busy, onToggle, onChange }) {
+      const CUSTOM_CHOICE = '__custom';
+      const t = useT();
+      const setRow = (index, patch) => onChange(rows.map((row, i) => (i === index ? { ...row, ...patch } : row)));
+      // A new row starts on the first preset nobody uses yet; when all seven are taken it
+      // starts as a custom row instead, which is the only case where a name is typed.
+      const add = () => {
+        const free = LEVELS.find((level) => !rows.some((row) => row.level === level));
+        onChange([...rows, free ? { level: free, value: defaultWireFor(free) } : { level: '', value: '' }]);
+      };
+      const used = new Set(rows.map((row) => row.level).filter(Boolean));
+      const problems = rows.map((row) => {
+        if (!row.level) return { row: true };
+        if (!LEVELS.includes(row.level) && !CUSTOM_LEVEL.test(row.level)) return { invalid: true };
+        if (rows.filter((other) => other.level === row.level).length > 1) return { duplicate: true };
+        if (row.value.trim() === '' && !LEVELS.includes(row.level)) return { needsValue: true };
+        return {};
+      });
+      return h('div', { className: 'nas-levels' },
+        h('div', { className: 'nas-levels-head' },
+          h('div', { className: 'nas-levels-title' },
+            h('span', null, t('reasoningLevels')),
+            h('span', { className: 'nas-help', role: 'img', 'aria-label': t('levelsHelp'), 'data-tip': t('levelsHelp'), 'data-tip-align': 'start' }, '?')),
+          h('button', {
+            type: 'button', role: 'switch', 'aria-checked': enabled, 'aria-label': t('reasoningLevelsMode'),
+            className: `nas-switch ${enabled ? 'on' : ''}`, disabled: busy, onClick: onToggle,
+          }, h('i'))),
+        h('div', { className: 'nas-sub' }, enabled ? t('levelsCustomHint') : t('levelsAutoHint')),
+        !enabled && h('div', { className: 'nas-levels-summary', lang: 'en' }, `${t('levelsOffered')}: ${detected.join(' / ') || '—'}`),
+        enabled && h(React.Fragment, null,
+          h('div', { className: 'nas-levels-table' },
+            h('div', { className: 'nas-levels-row head' },
+              h('span', null, t('levelColumn')), h('span', null, t('apiValueColumn')), h('span', { 'aria-hidden': true })),
+            rows.map((row, index) => h('div', { className: 'nas-levels-row', key: `${row.level}-${index}` },
+              LEVELS.includes(row.level)
+                ? h('select', {
+                  value: row.level, disabled: busy, lang: 'en', 'aria-label': t('levelColumn'),
+                  onChange: (e) => setRow(index, e.target.value === CUSTOM_CHOICE
+                    ? { level: '' }                                  // switch this row to a typed name
+                    : { level: e.target.value, value: row.value || defaultWireFor(e.target.value) }),
+                },
+                LEVELS.map((level) => h('option', {
+                  key: level, value: level, lang: 'en',
+                  disabled: level !== row.level && used.has(level),
+                }, level)),
+                h('option', { value: CUSTOM_CHOICE }, t('levelCustomOption')))
+                : h('div', { className: 'nas-levels-custom' },
+                  h('input', {
+                    value: row.level, disabled: busy, lang: 'en', spellCheck: false, autoFocus: true,
+                    placeholder: t('levelPlaceholder'), 'aria-label': t('levelColumn'),
+                    'aria-invalid': Boolean(problems[index].invalid || problems[index].duplicate),
+                    onChange: (e) => setRow(index, { level: e.target.value.trim().toLowerCase() }),
+                  }),
+                  h('button', { type: 'button', className: 'nas-levels-back', disabled: busy,
+                    'aria-label': t('levelBackToPreset'), 'data-tip': t('levelBackToPreset'), 'data-tip-align': 'end',
+                    onClick: () => {
+                      const free = LEVELS.find((level) => !used.has(level));
+                      setRow(index, free ? { level: free, value: defaultWireFor(free) } : { level: LEVELS[0], value: defaultWireFor(LEVELS[0]) });
+                    } }, h(Icon, { name: 'refresh', size: 12 }))),
+              h('input', {
+                value: row.value, disabled: busy, lang: 'en', spellCheck: false, placeholder: t('apiValuePlaceholder'),
+                'aria-label': t('apiValueColumn'), onChange: (e) => setRow(index, { value: e.target.value }),
+              }),
+              h('button', {
+                type: 'button', className: 'nas-levels-remove', disabled: busy || rows.length <= 1,
+                'aria-label': t('removeLevel'), 'data-tip': t('removeLevel'), 'data-tip-align': 'end',
+                onClick: () => onChange(rows.filter((_, i) => i !== index)),
+              }, h(Icon, { name: 'trash', size: 13 })))),
+          h('button', { type: 'button', className: 'nas-levels-add', disabled: busy || rows.length >= LEVELS.length, onClick: add },
+            h(Icon, { name: 'plus', size: 13 }), t('addLevel')),
+          !rows.length && h('span', { className: 'nas-field-error' }, t('levelsRequired')))));
+    }
+    /** Level→wire map to editable rows; falls back to the detected set when nothing is pinned. */
+    function rowsFromMap(map, detectedLevels, detectedMap) {
+      if (map && Object.keys(map).length) {
+        const names = Object.keys(map).filter((l) => typeof map[l] === 'string');
+        return orderLevelNames(names).map((l) => ({ level: l, value: map[l] }));
+      }
+      const levels = detectedLevels ?? [];
+      return levels.map((l) => ({ level: l, value: (detectedMap && typeof detectedMap[l] === 'string') ? detectedMap[l] : defaultWireFor(l) }));
+    }
+    /** Preset levels first, then custom names — the same order the server resolves. */
+    function orderLevelNames(names) {
+      const preset = LEVELS.filter((l) => names.includes(l));
+      const custom = names.filter((l) => !LEVELS.includes(l)).sort();
+      return [...preset, ...custom];
+    }
+    /** A custom level name must be a safe id; presets are always allowed. */
+    const CUSTOM_LEVEL = /^[a-z0-9][a-z0-9_-]{0,23}$/;
+    /** Rows to the override map. A blank value means "this level sends nothing" (e.g. off). */
+    function rowsToMap(rows) {
+      const map = {};
+      for (const row of rows) map[row.level] = row.value.trim() ? row.value.trim() : null;
+      return map;
+    }
+    /** True when two level maps say the same thing (null and absent both mean "hidden"). */
+    function sameLevelMap(a, b) {
+      const read = (map, level) => {
+        const value = map ? map[level] : undefined;
+        return typeof value === 'string' ? value : null;
+      };
+      return LEVELS.every((level) => read(a, level) === read(b, level));
+    }
+    /** Wire value a level usually needs when the user adds it by hand. */
+    function defaultWireFor(level) {
+      return level === 'off' ? '' : level;
+    }
     function ModelEditor({ model, channel, revision, siblings = [], onClose, onSaved }) {
       const t = useT(); const id = useId(); const a = useAction();
       const initial = model.override || {};
@@ -581,6 +747,9 @@ window.__ModuleLoader__.load({
         inputMode: Array.isArray(initial.input) ? 'custom' : 'auto',
         input: [...(initial.input ?? automaticInput)],
         reasoningMode: initial.reasoning == null ? 'auto' : initial.reasoning ? 'on' : 'off',
+        levelsMode: 'custom',
+        // Custom rows: level id plus the wire value it sends ('' means "no value", i.e. off/none).
+        rows: rowsFromMap(initial.thinkingLevelMap, model.automaticReasoningLevels, model.automaticThinkingLevelMap),
         hidden: Boolean(initial.hidden),
       });
       const original = useRef(JSON.stringify(form)); const dirty = original.current !== JSON.stringify(form);
@@ -593,6 +762,13 @@ window.__ModuleLoader__.load({
         if (a.pending) return;
         for (const k of ['contextWindow', 'maxTokens']) if (form[k] && (!/^\d+$/.test(form[k]) || Number(form[k]) < 1 || !Number.isSafeInteger(Number(form[k])))) return setInvalid(t('positiveInteger'));
         if (form.upstreamModel.trim() && (/\s|[\u0000-\u001f\u007f-\u009f]/u.test(form.upstreamModel.trim()) || form.upstreamModel.trim().length > 500)) return setInvalid(t('invalidMapping'));
+        if (form.levelsMode === 'custom') {
+          const levels = form.rows.map((row) => row.level).filter(Boolean);
+          if (!levels.length) return setInvalid(t('levelsRequired'));
+          if (levels.some((level) => !LEVELS.includes(level) && !CUSTOM_LEVEL.test(level))) return setInvalid(t('levelInvalid'));
+          if (new Set(levels).size !== levels.length) return setInvalid(t('levelDuplicate'));
+          if (form.rows.some((row) => row.level && !LEVELS.includes(row.level) && !row.value.trim())) return setInvalid(t('levelNeedsValue'));
+        }
         const override = { ...initial };
         for (const k of ['name', 'upstreamModel', 'kind', 'protocol', 'contextWindow', 'maxTokens']) {
           const value = form[k].trim();
@@ -600,6 +776,12 @@ window.__ModuleLoader__.load({
         }
         override.input = form.inputMode === 'auto' ? null : form.input;
         override.reasoning = form.reasoningMode === 'auto' ? null : form.reasoningMode === 'on';
+        // A table that still matches what the model declares is not an override: keeping it
+        // null means the levels keep following pi-ai's data instead of freezing today's copy.
+        override.reasoningLevels = null;
+        const edited = rowsToMap(form.rows);
+        const detected = model.automaticThinkingLevelMap;
+        override.thinkingLevelMap = sameLevelMap(edited, detected) ? null : edited;
         override.hidden = form.hidden ? true : null;
         return a.run(async () => { await store.mutate('model/override', { revision, channelId: channel.id, modelId: model.id, override }); onSaved(false); });
       };
@@ -637,7 +819,15 @@ window.__ModuleLoader__.load({
           })),
           h('div', { className: 'nas-note', style: { marginTop: 8, marginBottom: 16 } }, t('inputHint')),
           h(Field, { label: t('reasoning'), htmlFor: `${id}-reasoning` }, h('select', { id: `${id}-reasoning`, value: form.reasoningMode, onChange: changed('reasoningMode'), disabled: a.pending },
-            h('option', { value: 'auto' }, `${t('followAuto')} · ${t((model.automaticReasoning ?? model.reasoning) ? 'enableReasoning' : 'disableReasoning')}`), h('option', { value: 'on' }, t('enableReasoning')), h('option', { value: 'off' }, t('disableReasoning'))))),
+            h('option', { value: 'auto' }, `${t('followAuto')} · ${t((model.automaticReasoning ?? model.reasoning) ? 'enableReasoning' : 'disableReasoning')}`), h('option', { value: 'on' }, t('enableReasoning')), h('option', { value: 'off' }, t('disableReasoning')))),
+          (form.reasoningMode !== 'off') && h(ReasoningLevelsEditor, {
+            enabled: form.levelsMode === 'custom',
+            rows: form.rows,
+            detected: model.automaticReasoningLevels ?? [],
+            busy: a.pending,
+            onToggle: () => setForm({ ...form, levelsMode: form.levelsMode === 'custom' ? 'auto' : 'custom' }),
+            onChange: (rows) => setForm({ ...form, rows }),
+          })),
         h('details', { className: 'nas-editor-advanced' }, h('summary', null, t('advancedOptions')),
           h('div', { className: 'nas-two' },
             h(Field, { label: t('kind'), htmlFor: `${id}-kind` }, h('select', { id: `${id}-kind`, value: form.kind, onChange: changed('kind'), disabled: a.pending }, h('option', { value: '' }, t('auto')), ['chat', 'image', 'video', 'audio', 'embedding', 'other'].map((k) => h('option', { key: k, value: k }, t(k))))),
@@ -1032,6 +1222,7 @@ window.__ModuleLoader__.load({
                 m.kind === 'chat' ? `${t('context')}: ${m.effectiveContextWindow} / ${t('maxOutput')}: ${m.effectiveMaxTokens}` : t(m.kind),
                 `${t('source')}: ${m.source?.modelsDev?.provider || t('defaults')} · ${t(m.source?.modelsDev ? m.source.modelsDev.match === 'prefix' ? 'originPrefix' : 'originExact' : 'originNone')}`,
                 m.source?.overridden?.length ? `${t('overridden')}: ${m.source.overridden.join(', ')}` : null,
+                m.reasoning && m.reasoningLevels?.length ? `${t('reasoningLevels')}: ${m.reasoningLevels.map((l) => t('level_' + l)).join(' / ')}` : null,
               ].filter(Boolean).join('\n') },
                 m.kind === 'chat' ? h('span', { className: 'nas-cap-numbers' }, tokens(m.effectiveContextWindow), h('span', { className: 'nas-cap-divider' }, ' / '), tokens(m.effectiveMaxTokens)) : h('span', null, t(m.kind)),
                 h('span', { className: 'nas-cap-icons' },
@@ -1086,7 +1277,7 @@ window.__ModuleLoader__.load({
       const modelChannel = channels.find((c) => c.id === modelChannelId) || active;
       const count = (kind) => entries.filter((e) => e.kind === kind).length;
       const operate = (path, ch, key) => a.run(async () => { await store.mutate(path, { id: ch.id, revision: state.revision }); notify(key); });
-      return h('div', { className: 'nas nas-page', 'data-newapi-provider-version': '0.8.4' }, h(Styles), header,
+      return h('div', { className: 'nas nas-page', 'data-newapi-provider-version': '0.9.4' }, h(Styles), header,
         notice && h('div', { className: 'nas-feedback', role: 'status' }, h(Icon, { name: 'check', size: 14 }), notice),
         h(ErrorText, { text: a.error || error }),
         h('div', { className: 'nas-summary' },

package/index.js

@@ -45,6 +45,8 @@ const ModelOverride = z.object({
   input: z.array(z.union(MODALITIES)).default(undefined).description('Input modalities the model accepts.'),
   reasoning: z.boolean().description('Whether the model supports reasoning effort.'),
   reasoningLevels: z.array(z.union(LEVELS)).default(undefined).description('Reasoning effort levels to offer.'),
+  thinkingLevelMap: z.dict(z.union([z.string(), z.const(null)])).default(undefined)
+    .description('Per-level wire value: a string is sent upstream, null hides the level. Omitted levels fall back to the detected value.'),
   protocol: z.union(ENDPOINT_TYPES).description('Force the wire protocol for this model.'),
   custom: z.boolean().description('Add this model even if the gateway does not list it.'),
 });
@@ -461,9 +463,10 @@ export function apply(ctx, config) {
       fetchedAt: value.fetchedAt,
       pricingAvailable: value.pricingAvailable,
       pricingError: value.pricingError,
-      entries: value.entries.map((e) => ({
+      entries: value.entries.map(({ thinkingLevelMap, ...e }) => ({   // the map is wire detail; the UI gets the same data under its own name
         ...e,
         // Own-property read: built-in names such as `toString` are legal model ids.
+        automaticThinkingLevelMap: thinkingLevelMap ?? null,
         override: structuredClone(Object.hasOwn(captured.models ?? {}, e.id) ? captured.models[e.id] : {}),
         automaticContextWindow: e.automaticContextWindow ?? conn.defaultContextWindow,
         automaticMaxTokens: e.automaticMaxTokens ?? conn.defaultMaxTokens,
@@ -612,6 +615,8 @@ export function apply(ctx, config) {
             input: e.input,
             output: e.outputModalities,
             reasoning: e.reasoning,
+            reasoningLevels: e.reasoningLevels ?? [],
+            reasoningLevelsSource: e.reasoningLevelsSource ?? 'default',
             endpointTypes: e.endpointTypes,
             vendor: e.vendor,
             pricing: e.pricing,

package/lib/adapter.js

@@ -41,9 +41,14 @@ function baseUrlFor(baseURL, api) {
   return api === 'openai-completions' || api === 'openai-responses' ? openaiBase(baseURL) : gatewayRoot(baseURL);
 }
 
-/** Reasoning level map: explicit override levels, else "reasoning on" defaults. */
+/**
+ * Reasoning level map. The catalog resolves it per model — the user's override,
+ * pi-ai's own data for that id, or a vendor-family default — so pi-ai hides the
+ * levels this model cannot express instead of offering the same five everywhere.
+ */
 function thinkingLevelMap(entry) {
   if (!entry.reasoning) return undefined;
+  if (entry.thinkingLevelMap) return entry.thinkingLevelMap;
   if (!entry.reasoningLevels?.length) return undefined;
   const allowed = new Set(entry.reasoningLevels);
   return Object.fromEntries(LEVELS.map((l) => [l, allowed.has(l) ? l : null]));
@@ -163,9 +168,15 @@ export class NewApiAdapter extends LlmAdapter {
   async modelInfo(bound, provider, model, signal) {
     const info = await bound.inner.resolveModel(provider, model, signal);
     const entry = bound.catalog.entries.find((e) => e.id === model);
-    if (entry?.reasoningLevels?.length) info.reasoning = {
-      efforts: entry.reasoningLevels.map((l) => ({ id: ReasoningEffortId(l), name: l.charAt(0).toUpperCase() + l.slice(1) })),
-    };
+    // Report exactly the levels the request path can express: DSH rejects an effort
+    // it did not advertise, and clamps nothing, so these two must agree.
+    if (entry?.reasoning && entry.reasoningLevels?.length) {
+      const names = { off: 'Off', minimal: 'Minimal', low: 'Low', medium: 'Medium', high: 'High', xhigh: 'Extra high', max: 'Max' };
+      info.reasoning = {
+        efforts: entry.reasoningLevels.map((l) => ({ id: ReasoningEffortId(l), name: names[l] ?? l })),
+        ...(entry.reasoningLevels.includes('medium') ? { defaultEffort: ReasoningEffortId('medium') } : {}),
+      };
+    }
     if (entry?.maxTokens) info.defaultMaxTokens = entry.maxTokens;
     return info;
   }

package/lib/catalog.js

@@ -11,6 +11,7 @@
  * other) so chat models go to the picker and media models go to the tools.
  */
 import { fetchJson, gatewayRoot } from './util.js';
+import { LevelCatalog, resolveReasoningLevels } from './levels.js';
 
 export const DEFAULT_CONTEXT_WINDOW = 128_000;
 export const DEFAULT_MAX_TOKENS = 32_768;
@@ -44,9 +45,10 @@ function prettyName(id) {
 }
 
 export class Catalog {
-  constructor({ modelsDev, logger }) {
+  constructor({ modelsDev, logger, levels }) {
     this.modelsDev = modelsDev;
     this.logger = logger;
+    this.levels = levels ?? new LevelCatalog();
     this.cache = new Map();
     this.epoch = 0;
   }
@@ -81,11 +83,32 @@ export class Catalog {
     if (!force && hit && Date.now() - hit.at < CATALOG_TTL_MS && hit.overridesRev === conn.overridesRev) return hit.value;
     void this.modelsDev.refresh();
     const raw = await this.fetchGateway(conn, apiKey, signal);
-    const value = this.build(conn, raw);
+    const value = this.build(conn, raw, await this.resolveLevels(conn, raw));
     if (epoch === this.epoch) this.cache.set(key, { at: Date.now(), value, overridesRev: conn.overridesRev });
     return value;
   }
 
+  /**
+   * Reasoning levels for every id the catalog will contain, resolved before the
+   * synchronous build so each entry can carry its exact selector.
+   */
+  async resolveLevels(conn, { models }) {
+    const overrides = conn.overrides ?? {};
+    const ids = new Set((models?.data ?? []).map((m) => m?.id).filter(Boolean));
+    for (const [id, ov] of Object.entries(overrides)) if (ov?.custom === true) ids.add(id);
+    const out = new Map();
+    await Promise.all([...ids].map(async (id) => {
+      const own = Object.hasOwn(overrides, id) ? overrides[id] : undefined;
+      const override = Array.isArray(own?.reasoningLevels) && own.reasoningLevels.length ? own.reasoningLevels : undefined;
+      const overrideMap = own?.thinkingLevelMap && Object.keys(own.thinkingLevelMap).length ? own.thinkingLevelMap : undefined;
+      const hasOverride = Boolean(override || overrideMap);
+      const effective = await resolveReasoningLevels({ id, override, overrideMap, catalog: this.levels });
+      const automatic = hasOverride ? await resolveReasoningLevels({ id, catalog: this.levels }) : effective;
+      out.set(id, { effective, automatic });
+    }));
+    return out;
+  }
+
   /** Last good catalog for a connection without network, if any. */
   key(conn) {
     return JSON.stringify([conn.channelId, gatewayRoot(conn.baseURL), conn.keyFingerprint, conn.overridesRev, conn.headers, conn.enabledModels ?? null]);
@@ -95,7 +118,7 @@ export class Catalog {
     return this.cache.get(this.key(conn))?.value;
   }
 
-  build(conn, { models, pricing, pricingError }) {
+  build(conn, { models, pricing, pricingError }, levelInfo = new Map()) {
     const priced = new Map();
     for (const p of pricing?.data ?? []) priced.set(p.model_name, p);
     const vendors = new Map((pricing?.vendors ?? []).map((v) => [v.id, v.name]));
@@ -146,7 +169,11 @@ export class Catalog {
         automaticReasoning: dev?.reasoning ?? false,
         outputModalities: dev?.outputModalities ?? [],
         reasoning: ov.reasoning ?? dev?.reasoning ?? false,
-        reasoningLevels: ov.reasoningLevels,
+        // Only a reasoning model has a selector; image/embedding models show none.
+        reasoningLevels: (ov.reasoning ?? dev?.reasoning ?? false) ? levelInfo.get(id)?.effective.levels : [],
+        automaticReasoningLevels: (ov.reasoning ?? dev?.reasoning ?? false) ? levelInfo.get(id)?.automatic.levels : [],
+        reasoningLevelsSource: levelInfo.get(id)?.effective.source ?? 'default',
+        thinkingLevelMap: levelInfo.get(id)?.effective.map,
         source: {
           gateway: Boolean(localGatewayEntry),
           upstreamGateway: gateway.has(upstreamModel),

package/lib/channels.js

@@ -45,12 +45,26 @@ export function resolveChannels(raw = {}) {
 }
 
 /** Merge only supplied fields; null removes one override, reset removes the whole override. */
+/** A level map may only key known levels, and each value is a wire string or null. */
+function isValidLevelMap(value) {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) return false;
+  const entries = Object.entries(value);
+  if (!entries.length) return false;
+  return entries.every(([level, mapped]) => {
+    const known = LEVELS.includes(level);
+    // Custom names must be a safe id and must carry a value: that value is the whole point.
+    if (!known && !/^[a-z0-9][a-z0-9_-]{0,23}$/.test(level)) return false;
+    if (mapped === null) return known;
+    return typeof mapped === 'string' && mapped.length > 0 && mapped.length <= 64 && !/[\u0000-\u001f\u007f-\u009f]/.test(mapped);
+  });
+}
+
 export function mergeModelOverride(previous, patch, reset = false) {
   if (reset) return undefined;
   if (!patch || typeof patch !== 'object' || Array.isArray(patch)) throw channelError(400, 'override must be an object');
   const next = { ...previous };
   for (const [key, value] of Object.entries(patch)) {
-    if (!['name', 'upstreamModel', 'kind', 'hidden', 'contextWindow', 'maxTokens', 'input', 'reasoning', 'reasoningLevels', 'protocol', 'custom'].includes(key)) {
+    if (!['name', 'upstreamModel', 'kind', 'hidden', 'contextWindow', 'maxTokens', 'input', 'reasoning', 'reasoningLevels', 'thinkingLevelMap', 'protocol', 'custom'].includes(key)) {
       if (Object.hasOwn(previous ?? {}, key) && JSON.stringify(value) === JSON.stringify(previous[key])) continue;
       throw channelError(400, `unsupported override field: ${key}`);
     }
@@ -62,6 +76,7 @@ export function mergeModelOverride(previous, patch, reset = false) {
     else if (key === 'upstreamModel') valid = typeof value === 'string' && value.trim().length > 0 && value.length <= 500 && !/[\u0000-\u001f\u007f-\u009f]/.test(value);
     else if (key === 'kind') valid = KINDS.includes(value);
     else if (key === 'protocol') valid = PROTOCOLS.includes(value);
+    else if (key === 'thinkingLevelMap') valid = isValidLevelMap(value);
     else valid = Array.isArray(value) && value.every((v) => (key === 'input' ? MODALITIES : LEVELS).includes(v));
     if (!valid) throw channelError(400, `invalid override field: ${key}`);
     next[key] = ['name', 'upstreamModel'].includes(key) ? value.trim() : value;

package/lib/levels.js

@@ -0,0 +1,235 @@
+/**
+ * Reasoning ("thinking") levels per model.
+ *
+ * pi-ai renders a level selector from `thinkingLevelMap`: a `null` value hides that
+ * level, a string maps it to the vendor's own vocabulary, and an absent key falls
+ * back to the provider default. Without a map every reasoning model advertises the
+ * same five levels (`off`, `minimal`, `low`, `medium`, `high`) — which is wrong for
+ * vendors that cannot turn thinking off, have no effort parameter at all, or support
+ * `xhigh`/`max`.
+ *
+ * Resolution order, highest precedence first:
+ *   1. the user's per-model override (`reasoningLevels` in the channel config),
+ *   2. pi-ai's own shipped catalog for that model id — the exact map the built-in
+ *      providers use, so a model here behaves like the same model there,
+ *   3. a vendor-family default (below) when the id is a relay alias the catalog
+ *      does not know,
+ *   4. the pi-ai default (no map at all) for anything unrecognised.
+ */
+
+/** pi-ai's built-in level vocabulary, in display order. Custom names may be added on top. */
+export const LEVELS = ['off', 'minimal', 'low', 'medium', 'high', 'xhigh', 'max'];
+
+/** A level id: the built-ins, or a user-chosen name the upstream understands. */
+export const CUSTOM_LEVEL = /^[a-z0-9][a-z0-9_-]{0,23}$/;
+
+/** Preset levels first (pi's order), then custom names alphabetically. */
+export function orderLevels(names) {
+  const preset = LEVELS.filter((level) => names.includes(level));
+  const custom = names.filter((name) => !LEVELS.includes(name)).sort();
+  return [...preset, ...custom];
+}
+
+/** Provider catalogs to consult. Kept small: only vendors a New API relay resells. */
+const CATALOG_PROVIDERS = ['openai', 'anthropic', 'google', 'deepseek', 'zai', 'moonshotai', 'xai', 'minimax', 'alibaba'];
+
+/** First-party provider per model family, used to prefer the right catalog and default. */
+const FAMILY_RULES = [
+  [/^claude|^fable/, 'anthropic'],
+  [/^(gpt|o\d|codex|chatgpt|dall-e)/, 'openai'],
+  [/^gemini|^gemma/, 'google'],
+  [/^deepseek/, 'deepseek'],
+  [/^glm|^cogview|^cogvideo/, 'zai'],
+  [/^(kimi|moonshot)/, 'moonshotai'],
+  [/^grok/, 'xai'],
+  [/^(minimax|abab|hailuo)/, 'minimax'],
+  [/^(qwen|qwq|wan)/, 'alibaba'],
+];
+
+/**
+ * Family defaults for ids the catalog does not know (relay aliases such as
+ * `claude-opus-5-5` or `deepseek-v4.1-flash`). Each entry mirrors the shape pi-ai
+ * ships for that family; `null` hides a level, a string is sent upstream.
+ */
+const FAMILY_DEFAULTS = [
+  // Adaptive thinking: effort levels, no `minimal`, `max` available on every adaptive model.
+  [/^claude-(opus-([456]-?\d*|5)|sonnet-([456]|4-\d+|[56]-\d+)|fable|mythos)/, { off: null, minimal: null, low: 'low', medium: 'medium', high: 'high', xhigh: 'xhigh', max: 'max' }],
+  // Budget-based thinking: every level maps to a token budget, so all five apply.
+  // Older/unknown Claude: budget-based thinking covers every level (pi-ai ships no map).
+  [/^claude/, null],
+  // Pro variants expose a narrower set (gpt-5-pro: high only; later pros: medium+).
+  [/^gpt-5-pro/, { off: null, minimal: null, low: null, medium: null, high: 'high', xhigh: null, max: null }],
+  [/^gpt-5[.-][245]-pro/, { off: null, minimal: null, low: null, medium: 'medium', high: 'high', xhigh: 'xhigh', max: null }],
+  [/^gpt-6-astra/, { off: null, minimal: null, low: 'low', medium: 'medium', high: 'high', xhigh: 'xhigh', max: 'max' }],
+  [/^gpt-6[.-]1/, { off: null, minimal: null, low: 'low', medium: 'medium', high: 'high', xhigh: 'xhigh', max: 'max' }],
+  // GPT-5.1+ and GPT-6: "none" turns reasoning off; minimal is gone; xhigh/max exist.
+  [/^gpt-(5[.-][1-9]|5[.-]\d\d|6)/, { off: 'none', minimal: null, low: 'low', medium: 'medium', high: 'high', xhigh: 'xhigh', max: 'max' }],
+  // GPT-5.0: minimal exists, no xhigh/max.
+  [/^gpt-5/, { off: null, minimal: 'minimal', low: 'low', medium: 'medium', high: 'high', xhigh: null, max: null }],
+  // o-series: low/medium/high only.
+  [/^o\d/, { off: null, minimal: null, low: 'low', medium: 'medium', high: 'high', xhigh: null, max: null }],
+  // Gemini 3: two-step thinking level, cannot be switched off.
+  [/^gemini-[34]/, { off: null, minimal: 'MINIMAL', low: 'LOW', medium: 'MEDIUM', high: 'HIGH', xhigh: null, max: null }],
+  // Gemini 2.5: thinkingBudget; 0 disables it on flash models.
+  // Gemini 2.5 and older: budget-based, no level vocabulary (pi-ai ships no map).
+  [/^gemini/, null],
+  // DeepSeek V4 exposes effort with a gap at `medium`.
+  [/^deepseek/, { minimal: null, medium: null, low: 'low', high: 'high', max: 'max', xhigh: null }],
+  [/^glm-5[.-][3-9]/,  { off: null, minimal: null, low: 'low', medium: null, high: 'high', xhigh: null, max: 'max' }],
+  [/^glm-5[.-]2/,  { off: 'none', minimal: 'minimal', low: 'low', medium: 'medium', high: 'high', xhigh: 'xhigh', max: 'max' }],
+  [/^glm-5/, { off: 'none', minimal: null, low: 'low', medium: null, high: 'high', xhigh: null, max: 'max' }],
+  [/^glm/, null],
+  [/^(kimi-k3|moonshot-k3)/, { off: null, minimal: null, low: 'low', medium: null, high: 'high', xhigh: null, max: 'max' }],
+  [/^(kimi|moonshot)/, null],
+  [/^grok-4\.[5-9]/, { off: null, minimal: null, low: 'low', medium: 'medium', high: 'high', xhigh: null, max: null }],
+  [/^grok/, { off: 'none', minimal: null, low: 'low', medium: 'medium', high: 'high', xhigh: null, max: null }],
+];
+
+/** Normalise an id for catalog comparison: case, dots/underscores, vendor prefixes. */
+function normalize(id) {
+  return String(id).toLowerCase().split('/').pop().replace(/[._]/g, '-');
+}
+
+/** Index one provider catalog by its normalised ids. */
+function indexCatalog(catalog) {
+  const index = new Map();
+  for (const model of Object.values(catalog ?? {})) {
+    if (!model?.id) continue;
+    const key = normalize(model.id);
+    if (!index.has(key)) index.set(key, model);
+  }
+  return index;
+}
+
+/**
+ * Lazily loads and indexes pi-ai's shipped catalogs. Import failures are not fatal:
+ * the family defaults still give a model the right level set.
+ */
+export class LevelCatalog {
+  constructor({ providers = CATALOG_PROVIDERS } = {}) {
+    this.providers = providers;
+    this.index = undefined;
+    this.loading = undefined;
+    this.byFamily = new Map();
+  }
+
+  async load() {
+    if (this.index) return this.index;
+    this.loading ??= (async () => {
+      const index = new Map();
+      for (const name of this.providers) {
+        try {
+          const mod = await import(`@earendil-works/pi-ai/providers/${name}.models`);
+          for (const value of Object.values(mod)) {
+            const models = indexCatalog(value);
+            for (const [key, model] of models) if (!index.has(key)) index.set(key, model);
+          }
+        } catch { /* that provider catalog is absent in this pi-ai build */ }
+      }
+      this.index = index;
+      return index;
+    })();
+    return this.loading;
+  }
+
+  familyOf(id) {
+    const key = normalize(id);
+    for (const [re, provider] of FAMILY_RULES) if (re.test(key)) return provider;
+    return undefined;
+  }
+
+  /**
+   * pi-ai's own entry for this id: exact, then progressively shorter prefixes so a
+   * relay variant (`claude-opus-5-5`, `claude-sonnet-5-5-high`) lands on its base model.
+   */
+  async find(id) {
+    const index = await this.load();
+    const key = normalize(id);
+    const exact = index.get(key);
+    if (exact) return { model: exact, match: 'exact' };
+    const parts = key.split('-');
+    for (let n = parts.length - 1; n >= 2; n--) {
+      const hit = index.get(parts.slice(0, n).join('-'));
+      if (hit) return { model: hit, match: 'prefix' };
+    }
+    return undefined;
+  }
+
+  /** Family default map, or `undefined` when the family keeps the pi-ai default. */
+  familyDefault(id) {
+    const key = normalize(id);
+    if (this.byFamily.has(key)) return this.byFamily.get(key);
+    let map;
+    for (const [re, value] of FAMILY_DEFAULTS) if (re.test(key)) { map = value; break; }
+    this.byFamily.set(key, map);
+    return map;
+  }
+}
+
+/**
+ * Levels a map exposes, in pi-ai display order. `off`/`minimal`/`low`/`medium`/`high`
+ * are shown unless explicitly `null`; `xhigh`/`max` only when mapped.
+ */
+export function levelsFromMap(map) {
+  if (!map) return ['off', 'minimal', 'low', 'medium', 'high'];
+  const names = LEVELS.filter((level) => {
+    const mapped = map[level];
+    if (mapped === null) return false;
+    if (level === 'xhigh' || level === 'max') return mapped !== undefined;
+    return true;
+  });
+  // A custom level exists only when it is mapped to something the upstream accepts.
+  for (const [level, mapped] of Object.entries(map)) {
+    if (LEVELS.includes(level)) continue;
+    if (typeof mapped === 'string' && CUSTOM_LEVEL.test(level)) names.push(level);
+  }
+  return orderLevels(names);
+}
+
+/** Build a pi-ai map that exposes exactly `levels`, keeping `base`'s upstream strings. */
+export function mapFromLevels(levels, base) {
+  if (!Array.isArray(levels) || levels.length === 0) return undefined;
+  const allowed = new Set(levels);
+  const map = {};
+  for (const level of LEVELS) {
+    if (!allowed.has(level)) { map[level] = null; continue; }
+    const mapped = base?.[level];
+    map[level] = typeof mapped === 'string' ? mapped : level;
+  }
+  return map;
+}
+
+/**
+ * Resolve one model's reasoning levels.
+ *
+ * @returns `{ levels, map, source }` where `source` is `override` (user),
+ * `catalog` (pi-ai shipped data), `family` (vendor default) or `default`.
+ */
+export async function resolveReasoningLevels({ id, override, overrideMap, catalog }) {
+  const found = await catalog.find(id);
+  const base = found?.model?.thinkingLevelMap ?? catalog.familyDefault(id);
+  const source = found?.model?.thinkingLevelMap
+    ? 'catalog'
+    : base ? 'family' : 'default';
+  // An explicit level→wire map is authoritative: it is literally what the user configured.
+  if (overrideMap && typeof overrideMap === 'object' && Object.keys(overrideMap).length) {
+    // The table is authoritative: preset levels not listed are hidden, and custom names
+    // are honoured as long as they carry a wire value.
+    const map = {};
+    for (const level of LEVELS) {
+      const mapped = overrideMap[level];
+      map[level] = typeof mapped === 'string' ? mapped : null;
+    }
+    for (const [level, mapped] of Object.entries(overrideMap)) {
+      if (LEVELS.includes(level) || !CUSTOM_LEVEL.test(level)) continue;
+      if (typeof mapped === 'string') map[level] = mapped;
+    }
+    const levels = levelsFromMap(map);
+    // A table that exposes nothing usable is a mistake, not an empty selector: fall back.
+    if (levels.length) return { levels, map, source: 'override' };
+  }
+  if (Array.isArray(override) && override.length) {
+    return { levels: override.filter((l) => LEVELS.includes(l)), map: mapFromLevels(override, base), source: 'override' };
+  }
+  return { levels: levelsFromMap(base), map: base ?? undefined, source };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-newapi-provider",
-  "version": "0.8.4",
+  "version": "0.9.4",
   "description": "New API gateway for DeepSeek Harness: models with context and modality details, balance, image and video generation.",
   "license": "MIT",
   "author": "zenVibeCoding",