dsh-cline-pass 0.2.7 → 0.2.9

package/lib/client.js

@@ -505,7 +505,7 @@ window.__ModuleLoader__.load({
      * in front of it once an entry is no longer from today — a long-lived host
      * process would otherwise show times that look like they were all this hour.
      */
-    function stamp(value) {
+    function historyStamp(value) {
       const at = new Date(Number(value ?? 0))
       if (!Number.isFinite(at.getTime())) return '-'
       const pad = (part) => String(part).padStart(2, '0')
@@ -966,7 +966,7 @@ window.__ModuleLoader__.load({
             action: { kind: 'validate', model, data: result },
             notice: {
               kind: (summary.ok ?? 0) > 0 ? 'ok' : 'warn',
-              text: `${model} · available=${summary.ok ?? 0} rate-limited=${summary.limited ?? 0} not-pinnable=${summary.bad ?? 0} auth-failed=${summary.auth ?? 0}`,
+              text: `${model} · available=${summary.ok ?? 0} rate-limited=${summary.limited ?? 0} not-pinnable=${summary.bad ?? 0} auth-failed=${summary.auth ?? 0} unknown=${summary.unknown ?? 0}`,
             },
           })
         }
@@ -1163,12 +1163,8 @@ window.__ModuleLoader__.load({
      * whether any picker offers this model, and the one action that matters. The
      * finer pin actions and the channel list live behind the expander.
      *
-     * The expander holds the three steps that are not the one-click path:
-     * discovering channels (probe), verifying what actually serves the stored pin
-     * (test), and dropping it (reset). Validating every channel is what
-     * auto-configure already does before it pins, so it is not a separate button
-     * here — running it alone costs one real request per channel to re-learn
-     * verdicts the same click would have produced.
+     * Discover channels, validate them, and choose a pin explicitly. Validation
+     * costs one real request per channel; it does not change the stored pin.
      */
     function ModelRow(props) {
       const { t, model, disabled, actions } = props
@@ -1201,6 +1197,7 @@ window.__ModuleLoader__.load({
         open ? h('div', { key: 'detail', className: 'cp-panel' }, [
           h('div', { key: 'actions', className: 'cp-row' }, [
             action('probe', t('probe'), actions.probeModel),
+            action('validate', t('validate'), actions.validateModel),
             action('test', t('testPin'), actions.testModel),
             action('reset', t('reset'), actions.resetModel),
           ]),
@@ -1256,7 +1253,7 @@ window.__ModuleLoader__.load({
             onClick: () => actions.testKey(account.apiKeyEnv, ''),
           }, t('test')),
           active || !pooled ? null : h('button', {
-            key: 'use', type: 'button', className: 'cp-btn',
+            key: 'use', type: 'button', className: 'cp-btn', disabled,
             onClick: () => actions.setAccountMode({ active: account.key }),
           }, t('accountsSetActive')),
           h('button', {
@@ -1275,9 +1272,8 @@ window.__ModuleLoader__.load({
     /**
      * The accounts card.
      *
-     * One table: the key field belongs to the account a request would actually
-     * use, instead of to whichever account happened to be first, and the pool
-     * controls sit in the section body where they apply to the whole list.
+     * The key editor belongs to the account selected for editing. It stays put
+     * while requests rotate or cool down; quota follows the effective account.
      *
      * It folds like every other section, with one exception: before an account is
      * usable this is the only thing left to act on, so it opens itself. A card
@@ -1292,7 +1288,7 @@ window.__ModuleLoader__.load({
       const single = data.accountMode !== 'roundrobin'
       const fallback = data.accounts.find((account) => account.enabled)?.key ?? ''
       const activeKey = data.activeAccount === '' ? fallback : data.activeAccount
-      // The key field follows the account requests will actually use.
+      // Editing is an explicit account choice, independent of request rotation.
       const target = data.accounts.find((account) => account.key === activeKey) ?? data.accounts[0]
       // A row can be deleted only when an explicit `accounts` entry stands behind
       // it; a lone implicit account is the top-level key, so deleting it would
@@ -1357,7 +1353,7 @@ window.__ModuleLoader__.load({
         target === undefined ? null : h('div', { key: 'key', className: 'cp-row cp-acct-key' }, [
           h('span', { key: 'l', className: 'cp-muted' }, fill(t('accountsFor'), { name: target.displayName })),
           h(KeyField, {
-            key: 'field',
+            key: `field:${target.key}:${target.apiKeyEnv}`,
             t,
             account: target,
             disabled,
@@ -1471,7 +1467,7 @@ window.__ModuleLoader__.load({
           color: failed ? 'var(--dsw-alias-state-error-primary)' : 'var(--dsw-alias-state-success-primary)',
           title: failed ? entry.error : 'ok',
         })),
-        h('td', { key: 'when', className: 'cp-history-when' }, stamp(entry.ts)),
+        h('td', { key: 'when', className: 'cp-history-when' }, historyStamp(entry.ts)),
         // Model and its serving channel share a cell: the panel is ~480px wide and
         // a column of its own squeezed the model id — the one identifier a reader
         // scans for — down to a truncated stub.
@@ -1711,9 +1707,8 @@ window.__ModuleLoader__.load({
         void props.loadUsage().then((result) => setReadFailed(result === undefined))
       }, [state.data])
 
-      // The history section follows the host's retained count: every panel read
-      // carries it, so the rows are re-read whenever new requests landed instead
-      // of going stale the moment the first read completed.
+      // Revisions keep advancing when retained rows have reached the cap.
+      // Older hosts expose only the retained count.
       React.useEffect(() => {
         if (state.data === null) return
         let cancelled = false
@@ -1722,7 +1717,7 @@ window.__ModuleLoader__.load({
           setHistory({ entries: result.entries ?? [], total: Number(result.total ?? 0) })
         })
         return () => { cancelled = true }
-      }, [state.data?.historySize])
+      }, [state.data?.historyRevision ?? state.data?.historySize])
 
   
   
@@ -1885,7 +1880,7 @@ window.__ModuleLoader__.load({
           h('span', { key: 'n', className: 'cp-grow' }, data?.ready === true ? t('keyOk') : t('keyMissing')),
         ]),
         account === undefined ? null : h(KeyField, {
-          key: 'key',
+          key: `key:${account.key}:${account.apiKeyEnv}`,
           t,
           account,
           disabled: state.busy !== null || data?.settingsAvailable === false,
@@ -2105,6 +2100,7 @@ window.__ModuleLoader__.load({
     /** A local timestamp, matching the panel's own reading of "updated at". */
     function stamp(ms) {
       const at = new Date(Number(ms ?? 0))
+      if (!Number.isFinite(at.getTime())) return '-'
       const pad = (n) => String(n).padStart(2, '0')
       return `${at.getFullYear()}/${at.getMonth() + 1}/${at.getDate()} ${pad(at.getHours())}:${pad(at.getMinutes())}:${pad(at.getSeconds())}`
     }
@@ -2181,12 +2177,12 @@ window.__ModuleLoader__.load({
       // 3. The quota reading beside the model selector. It mounts for every
       //    session but renders nothing unless the selected model is this
       //    provider's, so no other model pays for a usage request.
-      ctx.slots.inject('conversation.input.right', () => ctx.slots.register({
+      const registerUsage = (usageCtx) => usageCtx.slots.inject('conversation.input.right', () => usageCtx.slots.register({
         name: 'conversation.input.right',
         id: `${NS}-usage`,
         order: 100,
         inject: (sessionId) => ({
-          directory: ctx.modelDirectories.directoryFor(sessionId).store,
+          directory: usageCtx.modelDirectories.directoryFor(sessionId).store,
           // The route name is configuration, so it is only known once a state
           // read has landed. Read it at render time rather than capturing it:
           // the pill can mount before the first read completes.
@@ -2207,6 +2203,12 @@ window.__ModuleLoader__.load({
         }),
       }, UsagePill))
 
+      // Newer Cordis service methods execute in the consumer's context. The
+      // directory resolver reads remote.session, so give this slot its explicit
+      // dependency without requiring that newer service on legacy hosts.
+      if (ctx.get('remote.session') !== undefined) ctx.inject(['remote.session'], registerUsage)
+      else registerUsage(ctx)
+
       // The first read is lazy (each component asks for it), because the RPC
       // transport only exists once Connection has activated.
       void controller.refresh()

package/lib/cline.js

@@ -8,10 +8,13 @@
  * - `GET  {baseURL}/users/{id}/usages` — the per-request usage history behind them
  * - `GET  api.cline.bot/.../recommended-models` — official subscription list
  * - `GET  models.dev/api.json` — community registry, a backstop
+ * - `GET  ai-gateway.vercel.sh/v1/models` — the upstream's own catalog
  * - `GET  openrouter.ai/api/v1/...` — endpoint detail for direct-pipeline models
  *
  * @module dsh-cline-pass/cline
  */
+
+import { REASONING_EFFORTS } from './catalog.js'
 /** The public Cline endpoint that lists subscription models without auth. */
 export const RECOMMENDED_MODELS_URL = 'https://api.cline.bot/api/v1/ai/cline/recommended-models'
 /** The authenticated sub-path that reports quota consumption for the account. */
@@ -36,6 +39,17 @@ const DAY_MS = 86_400_000
 export const MODEL_ROWS_MAX = 8
 /** The community model registry. */
 export const MODELS_DEV_URL = 'https://models.dev/api.json'
+/**
+ * The upstream gateway's own model catalog.
+ *
+ * It is the only source that publishes the reasoning levels behind a Cline Pass
+ * model. Cline Pass does not: its `/models` carries ids only, and its gateway
+ * accepts every level in the harness vocabulary for every model, so an unsupported
+ * one cannot even be probed out — a level outside the vocabulary is the only
+ * rejection it makes. The route is named in the gateway's own failures
+ * (`… from Vercel`), and that catalog is open.
+ */
+export const VERCEL_MODELS_URL = 'https://ai-gateway.vercel.sh/v1/models'
 /** OpenRouter's public API, used only for direct-pipeline endpoint detail. */
 export const OPENROUTER_API = 'https://openrouter.ai/api/v1'
 
@@ -147,6 +161,38 @@ function modelMetadata(entry) {
   return meta
 }
 
+/**
+ * The reasoning levels one model offers, from the upstream's `reasoning_options`.
+ *
+ * An `effort` entry names the levels; a `toggle` entry is the model's on/off switch,
+ * which in the harness vocabulary is `none`. Returned in escalating order so the
+ * picker reads in one direction whatever order the catalog happened to list.
+ *
+ * Models published with only a toggle, or only a token budget, name no levels at
+ * all. Those return undefined rather than an invented list, and the caller keeps the
+ * full vocabulary — narrowing a model to a single `none` would take away the switch
+ * the catalog just described.
+ *
+ * @returns the level ids, or undefined when the entry names none.
+ */
+function effortsFromOptions(options) {
+  if (!Array.isArray(options)) return undefined
+  const levels = new Set()
+  let toggle = false
+  for (const option of options) {
+    if (option?.type === 'toggle') toggle = true
+    if (option?.type !== 'effort' || !Array.isArray(option.values)) continue
+    for (const value of option.values) if (typeof value === 'string' && value.length > 0) levels.add(value)
+  }
+  // A toggle on its own names nothing to choose from — it says the switch exists,
+  // not what to set it to — so it is not narrowed to a lone `none`, which would
+  // offer "off" and take away the switch the catalog just described.
+  if (levels.size === 0) return undefined
+  if (toggle) levels.add('none')
+  const ordered = REASONING_EFFORTS.map((effort) => effort.id).filter((id) => levels.has(id))
+  return ordered.length > 0 ? ordered : undefined
+}
+
 /**
  * List the gateway's own catalog ids.
  * @returns the model ids; an empty array when the call fails or returns nothing.
@@ -307,11 +353,56 @@ export async function fetchOfficialModels({ signal, timeoutMs = 30000, fetchImpl
       }
     }
   } catch { /* source unavailable */ }
+  // The upstream's own catalog, matched by the id's tail: `cline-pass/glm-5.3` and
+  // `zai/glm-5.3` are the same model reached through the same gateway. It is also
+  // the only source that describes a model published after this release — Cline Pass
+  // lists ids, names and descriptions, and says nothing about what a model can do,
+  // so without this a new model falls back to the route's conservative window.
+  //
+  // Its output cap is deliberately NOT taken. It disagrees with the published one
+  // (32k where the shipped table says 384k) and it moves: the same model reported a
+  // different figure a week later. Adopting it would silently resize every request's
+  // completion reserve, which is what decides where compaction fires.
+  const upstreamByTail = new Map()
+  try {
+    const response = await fetchImpl(VERCEL_MODELS_URL, { signal: withTimeout(signal, timeoutMs) })
+    if (response.ok) {
+      const json = await response.json()
+      const rows = Array.isArray(json?.data) ? json.data : Array.isArray(json?.models) ? json.models : []
+      for (const row of rows) {
+        if (typeof row?.id !== 'string') continue
+        // The shared extractor already reads the display name and `modalities.input`,
+        // and it deliberately misses this catalog's snake_case output cap — which is
+        // exactly the field that must not be adopted.
+        const meta = modelMetadata(row)
+        const contextWindow = row?.context_window ?? row?.contextWindow
+        if (Number.isSafeInteger(contextWindow) && contextWindow > 0) meta.contextWindow = contextWindow
+        const efforts = effortsFromOptions(row.reasoning_options)
+        if (efforts !== undefined) meta.efforts = efforts
+        if (Object.keys(meta).length > 0) upstreamByTail.set(row.id.split('/').pop(), meta)
+      }
+      if (upstreamByTail.size > 0) sources.push('vercel')
+    }
+  } catch { /* source unavailable */ }
   const models = [...found.keys()].filter((id) => /^cline-pass\/[a-z0-9._-]+$/.test(id))
   const catalog = {}
   for (const id of models) {
-    const meta = found.get(id)
-    if (meta !== undefined && Object.keys(meta).length > 0) catalog[id] = meta
+    const meta = found.get(id) ?? {}
+    const upstream = upstreamByTail.get(id.slice('cline-pass/'.length))
+    if (upstream === undefined) {
+      if (Object.keys(meta).length > 0) catalog[id] = meta
+      continue
+    }
+    // Fills what the other sources leave out, so an id list that carries only a name
+    // still yields a real window, real levels and real modalities. A source that did
+    // describe a field keeps it: this is a gap filler, not an override.
+    const entry = { ...upstream, ...meta }
+    // The exception is the name, where the id list's "name" is the id itself and
+    // says nothing — the upstream publishes the label a person reads.
+    if (upstream.name !== undefined && (entry.name === undefined || entry.name === id || entry.name === id.slice('cline-pass/'.length))) {
+      entry.name = upstream.name
+    }
+    catalog[id] = entry
   }
   return { models, catalog, sources }
 }

package/lib/compat.js

@@ -145,10 +145,37 @@ export function installLiveSection(settings, owner, ns, schema, seed, hooks) {
  * @param removals - key paths to delete, e.g. `[['accounts', 'name']]`.
  */
 export async function updateLiveSection(settings, ns, patch, removals = []) {
+  if (removals.length > 0 && typeof settings?.mutate !== 'function') {
+    throw new Error('the settings service cannot remove configuration keys')
+  }
   if (removals.length > 0 && typeof settings?.mutate === 'function') {
     // Unset first, then merge the rest: the merge cannot resurrect a key the
     // unset already removed, because the patch no longer mentions it.
     await settings.mutate(ns, removals.map((path) => ({ op: 'unset', path: [...path] })))
   }
   if (Object.keys(patch).length > 0) await settings.update(ns, patch)
-}
+}
+
+/** The same recursive patch semantics for hosts without a settings service. */
+export function patchConfig(config, patch, removals = []) {
+  const merge = (source, changes) => {
+    const next = { ...source }
+    for (const [key, value] of Object.entries(changes)) {
+      next[key] = value !== null && typeof value === 'object' && !Array.isArray(value)
+        ? merge(source?.[key], value)
+        : value
+    }
+    return next
+  }
+  const unset = (source, path) => {
+    if (source === null || typeof source !== 'object' || path.length === 0) return source
+    const [key, ...rest] = path
+    const next = { ...source }
+    if (rest.length === 0) delete next[key]
+    else if (Object.hasOwn(next, key)) next[key] = unset(next[key], rest)
+    return next
+  }
+  let next = config
+  for (const path of removals) next = unset(next, path)
+  return merge(next, patch)
+}

package/lib/engine.js

@@ -25,6 +25,7 @@ import {
   errorText,
   extractAvailableProviders,
   injectPrefs,
+  isAuthenticationError,
   isAdherenceOk,
   mergeUpstreams,
   parseRouting,
@@ -210,8 +211,8 @@ export function createEngine({
     })
     const payload = unwrapEnvelope(result.json)
     const ms = Date.now() - started
-    if (payload?.error !== undefined && payload?.choices === undefined) {
-      const message = errorText(payload.error)
+    if (!result.ok || (payload?.error !== undefined && payload?.choices === undefined) || !Array.isArray(payload?.choices) || payload.choices.length === 0) {
+      const message = errorText(payload?.error) || String(payload?.message ?? '') || result.text.slice(0, 400) || (result.ok ? 'gateway returned no completion' : `HTTP ${result.status}`)
       store.learn(model, { ok: false, lastError: message, lastMs: ms })
       return { ok: false, ms, model, error: message }
     }
@@ -342,15 +343,16 @@ export function createEngine({
           const ms = Date.now() - started
           let status = 'unknown'
           let note = ''
-          if (payload?.error !== undefined && payload?.choices === undefined) {
-            note = errorText(payload.error)
-            status = classifyUpstreamError(note)
+          if (!result.ok || (payload?.error !== undefined && payload?.choices === undefined)) {
+            note = errorText(payload?.error) || result.text || `HTTP ${result.status}`
+            status = isAuthenticationError(note, result.status) ? 'auth' : classifyUpstreamError(note)
           } else if (payload?.choices !== undefined) {
             const routing = parseRouting(payload)
             const adherence = pinAdherence(attempt, routing)
-            if (isAdherenceOk(adherence)) {
+            if (adherence === 'adopted') {
               status = 'ok'
-              if (adherence === 'fallback') note = `answered by ${routing.finalProvider ?? 'another channel'}`
+            } else if (adherence === 'unresolved') {
+              note = 'the response did not name the serving channel; the pin could not be verified'
             } else {
               status = 'not-adopted'
               note = `pin not adopted: served by ${routing.finalProvider ?? '(unknown)'}`
@@ -362,7 +364,7 @@ export function createEngine({
         }
       }))
       for (const result of settled) {
-        store.learnUpstream(model, result.upstream, result.status, result.note, result.ms)
+        store.learnUpstream(model, result.upstream, result.status, result.note, result.ms, { includeUnknown: true })
         results.push(result)
       }
     }
@@ -463,12 +465,18 @@ export function createEngine({
       })
       const payload = unwrapEnvelope(result.json)
       const ms = Date.now() - started
-      if (payload?.error !== undefined && payload?.choices === undefined) {
-        const message = errorText(payload.error)
-        const authFailed = /unauthorized|re-authenticate|invalid\s*api|401/i.test(message)
-        return { ok: !authFailed, authorized: !authFailed, ms, model, error: message }
-      }
-      return { ok: true, authorized: true, ms, model, error: '' }
+      const message = errorText(payload?.error) || String(payload?.message ?? '') || (result.ok ? '' : result.text.slice(0, 400)) || (result.ok ? '' : `HTTP ${result.status}`)
+      if (isAuthenticationError(message, result.status)) return { ok: false, authorized: false, ms, model, error: message || `HTTP ${result.status}` }
+      const hasCompletion = result.ok && Array.isArray(payload?.choices) && payload.choices.length > 0
+      // A structured model/quota refusal can establish authorization without a
+      // completion. Server failures, HTML and malformed success bodies cannot.
+      const modelError = /empty response content|\bmodel(?:id)?\b|context|max[_ -]?tokens|reasoning|no (?:allowed|available) providers/i.test(message)
+      const modelRefusal = payload?.error !== undefined && (
+        [402, 429].includes(result.status)
+        || ((result.ok || [400, 404, 422].includes(result.status)) && modelError)
+      )
+      const authorized = hasCompletion || modelRefusal
+      return { ok: authorized, authorized, ms, model, error: authorized && hasCompletion ? '' : (message || 'gateway returned no completion; authorization could not be verified') }
     } catch (error) {
       return { ok: false, authorized: false, ms: Date.now() - started, model, error: errorText(error) }
     }

package/lib/index.js

@@ -28,7 +28,7 @@ import {
   DEFAULT_STREAM_IDLE_TIMEOUT_MS,
 } from './adapter.js'
 import { catalogEntry, MODEL_CATALOG, REASONING_EFFORTS } from './catalog.js'
-import { installLiveSection, liveConfigReader, markVolatile, resolveLiveRefs, updateLiveSection } from './compat.js'
+import { installLiveSection, liveConfigReader, markVolatile, patchConfig, resolveLiveRefs, updateLiveSection } from './compat.js'
 import { createEngine } from './engine.js'
 import { createPanel, PANEL_PATH, registerPanel } from './panel.js'
 import { BUILD_TAG } from './protocol.js'
@@ -294,18 +294,29 @@ export function apply(ctx, config) {
    * avoid. Keeping one ordering is also what stops the cooldown rule from being
    * applied in one place and forgotten in the other.
    */
-  const candidateAccounts = (exclude = []) => {
+  const candidateAccounts = async (exclude = []) => {
     const skip = new Set(exclude.map(String))
-    const enabled = accountProfiles().filter(([, profile]) => profile.enabled)
+    const failures = []
+    const resolved = await Promise.all(accountProfiles().filter(([key, profile]) => profile.enabled && !skip.has(key)).map(async ([key, profile]) => {
+      try {
+        const value = await resolveKey(profile.apiKeyEnv)
+        if (value === undefined) throw new LlmError(`cline-pass: no API key for account "${key}"; store it at ${profile.apiKeyEnv} or configure another account`, 'MISSING_CREDENTIAL')
+        return [key, profile, assertUsableApiKey(value, 'cline-pass', profile.apiKeyEnv)]
+      } catch (error) {
+        failures.push(error)
+        return undefined
+      }
+    }))
+    const enabled = resolved.filter((entry) => entry !== undefined)
     // Accounts that just refused a request are stood down for a while, so a pool
     // does not spend one failed round trip per call rediscovering the same
     // exhausted key. When every candidate is cooling the oldest one is used
     // anyway: a window can reset, and refusing to try at all would be worse.
     const now = Date.now()
     const eligible = enabled.filter(([key]) => !skip.has(key) && (cooling.get(key) ?? 0) <= now)
-    if (eligible.length > 0) return eligible
+    if (eligible.length > 0) return { ordered: eligible, error: failures[0] }
     const pool = enabled.filter(([key]) => !skip.has(key))
-    return [...pool].sort((left, right) => (cooling.get(left[0]) ?? 0) - (cooling.get(right[0]) ?? 0))
+    return { ordered: [...pool].sort((left, right) => (cooling.get(left[0]) ?? 0) - (cooling.get(right[0]) ?? 0)), error: failures[0] }
   }
 
   /**
@@ -315,9 +326,9 @@ export function apply(ctx, config) {
    * account is in line must not move it either — otherwise showing the user their
    * quota would change which account answers them.
    */
-  const effectiveAccount = () => {
+  const effectiveAccount = async () => {
     const cfg = live()
-    const ordered = candidateAccounts()
+    const { ordered } = await candidateAccounts()
     if (ordered.length === 0) return ''
     if (cfg.accountMode === 'roundrobin' && ordered.length > 1) return ordered[roundRobin % ordered.length][0]
     return (ordered.find(([key]) => key === cfg.activeAccount) ?? ordered[0])[0]
@@ -330,8 +341,11 @@ export function apply(ctx, config) {
     if (enabled.length === 0) {
       throw new LlmError('cline-pass: every configured account is disabled; enable one or add another', 'MISSING_CREDENTIAL')
     }
-    const ordered = candidateAccounts(exclude)
-    if (ordered.length === 0) return undefined
+    const { ordered, error } = await candidateAccounts(exclude)
+    if (ordered.length === 0) {
+      if (exclude.length > 0) return undefined
+      throw error ?? new LlmError('cline-pass: no usable account credentials', 'MISSING_CREDENTIAL')
+    }
     let picked
     if (cfg.accountMode === 'roundrobin' && ordered.length > 1) {
       picked = ordered[roundRobin % ordered.length]
@@ -339,15 +353,8 @@ export function apply(ctx, config) {
     } else {
       picked = ordered.find(([key]) => key === cfg.activeAccount) ?? ordered[0]
     }
-    const [key, profile] = picked
-    const value = await resolveKey(profile.apiKeyEnv)
-    if (value === undefined) {
-      throw new LlmError(
-        `cline-pass: no API key for account "${key}"; store it at ${profile.apiKeyEnv} (cline_pass_accounts action="add" name=${key} key=… writes it, or use the dsh Models page), or export ${profile.apiKeyEnv} in the launching environment`,
-        'MISSING_CREDENTIAL',
-      )
-    }
-    return { name: key, key: assertUsableApiKey(value, 'cline-pass', profile.apiKeyEnv), baseURL: profile.baseURL }
+    const [key, profile, value] = picked
+    return { name: key, key: value, baseURL: profile.baseURL }
   }
 
   // ── connection facts ──────────────────────────────────────────────────────
@@ -524,12 +531,8 @@ export function apply(ctx, config) {
   const updateConfig = async (patch, removals = []) => {
     const settings = ctx.get('settings')
     if (settings === undefined) {
-      const next = { ...liveConfig, ...patch }
-      for (const path of removals) {
-        if (path.length === 1) delete next[path[0]]
-        else if (path.length === 2 && next[path[0]] !== undefined) delete next[path[0]][path[1]]
-      }
-      liveConfig = next
+      liveConfig = patchConfig(live(), patch, removals)
+      current = () => liveConfig
       return
     }
     await updateLiveSection(settings, DEFAULT_SETTINGS_NS, patch, removals)

package/lib/panel.js

@@ -14,6 +14,7 @@
  * @module dsh-cline-pass/panel
  */
 import { fetchUsageLimits } from './cline.js'
+import { accountProfileFor } from './accounts.js'
 import { normalizePinMode } from './protocol.js'
 
 /**
@@ -121,7 +122,8 @@ export function createPanel({ control, engine, store }) {
     const accounts = (await control.accountsWithKeys()).map((account) => accountView(account, declaredNames.has(String(account.key))))
     const hidden = new Set((config.hiddenModels ?? []).map(String))
     const models = (config.knownModels ?? []).map((id) => projectModel(id, config.perModel?.[id] ?? {}, store.metaOf(id), hidden.has(String(id))))
-    const usable = accounts.some((account) => account.keyConfigured && account.enabled)
+    const effectiveAccount = await control.effectiveAccount()
+    const usable = effectiveAccount !== '' && accounts.some((account) => account.keyConfigured && account.enabled)
     const pinned = models.filter((model) => model.pinned.length > 0).length
     return {
       provider: control.providerName,
@@ -134,7 +136,7 @@ export function createPanel({ control, engine, store }) {
       // one: `activeAccount` only decides single mode, and round-robin picks from
       // the cursor. Usage is per account, so a reading has to name the account it
       // belongs to or the surface showing it describes someone else's quota.
-      effectiveAccount: control.effectiveAccount(),
+      effectiveAccount,
       accounts,
       ready: usable,
       models,
@@ -144,6 +146,7 @@ export function createPanel({ control, engine, store }) {
       usage: store.usage(),
       catalogCount: Number(store.catalog()?.ids?.length ?? 0),
       historySize: store.historySize(),
+      historyRevision: store.historyRevision(),
       // The stored value, not the running one: the switch states what the user
       // wants, and reporting the running value would snap it back to where it
       // started the moment they clicked it, which reads as a failed click. The
@@ -253,15 +256,13 @@ export function createPanel({ control, engine, store }) {
     const ref = String(payload?.ref ?? '').trim()
     const config = readConfig()
     let key = typed
-    let baseURL = String(config.baseURL ?? '')
-    let label = typed.length > 0 ? '(typed key)' : ref
+    const account = ref === '' ? undefined : control.accounts().find((entry) => String(entry.apiKeyEnv) === ref)
+    const baseURL = String(account?.baseURL ?? '') || String(config.baseURL ?? '')
+    const label = String(account?.key ?? (typed.length > 0 ? '(typed key)' : ref))
     if (key.length === 0) {
       if (ref.length === 0) throw new Error('testing a key needs a `value` or the `ref` of a stored account')
-      const account = control.accounts().find((entry) => String(entry.apiKeyEnv) === ref)
       key = await control.readCredential(ref)
       if (key === '') throw new Error(`no key is stored at ${ref}`)
-      baseURL = String(account?.baseURL ?? '') || baseURL
-      label = String(account?.key ?? ref)
     }
     const model = (config.knownModels ?? [])[0] ?? 'cline-pass/glm-5.3-flash'
     const result = await engine.testAccount({ key, baseURL, model })
@@ -289,14 +290,9 @@ export function createPanel({ control, engine, store }) {
         baseURL: '',
       }
     }
-    const apiKeyEnv = String(payload?.apiKeyEnv ?? '').trim()
-      || `CLINE_PASS_${name.toUpperCase().replace(/[^A-Z0-9]+/g, '_')}_KEY`
-    accounts[name] = {
-      displayName: String(payload?.displayName ?? '').trim() || name,
-      apiKeyEnv,
-      enabled: payload?.enabled !== false,
-      baseURL: '',
-    }
+    const profile = accountProfileFor(name, payload, accounts, config.apiKeyEnv)
+    const apiKeyEnv = profile.apiKeyEnv
+    accounts[name] = profile
     await control.updateConfig({ accounts })
     const value = String(payload?.key ?? '').trim()
     if (value.length > 0) await control.setCredential(apiKeyEnv, value)
@@ -476,6 +472,7 @@ export function createPanel({ control, engine, store }) {
         effort: String(entry.effort ?? ''),
         stream: entry.stream === true,
         error: firstLine(entry.error, 200),
+        code: String(entry.code ?? ''),
       })),
     }
   }