@lynn123411/dsh-model-submenu 0.2.5 → 0.3.1

package/src/client/model-facts.ts

@@ -0,0 +1,198 @@
+/**
+ * What the settings document knows about one model, for the picker's metadata
+ * line.
+ *
+ * The Host's model catalog carries only a name and a reasoning list; context
+ * window and accepted modalities live in each provider's settings profile,
+ * which the settings mirror already holds in the browser. This module joins
+ * the two by the identity both agree on: the catalog's provider route key and
+ * model id are exactly the settings profile's provider key and model id.
+ *
+ * Every field is answered independently. A provider whose profile lists no
+ * models (an OAuth route such as the Kimi subscription, or the account
+ * provider) answers `unknown` rather than guessing the route default, because
+ * the line's rule is to omit what cannot be asserted.
+ */
+
+/** Accepted-modality answer for one model. */
+export type ImageAnswer = 'yes' | 'no' | 'unknown'
+
+/**
+ * The model knowledge a shipped adapter carries for its own account route.
+ *
+ * The account route has no `models` list on purpose: the account listing
+ * supplies the catalog and settings only carry per-model overrides. The same
+ * adapter family ships a default catalog for its API-key route, and the account
+ * route serves the same models, so those entries answer what the account
+ * profile cannot. Ids and facts mirror the adapter's own table.
+ */
+const FAMILY_DEFAULTS: Readonly<Record<string, readonly {
+  readonly id: string
+  readonly contextWindow: number
+  readonly images: boolean
+}[]>> = {
+  'deepseek-account': [
+    { id: 'deepseek-flash', contextWindow: 1_000_000, images: true },
+    { id: 'deepseek-v4-pro', contextWindow: 1_000_000, images: false },
+  ],
+}
+
+/** The metadata the settings document can answer for one model. */
+export interface ModelFacts {
+  /** Exact advertised capacity, or undefined when the model declares none. */
+  readonly contextWindow: number | undefined
+  /** Whether the model accepts images; `unknown` means the document is silent. */
+  readonly images: ImageAnswer
+}
+
+/** One provider directory row, as the Host's LLM directory reports it. */
+export interface ConfigurableProviderRow {
+  readonly provider: string
+  readonly settingsNs: string
+  readonly settingsPath: readonly string[]
+}
+
+/** One settings namespace view, as the describe answer carries it. */
+export interface NamespaceRow {
+  readonly ns: string
+  readonly value: unknown
+}
+
+/** What one provider's profile may carry, across both adapter families. */
+interface ProfileView {
+  readonly models?: readonly Record<string, unknown>[]
+  readonly defaultContextWindow?: unknown
+  readonly defaultInput?: unknown
+}
+
+type Record_ = Record<string, unknown>
+
+/**
+ * Build the fact lookup from the settings answer.
+ * @param providers - provider directory rows giving each route's settings address.
+ * @param namespaces - the describe answer's namespace views.
+ * @returns a lookup answering both fields for one provider and model.
+ */
+export function buildModelFacts(
+  providers: readonly ConfigurableProviderRow[],
+  namespaces: readonly NamespaceRow[],
+): (provider: string, model: string) => ModelFacts {
+  const byName = new Map(namespaces.map((row) => [row.ns, row.value]))
+  const profiles = new Map<string, ProfileView>()
+  for (const row of providers) {
+    const section = byName.get(row.settingsNs)
+    const profile = readPath(section, row.settingsPath)
+    if (isRecord(profile)) profiles.set(row.provider, profile as ProfileView)
+  }
+  return (provider, model) => {
+    const profile = profiles.get(provider)
+    const entry = profile?.models === undefined
+      ? undefined
+      : profile.models.find((candidate) => candidate.id === model)
+    if (profile !== undefined && entry !== undefined) {
+      const window = typeof entry.contextWindow === 'number' && entry.contextWindow > 0
+        ? entry.contextWindow
+        : undefined
+      return { contextWindow: window, images: imageAnswer(entry, profile) }
+    }
+    // A route with no model list of its own (the account route) still serves its
+    // adapter family's models; a declared override there wins over the default.
+    const override = readOverride(profile, model)
+    if (override !== undefined) {
+      const window = typeof override.contextWindow === 'number' && override.contextWindow > 0
+        ? override.contextWindow
+        : undefined
+      return {
+        contextWindow: window,
+        images: Array.isArray(override.inputModalities) ? containsImage(override.inputModalities) : 'unknown',
+      }
+    }
+    const family = FAMILY_DEFAULTS[provider]?.find((candidate) => candidate.id === model)
+    return family === undefined
+      ? { contextWindow: undefined, images: 'unknown' }
+      : { contextWindow: family.contextWindow, images: family.images ? 'yes' : 'no' }
+  }
+}
+
+/**
+ * Read one model entry's accepted image modalities.
+ *
+ * The two adapter families disagree about an omission. The Messages family
+ * names the field `inputModalities`, and leaving it out means text only. The
+ * pi-ai family names it `input`, and an empty or absent list defers to the
+ * route's `defaultInput`; with no route default the answer stays unknown.
+ */
+function imageAnswer(entry: Record_, profile: ProfileView): ImageAnswer {
+  if (Array.isArray(entry.inputModalities)) return containsImage(entry.inputModalities)
+  const defaultInput = Array.isArray(profile.defaultInput) ? profile.defaultInput : undefined
+  if (Array.isArray(entry.input)) {
+    if (entry.input.length > 0) return containsImage(entry.input)
+    return defaultInput === undefined ? 'unknown' : containsImage(defaultInput)
+  }
+  return defaultInput === undefined ? 'no' : containsImage(defaultInput)
+}
+
+/** One model's declared override, when the route keeps a `modelOverrides` table. */
+function readOverride(profile: ProfileView | undefined, model: string): Record_ | undefined {
+  const overrides = (profile as Record_ | undefined)?.modelOverrides
+  if (!isRecord(overrides)) return undefined
+  const entry = overrides[model]
+  return isRecord(entry) ? entry : undefined
+}
+
+function containsImage(modalities: readonly unknown[]): ImageAnswer {
+  return modalities.includes('image') ? 'yes' : 'no'
+}
+
+/**
+ * Abbreviate one capacity the way the metadata line shows it.
+ * @param tokens - exact advertised capacity in tokens.
+ * @returns e.g. `1M ctx`, `1.5M ctx`, `272k ctx`, or `512 ctx` below a thousand.
+ */
+export function formatContextWindow(tokens: number): string {
+  if (tokens >= 1_000_000) return `${trimNumber(tokens / 1_000_000)}M ctx`
+  if (tokens >= 1_000) return `${Math.round(tokens / 1_000)}k ctx`
+  return `${tokens} ctx`
+}
+
+/**
+ * Build the metadata line's segments.
+ * @param input.providerName - the provider's display name, omitted inside that provider's own tab.
+ * @param input.facts - what the settings document answered.
+ * @param input.thinks - whether the catalog advertises reasoning levels for this model.
+ * @param input.effortLabel - the localized word for the reasoning segment.
+ * @param input.imageLabel - the localized word for the image segment.
+ * @returns the segments to join; an empty list means show no line.
+ */
+export function metaSegments(input: {
+  readonly providerName?: string
+  readonly facts: ModelFacts
+  readonly thinks: boolean
+  readonly effortLabel: string
+  readonly imageLabel: string
+}): readonly string[] {
+  const segments: string[] = []
+  if (input.providerName !== undefined) segments.push(input.providerName)
+  if (input.facts.contextWindow !== undefined) segments.push(formatContextWindow(input.facts.contextWindow))
+  if (input.thinks) segments.push(input.effortLabel)
+  if (input.facts.images === 'yes') segments.push(input.imageLabel)
+  return segments
+}
+
+function trimNumber(value: number): string {
+  const rounded = Math.round(value * 10) / 10
+  return Number.isInteger(rounded) ? String(rounded) : rounded.toFixed(1)
+}
+
+function readPath(value: unknown, path: readonly string[]): unknown {
+  let cursor = value
+  for (const key of path) {
+    if (!isRecord(cursor)) return undefined
+    cursor = cursor[key]
+  }
+  return cursor
+}
+
+function isRecord(value: unknown): value is Record_ {
+  return typeof value === 'object' && value !== null && !Array.isArray(value)
+}

package/src/client/rows.ts

@@ -0,0 +1,125 @@
+/**
+ * Catalog flattening, tab derivation, and query matching for the picker.
+ *
+ * The model catalog groups models by provider; the picker shows one flat list
+ * with a tab per provider, so both surfaces read from these rows. Matching
+ * delegates to the shell's own ranker, which is why a query behaves the same
+ * here as in the built-in menu: case-insensitive, ordered subsequence, prefix
+ * hits first.
+ */
+
+import type { ModelDirectoryState } from '@deepseek-ai/dsh-client-ui-model-selection/client'
+
+/** One provider group of the shared catalog. */
+export type ProviderGroup = ModelDirectoryState['groups'][number]
+
+/** One model inside a provider group. */
+export type CatalogModel = ProviderGroup['models'][number]
+
+/** One flat catalog row, carrying the provider identity beside the model. */
+export interface ModelRow extends ModelRef {
+  readonly providerName: string
+  /** The model id inside its provider, the other half of a selection. */
+  readonly model: string
+  /** The catalog entry itself, for name and reasoning metadata. */
+  readonly entry: CatalogModel
+}
+
+/** A provider and one of its models: the pair every selection and favorite names. */
+export interface ModelRef {
+  readonly provider: string
+  readonly model: string
+}
+
+/** One picker tab. */
+export interface PickerTab {
+  readonly id: string
+  readonly label: string
+}
+
+/** The tab id standing for every provider. */
+export const ALL_TAB = '*'
+
+/**
+ * Flatten the catalog to one row per model.
+ * @param groups - the shared directory's provider groups, in display order.
+ * @returns the rows in catalog order.
+ */
+export function flattenGroups(groups: readonly ProviderGroup[]): readonly ModelRow[] {
+  return groups.flatMap((group) => group.models.map((model) => ({
+    provider: group.id,
+    providerName: group.name,
+    model: model.id,
+    entry: model,
+  })))
+}
+
+/**
+ * Build the picker's tabs: the all-tab, then one per provider that has a model.
+ * @param groups - the shared directory's provider groups.
+ * @param allLabel - localized label for the all-tab.
+ * @returns the tabs in catalog order.
+ */
+export function pickerTabs(groups: readonly ProviderGroup[], allLabel = 'All'): readonly PickerTab[] {
+  return [
+    { id: ALL_TAB, label: allLabel },
+    ...groups.filter((group) => group.models.length > 0).map((group) => ({ id: group.id, label: group.name })),
+  ]
+}
+
+/**
+ * @param rows - the flat catalog.
+ * @param tab - the tab id; the all-tab keeps every row.
+ * @returns the rows the tab shows, in their current order.
+ */
+export function rowsForTab(rows: readonly ModelRow[], tab: string): readonly ModelRow[] {
+  return tab === ALL_TAB ? rows : rows.filter((row) => row.provider === tab)
+}
+
+/** One row handed to the shell's ranker, carrying both searchable keys. */
+export interface SearchCandidate {
+  readonly name: string
+  readonly label: string
+  readonly row: ModelRow
+}
+
+/**
+ * Shape rows as the shell's ranker candidates: the model name is the name, the
+ * provider display name is the second key, so a query reaches either.
+ * @param rows - the rows to search.
+ * @returns candidates in row order.
+ */
+export function searchCandidates(rows: readonly ModelRow[]): readonly SearchCandidate[] {
+  return rows.map((row) => ({ name: row.entry.name, label: row.providerName, row }))
+}
+
+/**
+ * Read the reasoning metadata the catalog advertises for one model.
+ * @param groups - the shared directory's provider groups.
+ * @returns the metadata, or undefined when that model advertises none.
+ */
+export function reasoningOf(
+  groups: readonly ProviderGroup[],
+): (provider: string, model: string) => CatalogModel['reasoning'] {
+  return (provider, model) => groups
+    .find((group) => group.id === provider)
+    ?.models.find((candidate) => candidate.id === model)
+    ?.reasoning
+}
+
+/**
+ * Filter rows by a query over the model name and the provider name.
+ * @param rows - the rows to search.
+ * @param query - the typed text; an empty or blank query keeps every row.
+ * @param rank - the shell's own ranker, so this search behaves like every other one.
+ * @returns the matching rows.
+ */
+export function searchRows(
+  rows: readonly ModelRow[],
+  query: string,
+  rank: (items: readonly SearchCandidate[], query: string) => readonly SearchCandidate[],
+): readonly ModelRow[] {
+  const trimmed = query.trim()
+  if (trimmed === '') return rows
+  return rank(searchCandidates(rows), trimmed).map((match) => match.row)
+}

package/src/client/selection.ts

@@ -0,0 +1,112 @@
+/**
+ * When the composer menu writes a selection.
+ *
+ * Both gestures are immediate: clicking a level submits it, clicking a model
+ * submits it. The only quiet path is clicking the model already in use — that
+ * closes the menu without a write. A model click also restores the level this
+ * browser last used for that model, so switching away and back never silently
+ * resets the effort.
+ */
+
+import type { ModelReasoning } from '@deepseek-ai/dsh-api-session-controller/types'
+
+/** One complete selection, as the directory's `select` takes it. */
+export interface Selection {
+  readonly provider: string
+  readonly model: string
+  readonly reasoningEffort?: string
+}
+
+/** One segment of the reasoning row. */
+export interface EffortChoice {
+  readonly key: string
+  readonly effort: string | undefined
+  readonly label: string
+}
+
+/**
+ * Build the segments for one model's reasoning row.
+ * @param reasoning - the catalog's reasoning metadata, undefined when the model has none.
+ * @param providerDefaultLabel - the localized label for the "follow the provider" segment.
+ * @returns the segments in catalog order; the provider-default one leads when the model declares no default.
+ */
+export function effortChoices(
+  reasoning: ModelReasoning | undefined,
+  providerDefaultLabel: string,
+): readonly EffortChoice[] {
+  if (reasoning === undefined) return []
+  return [
+    ...reasoning.defaultEffort === undefined
+      ? [{ key: 'provider-default', effort: undefined, label: providerDefaultLabel }]
+      : [],
+    ...reasoning.efforts.map((level) => ({
+      key: level.id,
+      effort: level.id as string | undefined,
+      label: level.name,
+    })),
+  ]
+}
+
+/**
+ * The selection a level click submits.
+ * @param live - the selection in force right now.
+ * @param effort - the clicked level, undefined meaning the provider default.
+ * @returns the selection to submit, or null when the level already is the live one.
+ */
+export function planEffortCommit(live: Selection, effort: string | undefined): Selection | null {
+  if (sameEffort(live.reasoningEffort, effort)) return null
+  return {
+    provider: live.provider,
+    model: live.model,
+    ...effort === undefined ? {} : { reasoningEffort: effort },
+  }
+}
+
+/**
+ * The selection a model click submits.
+ * @param live - the selection in force right now, null before a first selection resolves.
+ * @param provider - the clicked model's provider.
+ * @param model - the clicked model id.
+ * @param reasoningOf - the catalog's reasoning metadata for one provider and model.
+ * @param remembered - the level this browser last used for the target model, if any.
+ * @returns the selection to submit, or null when the click changes nothing.
+ */
+export function planModelCommit(
+  live: Selection | null,
+  provider: string,
+  model: string,
+  reasoningOf: (provider: string, model: string) => ModelReasoning | undefined,
+  remembered?: string | undefined,
+): Selection | null {
+  if (live !== null && sameModel(live, provider, model)) return null
+  const offered = reasoningOf(provider, model)
+  // The target model's own memory is restored, so switching away and back never
+  // silently resets the effort.
+  const carried = offered !== undefined
+    && remembered !== undefined
+    && offered.efforts.some((level) => level.id === remembered)
+  return {
+    provider,
+    model,
+    ...carried ? { reasoningEffort: remembered } : {},
+  }
+}
+
+/**
+ * @param live - one selection.
+ * @param provider - the provider to compare.
+ * @param model - the model id to compare.
+ * @returns whether both name the same model.
+ */
+export function sameModel(live: Selection, provider: string, model: string): boolean {
+  return live.provider === provider && live.model === model
+}
+
+/**
+ * @param liveEffort - the level in force, undefined meaning the provider default.
+ * @param effort - the level in question.
+ * @returns whether they name the same level.
+ */
+export function sameEffort(liveEffort: string | undefined, effort: string | undefined): boolean {
+  return liveEffort === effort
+}