zidane-ui 9.1.1 → 9.1.4

package/src/chat/headless/composer/model-names.ts

@@ -1,145 +0,0 @@
-/**
- * Model names as the model picker shows them (`Opus 4.5`), for every surface
- * that names a model: the context orb, the transcript's receipt and worker
- * rows, session details, settings. One catalog (and the provider labels of
- * the sign-in report), read on the first reader and kept current. A model
- * the catalog doesn't know keeps its id, made readable; so does every model
- * while the catalog can't be listed.
- */
-import { modelDisplayName, nameFromModelId, type ModelNamer } from 'zidane/chat/pure';
-
-import type { ResourceSnapshot } from '../../../app/headless/resource';
-import type { Readable } from '../store';
-import type { ComposerModels } from './host-chrome';
-import type { ModelCatalogRow } from './models';
-
-/** How models and providers are named. */
-export interface ModelNames {
-  /** A model's name. */
-  model: ModelNamer;
-  /** A provider's label (`Anthropic`); its key when nothing names it. */
-  provider: (providerKey: string) => string;
-}
-
-/** A provider as the sign-in report lists it. */
-export interface ModelNamesProvider {
-  /** The provider's key. */
-  key: string;
-  /** Its label. */
-  label: string;
-}
-
-/** The live names. */
-export interface ModelNamesStore {
-  /** The names now (a new object when the catalog changes). */
-  get(): ModelNames;
-  /** Registers a listener (the first one starts reading). Returns the unsubscribe. */
-  subscribe(listener: () => void): () => void;
-}
-
-/**
- * A namer reading `catalog`: the entry of that provider first, then any provider listing the id.
- *
- * @param catalog - The catalog rows.
- */
-export function namerFor(
-  catalog: readonly Pick<ModelCatalogRow, 'providerKey' | 'modelId' | 'modelName'>[],
-): ModelNamer {
-  const exact = new Map<string, string>();
-  const anyProvider = new Map<string, Pick<ModelCatalogRow, 'providerKey' | 'modelName'>>();
-  for (const entry of catalog) {
-    exact.set(`${entry.providerKey}\u0000${entry.modelId}`, entry.modelName);
-    if (!anyProvider.has(entry.modelId)) anyProvider.set(entry.modelId, entry);
-  }
-  return (modelId, providerKey) => {
-    const name = providerKey ? exact.get(`${providerKey}\u0000${modelId}`) : undefined;
-    const fallback = name === undefined ? anyProvider.get(modelId) : undefined;
-    return modelDisplayName({
-      providerKey: providerKey ?? fallback?.providerKey,
-      modelId,
-      modelName: name ?? fallback?.modelName,
-    }).name;
-  };
-}
-
-/**
- * Creates the names over a catalog and, optionally, the sign-in report's providers.
- * Both are read for the store's life once a reader subscribes.
- *
- * @param catalog - The model catalog.
- * @param providers - The providers, signed in or not (labels for those with no model listed).
- */
-export function createModelNames(
-  catalog: Readable<
-    ResourceSnapshot<readonly Pick<ModelCatalogRow, 'providerKey' | 'providerLabel' | 'modelId' | 'modelName'>[]>
-  >,
-  providers?: Readable<ResourceSnapshot<readonly ModelNamesProvider[]>>,
-): ModelNamesStore {
-  let names: ModelNames = { model: nameFromModelId, provider: (key) => key };
-  let wired = false;
-  let rows: ReturnType<typeof catalog.get>['data'] | null = null;
-  let known: readonly ModelNamesProvider[] = [];
-  const listeners = new Set<() => void>();
-
-  const rebuild = () => {
-    if (!rows) return;
-    // Provider labels from the sign-in report too: it lists every provider, signed in or not.
-    const labels = new Map<string, string>([
-      ...known.map((p) => [p.key, p.label] as const),
-      ...rows.map((e) => [e.providerKey, e.providerLabel] as const),
-    ]);
-    names = { model: namerFor(rows), provider: (key) => labels.get(key) ?? key };
-    for (const listener of listeners) listener();
-  };
-  const wire = () => {
-    if (wired) return;
-    wired = true;
-    // Readers for the store's life: never unsubscribed.
-    const onCatalog = () => {
-      const { data } = catalog.get();
-      if (!data || data === rows) return;
-      rows = data;
-      rebuild();
-    };
-    catalog.subscribe(onCatalog);
-    onCatalog();
-    if (providers) {
-      const onProviders = () => {
-        const { data } = providers.get();
-        if (!data || data === known) return;
-        known = data;
-        rebuild();
-      };
-      providers.subscribe(onProviders);
-      onProviders();
-    }
-  };
-
-  return {
-    get: () => names,
-    subscribe(listener) {
-      wire();
-      listeners.add(listener);
-      return () => listeners.delete(listener);
-    },
-  };
-}
-
-const stores = new WeakMap<ComposerModels, ModelNamesStore>();
-const BY_ID: ModelNamesStore = {
-  get: () => ({ model: nameFromModelId, provider: (key) => key }),
-  subscribe: () => () => undefined,
-};
-
-/**
- * The one {@link ModelNamesStore} over a host's `models` (this computer's catalog, and its providers when listed).
- * Without `models`, every model keeps its readable id.
- *
- * @param models - The host's member.
- */
-export function modelNamesOf(models: ComposerModels | undefined): ModelNamesStore {
-  if (!models) return BY_ID;
-  let store = stores.get(models);
-  if (!store) stores.set(models, (store = createModelNames(models.catalog(undefined, null), models.providers?.())));
-  return store;
-}

package/src/chat/headless/composer/model-picker-prefs.ts

@@ -1,90 +0,0 @@
-/**
- * Model picker preferences (`zg:model-picker:v1`): per device, like the
- * editor preferences. One live value the picker, its toggle and an app's
- * command palette entry share.
- */
-
-/** The Storage key the preferences live under. */
-export const MODEL_PICKER_STORAGE_KEY = 'zg:model-picker:v1';
-
-/** The model picker's preferences. */
-export interface ModelPickerPrefs {
-  /** The stored shape's version. */
-  version: 1;
-  /** List every model a provider serves, not only the newest of each family (`currentModelKeys`). */
-  showLegacy: boolean;
-}
-
-/** The preferences before any change. */
-export const DEFAULT_MODEL_PICKER_PREFS: ModelPickerPrefs = { version: 1, showLegacy: false };
-
-/**
- * Parses stored preferences; `undefined` when they are not JSON.
- *
- * @param raw - The stored string.
- */
-export function parseModelPickerPrefs(raw: string): ModelPickerPrefs | undefined {
-  try {
-    const o: unknown = JSON.parse(raw);
-    if (!o || typeof o !== 'object') return undefined;
-    const showLegacy = (o as { showLegacy?: unknown }).showLegacy;
-    return { version: 1, showLegacy: typeof showLegacy === 'boolean' ? showLegacy : false };
-  } catch {
-    return undefined;
-  }
-}
-
-/** The live preferences. */
-export interface ModelPickerPrefsStore {
-  /** The preferences now. */
-  get(): ModelPickerPrefs;
-  /** Changes them (and stores them). */
-  set(update: Partial<ModelPickerPrefs>): void;
-  /** Registers a listener called after they change. Returns the unsubscribe. */
-  subscribe(listener: () => void): () => void;
-}
-
-/** Where the preferences are stored. */
-export type ModelPickerPrefsStorage = Pick<Storage, 'getItem' | 'setItem'>;
-
-/**
- * Creates the preferences over a Storage, read on first use.
- *
- * @param storage - Where they are stored. Absent: `localStorage` when there is one, else memory only.
- */
-export function createModelPickerPrefs(storage?: ModelPickerPrefsStorage): ModelPickerPrefsStore {
-  const store = (): ModelPickerPrefsStorage | undefined =>
-    storage ?? (typeof localStorage === 'undefined' ? undefined : localStorage);
-  let state: ModelPickerPrefs | undefined;
-  const listeners = new Set<() => void>();
-  const read = (): ModelPickerPrefs | undefined => {
-    try {
-      const raw = store()?.getItem(MODEL_PICKER_STORAGE_KEY) ?? null;
-      return raw === null ? undefined : parseModelPickerPrefs(raw);
-    } catch {
-      return undefined;
-    }
-  };
-  const get = () => (state ??= read() ?? DEFAULT_MODEL_PICKER_PREFS);
-  return {
-    get,
-    set(update) {
-      const prev = get();
-      const next: ModelPickerPrefs = { ...prev, ...update, version: 1 };
-      if (next.showLegacy === prev.showLegacy) return;
-      state = next;
-      try {
-        store()?.setItem(MODEL_PICKER_STORAGE_KEY, JSON.stringify(next));
-      } catch {
-        // Non-fatal: the next launch falls back to the default.
-      }
-      for (const l of listeners) l();
-    },
-    subscribe(listener) {
-      listeners.add(listener);
-      return () => {
-        listeners.delete(listener);
-      };
-    },
-  };
-}

package/src/chat/headless/composer/models.ts

@@ -1,86 +0,0 @@
-/**
- * The model rows the composer's pickers list, as a host hands them over: chat
- * models (`ModelCatalogRow`, with the options each declares), image models
- * (`ImageModelRow`) and a pick (`ModelPickRef`). React-free, so hosts type
- * their catalogs without the styled layer.
- */
-
-/** A model pick: provider, model and, when the provider has several, the stored account it runs on. */
-export interface ModelPickRef {
-  /** Key of the provider, for example `anthropic`. */
-  providerKey: string;
-  /** Model id within the provider. */
-  modelId: string;
-  /** Id of the stored account the pick runs on. Only set when the provider has several. */
-  account?: string;
-}
-
-/** One row of the catalog. */
-export interface ModelCatalogRow {
-  /** Key of the provider that serves the model. */
-  providerKey: string;
-  /** Provider name shown as the group heading. */
-  providerLabel: string;
-  /** The provider's stored account this row runs on, when it has several. Absent: its only one. */
-  account?: { id: string; label: string; active?: boolean };
-  /** Model id within the provider. */
-  modelId: string;
-  /** The catalog's display name (`Claude Opus 4.6`); the row shows its natural form (`Opus 4.6`). */
-  modelName: string;
-  /** Attribution for an aggregator's row (`anthropic` on OpenRouter). */
-  modelProvider?: string;
-  /** Context window in tokens, or `null` when unknown. */
-  contextWindow: number | null;
-  /** The model supports reasoning effort. */
-  supportsReasoning: boolean;
-  /** A typed id the catalog does not know: used as typed, no metadata. */
-  offCatalog?: boolean;
-  /** Short facts shown beside the name, before the window (`ChatModel.details`). */
-  details?: readonly string[];
-  /** An image model that takes reference images (to edit, or to match a style). */
-  references?: boolean;
-  /** An image model that can make a transparent background. */
-  transparency?: boolean;
-  /** Why the row cannot be picked with the current credentials. The row shows, greyed out, and picking it does nothing. */
-  unavailable?: string;
-  /** Pre-lowercased search text. Default: provider key and label, account, id, name, attribution. */
-  searchCorpus?: string;
-}
-
-/** One image model, as the host lists it. */
-export interface ImageModelRow {
-  /** The provider's key, for example `openai`. */
-  providerKey: string;
-  /** The provider's display name. */
-  providerLabel: string;
-  /** The model's id at the provider. */
-  modelId: string;
-  /** The model's display name. */
-  modelName: string;
-  /** The model takes reference images. */
-  references: boolean;
-  /** The model can return a transparent background. */
-  transparency: boolean;
-  /** The provider's credentials can generate with it. */
-  available: boolean;
-  /** Why it is not available. */
-  reason?: string;
-  /** The model `generate_image` uses while no default is picked. */
-  isDefault?: boolean;
-}
-
-/** A feature toggle a model declares (fast mode, …). */
-export interface ComposerModelOption {
-  /** The option's id, a key of the session's enabled options. */
-  id: string;
-  /** Its name. */
-  label: string;
-  /** What it does. */
-  description?: string;
-}
-
-/** A catalog row with the options its model declares: what `ComposerModels.catalog` lists. */
-export interface ComposerModelEntry extends ModelCatalogRow {
-  /** The feature toggles the model declares. Absent or empty: none. */
-  options?: readonly ComposerModelOption[];
-}

package/src/chat/headless/composer/new-session-defaults.ts

@@ -1,68 +0,0 @@
-/**
- * What a new session starts with, React-free: the model the host remembers
- * as the next new chat's (`lastProvider` / `lastModelByProvider` in the
- * prefs), the patch a new pick writes there, and what the effort picker has
- * to set for a model (nothing: no dialog).
- */
-import type { ComposerContextStatus, ComposerPrefsState } from './host-chrome';
-import type { ComposerModelOption, ModelPickRef } from './models';
-
-/**
- * The model remembered as the next new chat's, `null` when there is none.
- * The account comes as remembered: check the catalog still serves it.
- *
- * @param prefs - The remembered picks.
- */
-export function rememberedDefaultModel(prefs: ComposerPrefsState | null | undefined): ModelPickRef | null {
-  const providerKey = typeof prefs?.lastProvider === 'string' ? prefs.lastProvider : null;
-  const byProvider = prefs?.lastModelByProvider;
-  const modelId = providerKey && byProvider && typeof byProvider === 'object' ? byProvider[providerKey] : undefined;
-  if (!providerKey || typeof modelId !== 'string' || !modelId) return null;
-  const account = prefs?.lastAccountByProvider?.[providerKey];
-  return { providerKey, modelId, ...(typeof account === 'string' && account ? { account } : {}) };
-}
-
-/**
- * The prefs patch that remembers `pick` as the next new chat's model.
- *
- * @param current - The remembered picks now.
- * @param pick - The new default.
- */
-export function defaultModelPatch(
-  current: ComposerPrefsState | null | undefined,
-  pick: ModelPickRef,
-): ComposerPrefsState {
-  const { providerKey, modelId, account } = pick;
-  const lastModelByProvider = { ...(current?.lastModelByProvider ?? {}), [providerKey]: modelId };
-  const lastAccountByProvider: Partial<Record<string, string>> = { ...(current?.lastAccountByProvider ?? {}) };
-  if (account) lastAccountByProvider[providerKey] = account;
-  else delete lastAccountByProvider[providerKey];
-  return { lastProvider: providerKey, lastModelByProvider, lastAccountByProvider };
-}
-
-/** What the effort picker sets for a session's model. */
-export interface EffortPickerTarget {
-  /** The model has a reasoning effort knob. */
-  supportsReasoning: boolean;
-  /** The feature toggles it declares. */
-  options: readonly ComposerModelOption[];
-  /** The options on now. */
-  enabled: Record<string, boolean>;
-}
-
-/**
- * What the effort picker offers for a session, `null` when its model has
- * nothing to set (no dead-end dialog).
- *
- * @param status - The session's context status (`null` while unknown).
- * @param sessionOptions - The session's own enabled options, which win over the status's.
- */
-export function effortPickerTarget(
-  status: ComposerContextStatus | null | undefined,
-  sessionOptions?: Record<string, boolean>,
-): EffortPickerTarget | null {
-  const supportsReasoning = status?.supportsReasoning ?? false;
-  const options = status?.availableOptions ?? [];
-  if (!supportsReasoning && options.length === 0) return null;
-  return { supportsReasoning, options, enabled: sessionOptions ?? status?.modelOptions ?? {} };
-}

package/src/chat/headless/composer/prompt-suggestions.ts

@@ -1,72 +0,0 @@
-/**
- * The next-prompt suggestion per session (`ComposerHost.suggestions`): the
- * latest one the host offered, until a run or compaction starts or a prompt
- * is sent. One store per host, started on its first subscriber.
- */
-import type { ComposerSuggestions } from './host';
-
-/** A suggested next prompt. */
-export interface PromptSuggestion {
-  /** The run it followed. */
-  runId: string;
-  /** The suggested prompt. */
-  text: string;
-}
-
-/** The suggestions of every session, as {@link createPromptSuggestionStore} keeps them. */
-export interface PromptSuggestionStore {
-  /** The session's suggestion, `null` when it has none. */
-  get(sessionId: string): PromptSuggestion | null;
-  /** Calls `listener` when the session's suggestion changes. Returns the unsubscribe. */
-  subscribe(sessionId: string, listener: () => void): () => void;
-  /** Drops the session's suggestion. */
-  clear(sessionId: string): void;
-}
-
-/**
- * Creates a {@link PromptSuggestionStore} over a host's suggestions.
- *
- * @param source - The host's `suggestions` member.
- */
-export function createPromptSuggestionStore(source: ComposerSuggestions): PromptSuggestionStore {
-  const suggestions = new Map<string, PromptSuggestion>();
-  const listeners = new Map<string, Set<() => void>>();
-  let started = false;
-
-  const notify = (sessionId: string) => {
-    for (const listener of listeners.get(sessionId) ?? []) listener();
-  };
-  const clear = (sessionId: string) => {
-    if (!suggestions.delete(sessionId)) return;
-    notify(sessionId);
-  };
-  const start = () => {
-    if (started) return;
-    started = true;
-    source.onReady(({ sessionId, runId, text }) => {
-      const prev = suggestions.get(sessionId);
-      if (prev?.runId === runId && prev.text === text) return;
-      suggestions.set(sessionId, { runId, text });
-      notify(sessionId);
-    });
-    source.onStale?.(clear);
-  };
-
-  return {
-    get: (sessionId) => suggestions.get(sessionId) ?? null,
-    subscribe(sessionId, listener) {
-      start();
-      let group = listeners.get(sessionId);
-      if (!group) {
-        group = new Set();
-        listeners.set(sessionId, group);
-      }
-      group.add(listener);
-      return () => {
-        group.delete(listener);
-        if (group.size === 0 && listeners.get(sessionId) === group) listeners.delete(sessionId);
-      };
-    },
-    clear,
-  };
-}

package/src/chat/headless/composer/remember-model-pick.ts

@@ -1,132 +0,0 @@
-/**
- * What of a model pick an app remembers as its default (the next new chat's
- * model, the prefs' `lastModelChain` the TUI launches with too): the rule the
- * TUI applies (`rememberableChain` in `zidane/chat/pure`), with "this
- * computer can run it" = a provider this computer is signed in to.
- */
-import { rememberableChain as rememberable } from 'zidane/chat/pure';
-
-import type { ResourceSnapshot } from '../../../app/headless/resource';
-import type { Readable } from '../store';
-import type { ComposerControls, ComposerModels, ComposerPrefs, ComposerRememberedModel } from './host-chrome';
-import type { ModelPickRef } from './models';
-
-/**
- * The chain to remember, `null` for nothing (no primary, or a primary only the server runs).
- *
- * @param chain - The picked chain.
- * @param scope - Whether it was picked on a server, and the providers this computer can run.
- */
-export function rememberableChain(
-  chain: readonly ModelPickRef[],
-  scope: { onServer: boolean; localProviders: ReadonlySet<string> },
-): ModelPickRef[] | null {
-  const kept = rememberable(chain, (entry) => entry.providerKey, {
-    onServer: scope.onServer,
-    canRunHere: (key) => scope.localProviders.has(key),
-  });
-  // A server's account ids name ITS credentials: here they would pin nothing (or the wrong account).
-  return kept && scope.onServer ? kept.map(({ account: _account, ...entry }) => entry) : kept;
-}
-
-/**
- * The first settled value of a resource (subscribing starts its read).
- *
- * @param resource - The resource.
- */
-export function settledResource<T>(resource: Readable<ResourceSnapshot<T>>): Promise<T> {
-  return new Promise<T>((resolve, reject) => {
-    let off: (() => void) | null = null;
-    let done = false;
-    const check = () => {
-      const snap = resource.get();
-      if (done) return;
-      if (snap.status === 'success' && snap.data !== undefined) {
-        done = true;
-        resolve(snap.data);
-      } else if (snap.status === 'error') {
-        done = true;
-        reject(snap.error instanceof Error ? snap.error : new Error(String(snap.error)));
-      } else return;
-      off?.();
-    };
-    off = resource.subscribe(check);
-    check();
-    if (done) off();
-  });
-}
-
-/**
- * {@link rememberableChain} for a pick made on `hostId` (a server, or `null` for this computer).
- *
- * @param chain - The picked chain.
- * @param hostId - Where it was picked.
- * @param models - This computer's catalog, to tell which providers it runs.
- */
-export async function rememberedPick(
-  chain: readonly ModelPickRef[],
-  hostId: string | null | undefined,
-  models: ComposerModels | undefined,
-): Promise<ModelPickRef[] | null> {
-  if (!hostId) return rememberableChain(chain, { onServer: false, localProviders: new Set() });
-  let localProviders = new Set<string>();
-  try {
-    if (models) {
-      const catalog = await settledResource(models.catalog(undefined, null));
-      localProviders = new Set(catalog.map((entry) => entry.providerKey));
-    }
-  } catch {
-    // This computer's providers unknown: remember nothing rather than a pick it may not run.
-  }
-  return rememberableChain(chain, { onServer: true, localProviders });
-}
-
-/**
- * The prefs' `lastModelChain` entries for a chain (core `ModelChainEntry` shape, account included).
- *
- * @param chain - The chain.
- */
-export function lastModelChainOf(chain: readonly ModelPickRef[]): ComposerRememberedModel[] {
-  return chain.map((e) => ({
-    provider: e.providerKey,
-    model: e.modelId,
-    ...(e.account ? { account: e.account } : {}),
-  }));
-}
-
-/** Sets the app's default model (the next new chat's); `persist: false` holds it for this window only. */
-export type SetDefaultModel = (pick: ModelPickRef, opts?: { persist?: boolean }) => void;
-
-/**
- * Commits a picked chain, the ONE path every model picker takes: the
- * session's model (when there is one), then the app's default (the next
- * chat's model and `lastModelChain`) when this computer can run it. A draft
- * whose pick only a server can run still launches under it: held for this
- * window, not remembered. `remember: false` (a side chat's pick) only sets
- * the session's model.
- *
- * @param host - The host's `controls`, `models` and `prefs`.
- * @param target - The session (`null`: a draft) and the host it runs on.
- * @param chain - The picked chain, primary first.
- * @param setDefaultModel - Sets the app's default model.
- * @param options - `remember: false` to leave the default alone.
- */
-export async function commitModelPick(
-  host: { controls?: ComposerControls; models?: ComposerModels; prefs?: ComposerPrefs },
-  target: { sessionId: string | null; hostId: string | null | undefined },
-  chain: readonly ModelPickRef[],
-  setDefaultModel: SetDefaultModel,
-  { remember = true }: { remember?: boolean } = {},
-): Promise<void> {
-  const primary = chain[0];
-  if (!primary) return;
-  if (target.sessionId) await host.controls?.setModel?.(target.sessionId, primary, chain.slice(1));
-  if (!remember) return;
-  const remembered = await rememberedPick(chain, target.hostId, host.models);
-  if (remembered?.[0]) {
-    setDefaultModel(remembered[0]);
-    await host.prefs?.set({ lastModelChain: lastModelChainOf(remembered) });
-  } else if (!target.sessionId) {
-    setDefaultModel(primary, { persist: false });
-  }
-}