dsh-code 1.0.2 → 1.0.3

package/src/model-capabilities.ts

@@ -0,0 +1,318 @@
+/**
+ * Same-id reasoning-capability inheritance for hand-declared pi-ai routes:
+ * the model catalog inherits capabilities by route key, not by model id, so a
+ * relay route listing `gpt-5.5` reads nothing from the installed `openai`
+ * catalog entry and materializes as `reasoning: false` until its settings
+ * entry declares `reasoningEfforts`. This adapter closes that gap without
+ * touching upstream: whenever a pi-ai profile's model entry carries no
+ * declaration and its live row advertises no efforts, but the same model id
+ * is declared (in a sibling settings entry) or advertised (on another route)
+ * elsewhere, the declaration is materialized into settings — verbatim from a
+ * sibling declaration when one exists, otherwise as an identity level map
+ * (`off` maps to null, every other level to its own name), which is the
+ * correct wire spelling for OpenAI-compatible relays. Writes ride the same
+ * `settings.mutate` path as the provider panel, so the upstream
+ * `assertServiceable` gate still rejects anything invalid atomically.
+ *
+ * @module @deepseek-ai/dsh-tui/model-capabilities
+ */
+
+import type { Context } from '@deepseek-ai/cordis'
+import { loadModelDirectory, type ModelRow } from './models.ts'
+
+/** The settings namespace the llm-pi-ai plugin owns (identity via `settingsNamespace`). */
+const PI_AI_SETTINGS_NS = 'llm-pi-ai'
+
+/** The effort level that means "send no reasoning parameter"; its wire value is always null. */
+const OFF_LEVEL = 'off'
+
+/* ------------------------------------------------------------------ *
+ * Structural service faces (same discipline as provider-settings: the
+ * settings package is never imported, only described structurally).
+ * ------------------------------------------------------------------ */
+
+/** One configurable-provider directory entry (subset of the `llm` service face). */
+interface ConfigurableEntryFace {
+  readonly provider: string
+  readonly settingsNs: string
+  readonly settingsPath: readonly string[]
+}
+
+/** One redacted settings descriptor (subset of `SettingsDescriptor`). */
+interface DescriptorFace {
+  readonly ns: string
+  readonly value: unknown
+  readonly revision: number
+}
+
+/** One path-addressed edit to a stored section (subset of `SettingsPathOp`). */
+interface PathOpFace {
+  readonly op: 'set' | 'unset'
+  readonly path: readonly string[]
+  readonly value?: unknown
+}
+
+/** The subset of the `settings` service this module reads and writes. */
+interface SettingsFace {
+  describe(options?: { readonly redactSecrets?: boolean }): readonly DescriptorFace[]
+  mutate(ns: string, ops: readonly PathOpFace[], expectedRevision?: number): Promise<void>
+}
+
+/** A notice sink structurally compatible with the app bridge's `notify`. */
+export type CapabilityNotice = (text: string, tone?: 'info' | 'warning' | 'error') => void
+
+/** Single-line a misbehaving error for the notice channel. */
+function singleLine(message: string): string {
+  const spaced = [...message].map(ch => { const code = ch.charCodeAt(0); return code < 32 || code === 127 ? ' ' : ch }).join('')
+  return spaced.split(' ').filter(part => part !== '').join(' ')
+}
+
+/** Human text for a rejection value. */
+function messageOf(error: unknown): string {
+  return error instanceof Error ? error.message : String(error)
+}
+
+/** Read the value at a path through plain objects; undefined when any segment misses. */
+function getPath(value: unknown, path: readonly string[]): unknown {
+  let current = value
+  for (const segment of path) {
+    if (typeof current !== 'object' || current === null) return undefined
+    current = (current as Record<string, unknown>)[segment]
+  }
+  return current
+}
+
+/** Whether a raw settings value is a usable `reasoningEfforts` dict (non-empty, non-false). */
+function isDeclaredEfforts(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null && !Array.isArray(value) && Object.keys(value).length > 0
+}
+
+/**
+ * The identity level map for an advertised effort list: `off` sends no
+ * parameter, every other level keeps its own name — the wire spelling
+ * OpenAI-compatible relays accept as-is.
+ */
+function identityEfforts(levels: readonly string[]): Record<string, string | null> {
+  const dict: Record<string, string | null> = {}
+  for (const level of levels) dict[level] = level === OFF_LEVEL ? null : level
+  return dict
+}
+
+/* ------------------------------------------------------------------ *
+ * Pure planning.
+ * ------------------------------------------------------------------ */
+
+/** One pi-ai provider profile as stored in settings, addressed for mutation. */
+export interface CapabilityProfileSource {
+  /** Settings namespace owning the profile (`llm-pi-ai`). */
+  readonly settingsNs: string
+  /** Path from the section root to this provider's profile. */
+  readonly settingsPath: readonly string[]
+  /** Revision of the owning section at read time. */
+  readonly revision: number
+  /** Raw model entries, exactly as stored (declaration fields included). */
+  readonly models: readonly Record<string, unknown>[]
+}
+
+/** One planned per-provider models rewrite. */
+export interface CapabilitySyncPlan {
+  /** Provider route the plan targets. */
+  readonly provider: string
+  /** Settings namespace owning the profile. */
+  readonly settingsNs: string
+  /** Path from the section root to the provider profile. */
+  readonly settingsPath: readonly string[]
+  /** Raw model entries, exactly as stored (declaration fields included). */
+  readonly models: readonly Record<string, unknown>[]
+  /** Fingerprint of the source models array this plan was derived from. */
+  readonly sourceFingerprint: string
+  /** Document revision of the owning section when the plan was derived. */
+  readonly sourceRevision: number
+  /** Model ids that gained a declaration, notice-facing. */
+  readonly inherited: readonly string[]
+  /** `provider/model` labels the declarations came from, notice-facing. */
+  readonly sources: readonly string[]
+}
+
+/**
+ * Plan the reasoning declarations to materialize. A model entry inherits
+ * when it declares nothing (`reasoningEfforts` absent — a dict or `false` is
+ * an explicit choice and is never touched) and its live row advertises no
+ * efforts; the donor is the first sibling settings declaration for the same
+ * id, copied verbatim so dialect wire spellings survive, otherwise the first
+ * other-route row advertising efforts for that id, mapped by identity.
+ * Entries never lose fields and keep their key order; a provider appears in
+ * the result only when at least one entry changes.
+ * @param input - the live model rows and the raw pi-ai profiles from settings.
+ * @returns one plan per provider with at least one inheritance.
+ */
+export function planCapabilitySync(input: {
+  readonly rows: readonly ModelRow[]
+  readonly profiles: ReadonlyMap<string, CapabilityProfileSource>
+}): readonly CapabilitySyncPlan[] {
+  // Sibling declarations, first profile order wins: { id -> { dict, provider } }.
+  const declared = new Map<string, { dict: Record<string, unknown>; provider: string }>()
+  for (const [provider, profile] of input.profiles) {
+    for (const entry of profile.models) {
+      const efforts = entry.reasoningEfforts
+      if (!isDeclaredEfforts(efforts)) continue
+      if (!declared.has(String(entry.id))) declared.set(String(entry.id), { dict: efforts, provider })
+    }
+  }
+  // Advertised donors, first row order wins: { id -> { levels, provider } }.
+  // A row whose only level is `off` advertises nothing usable and is skipped.
+  const advertised = new Map<string, { levels: readonly string[]; provider: string }>()
+  for (const row of input.rows) {
+    const levels = row.reasoning?.efforts.map(effort => effort.id) ?? []
+    if (levels.filter(level => level !== OFF_LEVEL).length === 0) continue
+    if (!advertised.has(row.model)) advertised.set(row.model, { levels, provider: row.provider })
+  }
+  const plans: CapabilitySyncPlan[] = []
+  for (const [provider, profile] of input.profiles) {
+    const inherited: string[] = []
+    const sources: string[] = []
+    const models = profile.models.map((entry): Record<string, unknown> => {
+      if (entry.reasoningEfforts !== undefined) return entry
+      const id = String(entry.id)
+      const sibling = declared.get(id)
+      if (sibling !== undefined && sibling.provider !== provider) {
+        inherited.push(id)
+        if (!sources.includes(`${sibling.provider}/${id}`)) sources.push(`${sibling.provider}/${id}`)
+        return { ...entry, reasoningEfforts: sibling.dict }
+      }
+      const donor = advertised.get(id)
+      if (donor !== undefined && donor.provider !== provider) {
+        inherited.push(id)
+        if (!sources.includes(`${donor.provider}/${id}`)) sources.push(`${donor.provider}/${id}`)
+        return { ...entry, reasoningEfforts: identityEfforts(donor.levels) }
+      }
+      return entry
+    })
+    if (inherited.length > 0) {
+      plans.push({
+        provider,
+        settingsNs: profile.settingsNs,
+        settingsPath: profile.settingsPath,
+        models,
+        sourceFingerprint: JSON.stringify(profile.models),
+        sourceRevision: profile.revision,
+        inherited,
+        sources,
+      })
+    }
+  }
+  return plans
+}
+
+/* ------------------------------------------------------------------ *
+ * Application.
+ * ------------------------------------------------------------------ */
+
+/** Provider -> the source snapshot and document revision its last write landed against. */
+const lastApplied = new Map<string, { fingerprint: string; revision: number }>()
+
+/** Fresh revision of one namespace, or undefined when it does not resolve. */
+function revisionOf(settings: SettingsFace, ns: string): number | undefined {
+  try {
+    for (const descriptor of settings.describe({ redactSecrets: true })) {
+      if (descriptor.ns === ns) return descriptor.revision
+    }
+  } catch {
+    return undefined
+  }
+  return undefined
+}
+
+/**
+ * Materialize same-id reasoning declarations once per provider. Reads the
+ * configurable directory, the redacted settings document, and the live model
+ * rows; plans; then writes each provider's merged models array through
+ * `settings.mutate` under a fresh revision (writes bump the section
+ * revision, so per-plan revisions are re-read). Every failure converges to a
+ * single-line notice — the caller's promise never rejects and the session
+ * keeps running on the previous configuration.
+ * @param ctx - context carrying the `llm` and `settings` services (optional).
+ * @param notify - the app bridge's notice sink, when one is live.
+ */
+export async function syncModelCapabilities(ctx: Context, notify?: CapabilityNotice): Promise<void> {
+  try {
+    const llm = ctx.get('llm') as { listConfigurableProviders?: () => readonly ConfigurableEntryFace[] } | undefined
+    if (llm?.listConfigurableProviders === undefined) return
+    const settings = ctx.get('settings') as SettingsFace | undefined
+    if (settings === undefined) return
+    let entries: readonly ConfigurableEntryFace[]
+    try {
+      entries = llm.listConfigurableProviders()
+    } catch {
+      return
+    }
+    const routed = entries.filter(entry => entry.settingsNs === PI_AI_SETTINGS_NS)
+    if (routed.length === 0) return
+    let descriptors: readonly DescriptorFace[]
+    try {
+      descriptors = settings.describe({ redactSecrets: true })
+    } catch {
+      return
+    }
+    const namespaces = new Map(descriptors.map(descriptor => [descriptor.ns, descriptor] as const))
+    const profiles = new Map<string, CapabilityProfileSource>()
+    for (const entry of routed) {
+      const namespace = namespaces.get(entry.settingsNs)
+      if (namespace === undefined) continue
+      const profile = entry.settingsPath.length === 0
+        ? namespace.value
+        : getPath(namespace.value, entry.settingsPath)
+      const models = Array.isArray((profile as { models?: unknown } | null)?.models)
+        ? (profile as { models: unknown }).models as readonly Record<string, unknown>[]
+        : undefined
+      // An absent models list is a dormant or unconfigured route: nothing to
+      // inherit into (and the empty allow-list there is deliberate upstream).
+      if (models === undefined) continue
+      profiles.set(entry.provider, {
+        settingsNs: entry.settingsNs,
+        settingsPath: entry.settingsPath,
+        revision: namespace.revision,
+        models,
+      })
+    }
+    if (profiles.size === 0) return
+    const directory = await loadModelDirectory(ctx)
+    for (const plan of planCapabilitySync({ rows: directory.rows, profiles })) {
+      // Skip only a provable echo of our own write: the same source
+      // snapshot at the same document revision we already wrote against
+      // (our write re-triggers the document event before the re-read
+      // catches up). An external edit that removes a materialized
+      // declaration bumps the revision, so identical source content
+      // re-plans and re-writes instead of being skipped forever.
+      const applied = lastApplied.get(plan.provider)
+      if (applied !== undefined && applied.fingerprint === plan.sourceFingerprint && applied.revision === plan.sourceRevision) continue
+      // Writes bump the section revision; re-read per plan so the second
+      // provider's optimistic revision is not already stale.
+      const revision = revisionOf(settings, plan.settingsNs)
+      if (revision === undefined) continue
+      try {
+        await settings.mutate(
+          plan.settingsNs,
+          [{ op: 'set', path: [...plan.settingsPath, 'models'], value: plan.models }],
+          revision,
+        )
+        lastApplied.set(plan.provider, { fingerprint: plan.sourceFingerprint, revision: plan.sourceRevision })
+        const shown = plan.sources.slice(0, 3).join(', ')
+        const more = plan.sources.length > 3 ? `, +${plan.sources.length - 3}` : ''
+        notify?.(
+          `inherited reasoning levels for ${plan.inherited.length} model${plan.inherited.length === 1 ? '' : 's'} on ${plan.provider} (from ${shown}${more})`,
+          'info',
+        )
+      } catch (error) {
+        notify?.(`capability inheritance failed on ${plan.provider}: ${singleLine(messageOf(error))}`, 'warning')
+      }
+    }
+  } catch {
+    // A background sync must never surface as an unhandled rejection.
+  }
+}
+
+/** Test seam: forget the applied-write fingerprints. */
+export function resetCapabilitySyncState(): void {
+  lastApplied.clear()
+}

package/src/provider-settings.ts

@@ -138,11 +138,16 @@ function configurationOf(profile: unknown): ProviderConfiguration {
     if (typeof value !== 'object' || value === null) return []
     const entry = value as Record<string, unknown>
     if (typeof entry.id !== 'string' || entry.id.trim() === '') return []
+    // Fields the editor does not understand ride along untouched: dropping
+    // them here would let the next save strip hand-written reasoningEfforts
+    // or compat declarations out of the stored profile.
+    const { id: _id, name: _name, contextWindow: _contextWindow, maxTokens: _maxTokens, ...extras } = entry
     return [{
       id: entry.id,
       ...(typeof entry.name === 'string' && entry.name.trim() !== '' ? { name: entry.name } : {}),
       ...(typeof entry.contextWindow === 'number' && Number.isFinite(entry.contextWindow) ? { contextWindow: entry.contextWindow } : {}),
       ...(typeof entry.maxTokens === 'number' && Number.isFinite(entry.maxTokens) ? { maxTokens: entry.maxTokens } : {}),
+      ...Object.keys(extras).length > 0 ? { extras } : {},
     }]
   })
   return {
@@ -194,6 +199,13 @@ export interface ProviderModelSettings {
   readonly name?: string
   readonly contextWindow?: number
   readonly maxTokens?: number
+  /**
+   * Remaining entry fields the editor does not model (`reasoningEfforts`,
+   * `compat`, `input`, …), carried verbatim so a save preserves them.
+   * Populated by {@link loadProviderSettings}; never contains the four
+   * modelled keys.
+   */
+  readonly extras?: Readonly<Record<string, unknown>>
 }
 
 /** The small, portable subset of a provider profile the terminal edits. */
@@ -514,6 +526,10 @@ export async function saveProviderConfiguration(
     }
     return {
       id,
+      // Editor-invisible fields ride along after the id; the modelled keys
+      // spread last so a panel edit (or clear) always wins over a carried
+      // value. extras never contains those keys — see configurationOf.
+      ...model.extras,
       ...(model.name === undefined || model.name.trim() === '' ? {} : { name: model.name.trim() }),
       ...(model.contextWindow === undefined ? {} : { contextWindow: model.contextWindow }),
       ...(model.maxTokens === undefined ? {} : { maxTokens: model.maxTokens }),