zidane-ui 9.1.1 → 9.1.4

package/src/adapters/server-session-host.ts

@@ -1,241 +0,0 @@
-/**
- * A `SessionHost` on a running zidane-server: todo lists (`todos.get` /
- * `todos.set`, `todos:snapshot` pushes), the type-ahead queue (`queue.*`,
- * `queue:changed` pushes), artifacts (`sessions.artifacts`,
- * `artifacts.delete`, `artifact:recorded` / `artifact:changed` wake-ups),
- * running work (`chat.listWork` / `chat.cancelWork`, `work:snapshot`
- * pushes), turns (`sessions.getTurn`, `sessions.fork`,
- * `sessions.editTurnText`, `sessions.deleteTurn`, `sessions.rewind`) and the details actions
- * (`sessions.generateTitle`, `sessions.compact`, `sessions.setFolder`,
- * `sessions.cacheReport`), and a session's `/side` chat (`sessions.sideSession`,
- * `sessions.create` with `sideOf`, `sessions.delete`). On a server that has
- * them: an artifact row re-resolved (`artifacts.refresh`), a title's status
- * (`sessions.titleStatus`), the usage summary (`usage.summary`, over the
- * server's store), the providers' plan windows (`usage.providers`, with
- * the server's credentials) and GitHub's API limits (`usage.github`). The
- * transcript export (`sessions.export`) is offered when
- * the app says where the file goes (`saveExport`): the server renders it,
- * nothing is written there.
- * Share the chat host's client: `createServerSessionHost({ client: chat.client })`.
- *
- * The server answers stored artifacts, not rendered rows (the kind registry
- * that renders them runs in the host process), so each row shows the
- * artifact's label and links a web URI, grouped under the raw kind.
- */
-import type { HostSignal, SessionRow } from 'zidane/ipc';
-import type { ServerClient } from 'zidane/ipc/browser';
-
-import { createArtifactsState, groupArtifactRows, plainArtifactRow } from '../session/headless/artifacts';
-import type { SessionArtifact, SessionExportFormat, SessionHost, SideChatSession } from '../session/headless/host';
-import { createQueueState } from '../session/headless/queue';
-import { createRunningWorkState } from '../session/headless/running-work';
-import { createTodosState } from '../session/headless/todos';
-import type { UsageRange } from '../session/headless/usage';
-
-/** Options for {@link createServerSessionHost}. */
-export interface ServerSessionHostOptions {
-  /** The client to speak through, shared with the chat host (`createServerHost(…).client`). */
-  client: ServerClient;
-  /**
-   * Hands an exported transcript to the user (a browser download) and resolves what to show as where it went.
-   * Absent: no export.
-   */
-  saveExport?: (file: { filename: string; content: string; format: SessionExportFormat }) => Promise<string>;
-}
-
-/** The {@link SessionHost} {@link createServerSessionHost} returns. */
-export interface ServerSessionHost extends SessionHost {
-  /** Stops listening to the client (it leaves the client open). */
-  close(): void;
-}
-
-/**
- * Creates a {@link SessionHost} over a zidane-server client.
- *
- * @param options - The client to speak through.
- */
-export function createServerSessionHost(options: ServerSessionHostOptions): ServerSessionHost {
-  const { client, saveExport } = options;
-
-  const todos = createTodosState((sessionId) => client.call('todos.get', { sessionId }));
-  const queue = createQueueState({
-    list: (sessionId) => client.call('queue.list', { sessionId }),
-    remove: (sessionId, id) => client.call('queue.remove', { sessionId, id }),
-    update: (sessionId, id, text, attachments) =>
-      client.call('queue.update', { sessionId, id, text, ...(attachments ? { attachments } : {}) }),
-  });
-  const work = createRunningWorkState((sessionId) => client.call('chat.listWork', { sessionId }));
-  const artifacts = createArtifactsState(async (sessionId) =>
-    groupArtifactRows((await client.call('sessions.artifacts', { sessionId })).map(plainArtifactRow)),
-  );
-
-  const onSignal = (signal: HostSignal) => {
-    switch (signal.kind) {
-      case 'todos:snapshot':
-        todos.push(signal.sessionId, signal.snapshot);
-        break;
-      case 'queue:changed':
-        queue.replace(signal.sessionId, signal.items);
-        break;
-      case 'artifact:recorded':
-      case 'artifact:changed':
-        artifacts.wake(signal.sessionId);
-        break;
-      case 'work:snapshot':
-        work.push(signal.sessionId, signal.items);
-        break;
-      case 'sessions:changed':
-        if (signal.op === 'delete') todos.forget(signal.sessionId);
-        break;
-    }
-  };
-  const unsubscribe = [
-    client.onSignal(onSignal),
-    // A new connection may be a different server process: its queues are another store.
-    client.onOpen((_hello, reconnected) => {
-      if (reconnected) queue.reset(true);
-    }),
-  ];
-
-  return {
-    todos: {
-      snapshot: todos.snapshot,
-      refresh: todos.refresh,
-      set: async (sessionId, items) => (await client.call('todos.set', { sessionId, items })) !== null,
-      retry: async (sessionId, message) => {
-        await client.call('chat.pushQueued', { sessionId, message, requestId: crypto.randomUUID() });
-      },
-    },
-    queue: {
-      items: queue.items,
-      refresh: queue.refresh,
-      add: async (sessionId, text, add) =>
-        (
-          await client.call('queue.add', {
-            sessionId,
-            text,
-            // One id per submission: the host runs a resend of it once.
-            requestId: crypto.randomUUID(),
-            ...(add?.activatedSkills ? { activatedSkills: add.activatedSkills } : {}),
-            ...(add?.attachments ? { attachments: add.attachments } : {}),
-          })
-        ).delivered,
-      remove: queue.drop,
-      update: queue.edit,
-      attachments: (sessionId, id) => client.call('queue.attachments', { sessionId, id }).catch(() => null),
-      pushNow: async (sessionId, id) => (await client.call('queue.pushNow', { sessionId, id })).delivered,
-    },
-    artifacts: {
-      groups: artifacts.groups,
-      refresh: artifacts.refresh,
-      remove: (sessionId, artifactId, owner) =>
-        client.call('artifacts.delete', { sessionId: owner ?? sessionId, artifactId }),
-      ...(client.can('artifacts.refresh')
-        ? {
-            // The change comes back as `artifact:changed`, which wakes the panel.
-            refreshRow: async (sessionId: string, artifact: SessionArtifact, options?: { force?: boolean }) => {
-              await client
-                .call('artifacts.refresh', {
-                  sessionId: artifact.sessionId || sessionId,
-                  artifactId: artifact.id,
-                  ...(options?.force ? { force: true } : {}),
-                })
-                .catch(() => undefined);
-            },
-          }
-        : {}),
-    },
-    runningWork: {
-      items: work.items,
-      refresh: work.refresh,
-      ensure: work.ensure,
-      cancel: (sessionId, id, reason) =>
-        client.call('chat.cancelWork', { sessionId, id, ...(reason ? { reason } : {}) }),
-    },
-    turns: {
-      get: (sessionId, turnId) => client.call('sessions.getTurn', { sessionId, turnId }),
-      fork: async (sessionId, turnId) => (await client.call('sessions.fork', { sessionId, turnId })).id,
-      editText: async (sessionId, turnId, text) => {
-        await client.call('sessions.editTurnText', { sessionId, turnId, text });
-      },
-      delete: async (sessionId, turnId) => {
-        await client.call('sessions.deleteTurn', { sessionId, turnId });
-      },
-      rewind: async (sessionId, turnId, { inclusive }) => {
-        await client.call('sessions.rewind', { sessionId, turnId, inclusive });
-      },
-    },
-    details: {
-      generateTitle: async (sessionId) => (await client.call('sessions.generateTitle', { sessionId })).title,
-      compact: async (sessionId) => {
-        await client.call('sessions.compact', { sessionId });
-      },
-      setFolder: async (sessionId, folder) => {
-        await client.call('sessions.setFolder', { sessionId, cwd: folder ?? '' });
-      },
-      cacheReport: (sessionId) => client.call('sessions.cacheReport', { sessionId }),
-      ...(client.can('sessions.titleStatus')
-        ? { titleStatus: (sessionId: string) => client.call('sessions.titleStatus', { sessionId }) }
-        : {}),
-      ...(saveExport && client.can('sessions.export')
-        ? {
-            export: async (sessionId: string, format: SessionExportFormat) =>
-              saveExport({ ...(await client.call('sessions.export', { sessionId, format })), format }),
-          }
-        : {}),
-    },
-    ...(client.can('usage.summary') || client.can('usage.providers') || client.can('usage.github')
-      ? {
-          usage: {
-            ...(client.can('usage.summary')
-              ? { summary: (range: UsageRange) => client.call('usage.summary', { range }) }
-              : {}),
-            ...(client.can('usage.providers')
-              ? {
-                  providers: (options?: { refresh?: boolean }) =>
-                    client.call('usage.providers', options?.refresh ? { refresh: true } : {}),
-                }
-              : {}),
-            ...(client.can('usage.github')
-              ? {
-                  github: (options?: { probe?: boolean }) =>
-                    client.call('usage.github', options?.probe ? { probe: true } : {}),
-                }
-              : {}),
-          },
-        }
-      : {}),
-    ...(client.can('sessions.sideSession')
-      ? {
-          side: {
-            lookup: (parentId: string) => client.call('sessions.sideSession', { sessionId: parentId }),
-            create: (parentId: string, cwd: string, parent: SideChatSession | null) => {
-              // The parent's model and effort (`lookup` answers its row).
-              const from = parent as SessionRow | null;
-              return client.call('sessions.create', {
-                cwd,
-                sideOf: parentId,
-                agentId: 'plan',
-                title: 'Side chat',
-                ...(from?.providerKey && from.modelId ? { providerKey: from.providerKey, modelId: from.modelId } : {}),
-                ...(from?.effort ? { effort: from.effort } : {}),
-                ...(from?.modelOptions ? { modelOptions: from.modelOptions } : {}),
-              });
-            },
-            async remove(sideId: string) {
-              if (await client.call('chat.isRunning', { sessionId: sideId }))
-                await client.call('chat.interrupt', { sessionId: sideId });
-              await client.call('sessions.delete', { sessionId: sideId });
-            },
-            subscribe: (onChange: (sessionId: string) => void) =>
-              client.onSignal((signal: HostSignal) => {
-                if (signal.kind === 'sessions:changed' && signal.op === 'update') onChange(signal.sessionId);
-              }),
-          },
-        }
-      : {}),
-    close() {
-      for (const off of unsubscribe) off();
-    },
-  };
-}

package/src/adapters/server-settings-accounts.ts

@@ -1,212 +0,0 @@
-/**
- * The Accounts and MCP servers groups of the zidane-server `SettingsHost`
- * (`createServerSettingsHost`), over the shared browser client:
- *
- * - `providers`: `auth.status` (read again after each action and handshake;
- *   a provider's configuration fields with it), `auth.setApiKey`,
- *   `auth.configure` (the fields), `auth.remove` (one credential, or every
- *   one: Clear, a sign-out), `auth.setPreferred` (the credential in use),
- *   `auth.rename` (an OAuth account) and browser sign-ins over
- *   `auth.oauth.*` (`serverOAuthFlow`). Writes need the `admin` scope; the
- *   sections hide them when `writable` is false.
- * - `mcp`: the server's `catalog.mcps` for a folder there with each
- *   server's state (sign-in, tools, last Test), kept current by
- *   `catalog:changed`; `mcp.test`; `mcp.upsert` (admin: the server user's
- *   `mcps.json`, or the folder's project, with an Advanced OAuth client
- *   secret) and `mcp.remove` (the user's); `mcp.signOut` (admin) and a
- *   sign-in whose browser comes back to the server itself
- *   (`oauthCallbackUrl`: a browser can't listen on a loopback port); its
- *   shared processes (`mcp.instances`) and a restart (`mcp.restart`, admin).
- *
- * Left out, as the protocol has no method for them: extension providers of
- * a folder (`auth.status` takes no `cwd`) and removing a project's MCP
- * server.
- */
-import type { HostProviderAuth, HostSignal } from 'zidane/ipc';
-import { IpcErrorCode, ServerCallError, ServerConnectionError, type ServerClient } from 'zidane/ipc/browser';
-
-import type { SettingsError, SettingsHost } from '../settings/headless/host';
-import { settingsMcpServerOf, type SettingsMcpInstance, type SettingsMcpServer } from '../settings/headless/mcp';
-import type { SettingsPreferredCredential, SettingsProvider } from '../settings/headless/providers';
-import { createSettingsResource, keyedSettingsResources } from '../settings/headless/resource';
-import type { SettingsResource } from '../settings/headless/sections-host';
-import { serverOAuthFlow } from './server-oauth-flow';
-
-const errorOf = (error: unknown): SettingsError => {
-  const detail = error instanceof Error ? error.message : undefined;
-  const kind =
-    error instanceof ServerConnectionError
-      ? 'unreachable'
-      : error instanceof ServerCallError && error.code === IpcErrorCode.Forbidden
-        ? 'refused'
-        : 'failed';
-  return detail ? { kind, detail } : { kind };
-};
-
-/** A provider of `auth.status` as Accounts lists it. */
-function providerOf(auth: HostProviderAuth): SettingsProvider {
-  const stored = auth.methods.filter((m) => m.key && m.source !== 'env');
-  return {
-    key: auth.key,
-    label: auth.label,
-    available: auth.configured,
-    hasApiKey: stored.some((m) => m.source === 'apikey'),
-    hasOAuth: stored.some((m) => m.source === 'oauth'),
-    oauth: auth.oauth,
-    methods: auth.methods.map((m) => ({
-      source: m.source,
-      detail: m.detail,
-      active: m.active,
-      ...(m.key ? { key: m.key } : {}),
-      ...(m.label ? { label: m.label } : {}),
-    })),
-    ...(auth.customFields ? { customFields: auth.customFields } : {}),
-    ...(auth.configuredFields ? { configuredFields: auth.configuredFields } : {}),
-  };
-}
-
-/**
- * The server's `providers` and `mcp` groups.
- *
- * @param client - The shared client.
- * @param oauthCallbackUrl - The server's `SERVER_OAUTH_CALLBACK_PATH` at the origin this page reaches it by. Absent: no MCP sign-in.
- */
-export function serverSettingsAccounts(
-  client: ServerClient,
-  oauthCallbackUrl?: string,
-): Pick<SettingsHost, 'providers' | 'mcp'> {
-  const call: ServerClient['call'] = async (method, params) => {
-    try {
-      return await client.call(method, params);
-    } catch (error) {
-      throw errorOf(error);
-    }
-  };
-
-  let providersRead = false;
-  const providerList = createSettingsResource(async () => {
-    providersRead = true;
-    return (await call('auth.status', {})).providers.map(providerOf);
-  });
-
-  const serverLists = new Map<string, SettingsResource<readonly SettingsMcpServer[]>>();
-  const serversOf = (cwd: string) => {
-    let list = serverLists.get(cwd);
-    if (!list) {
-      list = createSettingsResource(async () =>
-        (await call('catalog.mcps', cwd ? { cwd } : {})).servers.map(settingsMcpServerOf),
-      );
-      serverLists.set(cwd, list);
-    }
-    return list;
-  };
-
-  client.onOpen(() => {
-    if (providersRead) void providerList.refresh();
-    for (const list of serverLists.values()) void list.refresh();
-  });
-  client.onSignal((signal: HostSignal) => {
-    if (signal.kind !== 'catalog:changed' || signal.catalog !== 'mcps') return;
-    for (const list of serverLists.values()) void list.refresh();
-  });
-  // A server with `mcp.signOut` also takes `mcp.upsert`'s `scope` and `clientSecret`, and a browser's sign-in redirect.
-  const mcpState = client.can('mcp.signOut');
-
-  return {
-    providers: {
-      list: () => providerList,
-      setApiKey: async (_cwd, provider, key) => {
-        await call('auth.setApiKey', { provider, key });
-        await providerList.refresh();
-      },
-      ...(client.can('auth.configure')
-        ? {
-            configure: async (_cwd: string, provider: string, customFields: Readonly<Record<string, string>>) => {
-              await call('auth.configure', { provider, customFields: { ...customFields } });
-              await providerList.refresh();
-            },
-          }
-        : {}),
-      clear: async (_cwd, provider) => {
-        await call('auth.remove', { provider });
-        await providerList.refresh();
-      },
-      remove: async (_cwd, provider, account) => {
-        await call('auth.remove', { provider, account });
-        await providerList.refresh();
-      },
-      ...(client.can('auth.setPreferred')
-        ? {
-            setPreferred: async (_cwd: string, provider: string, target: SettingsPreferredCredential) => {
-              await call('auth.setPreferred', { provider, target });
-              await providerList.refresh();
-            },
-          }
-        : {}),
-      ...(client.can('auth.rename')
-        ? {
-            rename: async (_cwd: string, provider: string, account: string, label: string) => {
-              await call('auth.rename', { provider, account, label });
-              await providerList.refresh();
-            },
-          }
-        : {}),
-      signIn: (provider) => serverOAuthFlow(client, { provider }, { onDone: () => void providerList.refresh() }),
-    },
-    mcp: {
-      servers: serversOf,
-      ...(client.can('mcp.test')
-        ? {
-            test: async (cwd: string, name: string) => {
-              await call('mcp.test', { name, ...(cwd ? { cwd } : {}) });
-              await serversOf(cwd).refresh();
-            },
-          }
-        : {}),
-      add: async (cwd, { entry, scope, clientSecret }) => {
-        await call('mcp.upsert', {
-          config: entry,
-          ...(mcpState
-            ? { scope, ...(scope === 'project' ? { cwd } : {}), ...(clientSecret ? { clientSecret } : {}) }
-            : {}),
-        });
-      },
-      remove: async (_cwd, name) => {
-        await call('mcp.remove', { name });
-      },
-      ...(client.can('mcp.instances')
-        ? {
-            instances: keyedSettingsResources((cwd: string) =>
-              createSettingsResource<readonly SettingsMcpInstance[]>(() => call('mcp.instances', cwd ? { cwd } : {})),
-            ),
-          }
-        : {}),
-      ...(client.can('mcp.restart')
-        ? {
-            restart: async (cwd: string, name: string) => {
-              await call('mcp.restart', { name, ...(cwd ? { cwd } : {}) });
-            },
-          }
-        : {}),
-      ...(mcpState
-        ? {
-            projectScope: true,
-            signOut: async (cwd: string, name: string) => {
-              await call('mcp.signOut', { name });
-              await serversOf(cwd).refresh();
-            },
-            ...(oauthCallbackUrl
-              ? {
-                  signIn: (cwd: string, name: string) =>
-                    serverOAuthFlow(
-                      client,
-                      { mcpServer: name, redirectUri: oauthCallbackUrl, ...(cwd ? { cwd } : {}) },
-                      { onDone: () => void serversOf(cwd).refresh() },
-                    ),
-                }
-              : {}),
-          }
-        : {}),
-    },
-  };
-}

package/src/adapters/server-settings-host.ts

@@ -1,120 +0,0 @@
-/**
- * A `SettingsHost` on a running zidane-server, over a shared browser client
- * (`createServerClient`): the server's settings (`settings.get`), kept current
- * by the `settings:changed` signal and re-read after every handshake, and
- * written with `settings.set`.
- *
- * Reading needs the `chat` scope, writing the `admin` one: `writable`
- * follows `client.can('settings.set')`, so a `chat` token shows the settings
- * read-only. It listens to the client for its whole life: `close()` stops.
- */
-import type { Settings } from 'zidane/chat';
-import { IpcErrorCode, ServerCallError, ServerConnectionError, type ServerClient } from 'zidane/ipc/browser';
-import type { HostSignal } from 'zidane/ipc';
-
-import { writable } from '../chat/headless/store';
-import { closableClient } from './closable-client';
-import { DEFAULT_SETTINGS } from '../settings/headless/catalog';
-import type { SettingsDocument, SettingsError, SettingsHost } from '../settings/headless/host';
-import { serverSettingsSections } from './server-settings-sections';
-import { serverSettingsAccounts } from './server-settings-accounts';
-import { serverSettingsModels } from './server-settings-models';
-import { serverSettingsPerformance } from './server-settings-performance';
-
-/** Options for {@link createServerSettingsHost}. */
-export interface ServerSettingsHostOptions {
-  /** The shared client (`createServerClient`). */
-  client: ServerClient;
-  /**
-   * The server's `SERVER_OAUTH_CALLBACK_PATH` at the origin this page reaches it by: an MCP server's sign-in
-   * comes back there (a browser can't listen on a loopback port). Absent: no MCP sign-in.
-   */
-  oauthCallbackUrl?: string;
-}
-
-/** The {@link SettingsHost} {@link createServerSettingsHost} returns. */
-export interface ServerSettingsHost extends SettingsHost {
-  /** Stops listening to the client (the client stays open). */
-  close(): void;
-}
-
-const errorOf = (error: unknown): SettingsError => {
-  const detail = error instanceof Error ? error.message : undefined;
-  const kind =
-    error instanceof ServerConnectionError
-      ? 'unreachable'
-      : error instanceof ServerCallError && error.code === IpcErrorCode.Forbidden
-        ? 'refused'
-        : 'failed';
-  return detail ? { kind, detail } : { kind };
-};
-
-/**
- * Creates a {@link SettingsHost} on a running zidane-server.
- *
- * @param options - The shared client.
- */
-export function createServerSettingsHost(options: ServerSettingsHostOptions): ServerSettingsHost {
-  const { client, close } = closableClient(options.client);
-  const document = writable<SettingsDocument>({ status: 'loading' });
-  const ready = (values: Partial<Settings>): SettingsDocument => ({
-    status: 'ready',
-    values: { ...DEFAULT_SETTINGS, ...values },
-  });
-  // A read that started before a write may answer with the old values: only the latest read lands.
-  let generation = 0;
-
-  const refresh = async () => {
-    const mine = ++generation;
-    try {
-      const values = await client.call('settings.get', {});
-      if (mine === generation) document.set(ready(values));
-    } catch (error) {
-      if (mine === generation && document.get().status !== 'ready') {
-        document.set({ status: 'error', error: errorOf(error) });
-      }
-    }
-  };
-
-  client.onSignal((signal: HostSignal) => {
-    if (signal.kind !== 'settings:changed') return;
-    generation += 1;
-    document.set(ready(signal.settings));
-  });
-  client.onOpen(() => void refresh());
-  if (client.state().status === 'open') void refresh();
-
-  const canWrite = () => client.state().status === 'open' && client.can('settings.set');
-  const writableStore = writable(canWrite());
-  client.onState(() => {
-    const next = canWrite();
-    if (writableStore.get() !== next) writableStore.set(next);
-  });
-
-  const update = async (patch: Partial<Settings>) => {
-    const current = document.get();
-    if (current.status === 'ready') document.set({ status: 'ready', values: { ...current.values, ...patch } });
-    generation += 1;
-    try {
-      const values = await client.call('settings.set', { patch });
-      generation += 1;
-      document.set(ready(values));
-    } catch (error) {
-      // Not taken: show what the server holds.
-      await refresh();
-      throw errorOf(error);
-    }
-  };
-
-  return {
-    document,
-    refresh,
-    update,
-    writable: writableStore,
-    ...serverSettingsSections(client),
-    ...serverSettingsAccounts(client, options.oauthCallbackUrl),
-    ...serverSettingsModels(client),
-    ...serverSettingsPerformance(client),
-    close,
-  };
-}

package/src/adapters/server-settings-models.ts

@@ -1,46 +0,0 @@
-/**
- * The `models` group of the zidane-server `SettingsHost`
- * (`createServerSettingsHost`): the decision models from `models.list`
- * (each provider's `decisionModels`), and the one-prompt tests
- * `models.test` / `decisions.test`.
- *
- * Left out: `lastUsed`, the last model picked on this device, which the
- * server does not hold (a web app's new sessions start on the server's
- * defaults).
- */
-import type { ServerClient } from 'zidane/ipc/browser';
-
-import type { SettingsHost } from '../settings/headless/host';
-import type { SettingsDecisionModel } from '../settings/headless/models';
-import { createSettingsResource, keyedSettingsResources } from '../settings/headless/resource';
-import { settingsCaller } from './server-settings-sections';
-
-/**
- * The server's `models` group.
- *
- * @param client - The shared client.
- */
-export function serverSettingsModels(client: ServerClient): Pick<SettingsHost, 'models'> {
-  const call = settingsCaller(client);
-  const scope = (cwd: string) => (cwd ? { cwd } : {});
-  return {
-    models: {
-      decisionModels: keyedSettingsResources((cwd: string) =>
-        createSettingsResource(async (): Promise<readonly SettingsDecisionModel[]> => {
-          const { providers } = await call('models.list', scope(cwd));
-          return providers.flatMap((provider) =>
-            (provider.decisionModels ?? []).map((model) => ({
-              providerKey: provider.key,
-              providerLabel: provider.label,
-              modelId: model.id,
-              available: model.available,
-              ...(model.reason ? { reason: model.reason } : {}),
-            })),
-          );
-        }),
-      ),
-      test: (cwd, model) => call('models.test', { ...scope(cwd), model }),
-      testDecision: (cwd, model) => call('decisions.test', { ...scope(cwd), ...(model ? { model } : {}) }),
-    },
-  };
-}

package/src/adapters/server-settings-performance.ts

@@ -1,58 +0,0 @@
-/**
- * The performance group of the zidane-server `SettingsHost`
- * (`createServerSettingsHost`), over the shared browser client: the
- * server's own figures (`perf.*`, admin), its samples held
- * (`perf.history`), followed while shown (`perf.watch`, `perf:sample`;
- * watched again after a reconnect) and a listed process's threads
- * (`perf.threads`). Offered when the token reaches them; a server too old
- * for them or a chat token has none, and the page says it is not available.
- * No counters, report or profiles: a server keeps none.
- */
-import { IpcErrorCode, ServerCallError, type ServerClient } from 'zidane/ipc/browser';
-import type { HostSignal } from 'zidane/ipc';
-
-import type { SettingsHost } from '../settings/headless/host';
-import type { PerfWatchError, SettingsPerformanceHost } from '../settings/headless/performance';
-
-/** JSON-RPC's "method not found": a server older than `perf.*`. */
-const METHOD_NOT_FOUND = -32601;
-
-const watchErrorOf = (error: unknown): PerfWatchError => {
-  const code = error instanceof ServerCallError ? error.code : undefined;
-  if (code === METHOD_NOT_FOUND) return { kind: 'unavailable' };
-  const detail = error instanceof Error ? error.message : String(error);
-  return { kind: code === IpcErrorCode.Forbidden ? 'refused' : 'failed', detail };
-};
-
-/**
- * The group, when the client's token reaches it.
- *
- * @param client - The shared browser client.
- */
-export function serverSettingsPerformance(client: ServerClient): Pick<SettingsHost, 'performance'> {
-  if (!client.can('perf.watch')) return {};
-  const performance: SettingsPerformanceHost = {
-    history: async () => (await client.call('perf.history', {})).samples,
-    watch: (onSample, onError) => {
-      let live = true;
-      const watch = () =>
-        void client.call('perf.watch', {}).catch((error: unknown) => {
-          if (live) onError?.(watchErrorOf(error));
-        });
-      const offSignal = client.onSignal((signal: HostSignal) => {
-        if (signal.kind === 'perf:sample') onSample(signal.sample);
-      });
-      // A reconnect is a new connection: the server forgot the watch.
-      const offOpen = client.onOpen(watch);
-      watch();
-      return () => {
-        live = false;
-        offSignal();
-        offOpen();
-        void client.call('perf.unwatch', {}).catch(() => undefined);
-      };
-    },
-    threads: async (pid) => (await client.call('perf.threads', { pid })).threads,
-  };
-  return { performance };
-}