zidane-ui 9.1.1 → 9.1.4

package/src/adapters/server-host.ts

@@ -1,489 +0,0 @@
-/**
- * A `ChatHost` on a running zidane-server, from a browser or any runtime with a `WebSocket`:
- * built on zidane's browser client (`zidane/ipc/browser`), which handles the protocol range,
- * the token, reconnecting, the heartbeat and the refusals no retry can fix.
- *
- * What it offers: the session list (create, rename, archive, delete, the orchestration Main), transcripts paged from
- * the end, send (with a model and thinking choice, skills), the provider check (`auth.status`),
- * interrupt, steer, follow up, questions and plans, the models the server can run, a tool call's
- * full output, and stopping a tool call. Left out: `!` shell runs (`sessions.workspaceExec`
- * answers the output but streams no run into the transcript and persists no turn).
- * After a reconnect it resumes each open transcript from the last signal it saw
- * (`sessions.resume`), or reloads it when the server can't replay that far.
- *
- * Tool approvals (safe mode) are their own area: `createServerApprovalsHost` on the same client
- * lists them, and answers them with an approve-scoped token. The server must allow the page's origin (`ZIDANE_SERVER_ALLOWED_ORIGINS`,
- * or serve the page itself).
- */
-import type { InteractionRequest } from 'zidane/chat';
-import type { ServerClient, ServerClientOptions, ServerClientState } from 'zidane/ipc/browser';
-import type {
-  HostModelProvider,
-  HostSignal,
-  IpcParams,
-  PendingInteraction,
-  SessionEventsPage,
-  SessionRow,
-  SignalMeta,
-} from 'zidane/ipc';
-
-import type {
-  ChatEvent,
-  ChatHost,
-  ChatInteraction,
-  ChatModelProvider,
-  ChatSession,
-  SessionSearchHit,
-} from '../chat/headless/host';
-import type { SidebarListSession } from '../chat/headless/sidebar/types';
-import { writable, type Readable } from '../chat/headless/store';
-import { createLiveState } from './live';
-import { createServerClient } from './server-client';
-import { createServerTranscriptMembers } from './server-transcript-members';
-
-/** Transcript turns per page. */
-const PAGE_TURNS = 200;
-
-/** Options for {@link createServerHost}: a client to share, or what to create one with. */
-export type ServerHostOptions = (
-  | {
-      /** A client already made with `createServerClient`, shared with other hosts (approvals, settings…). */
-      client: ServerClient;
-    }
-  | (Omit<ServerClientOptions, 'onState'> & { client?: undefined })
-) & {
-  /** Working directory for new sessions (default `''`: the server's first workspace root). */
-  cwd?: string;
-  /** Called with errors that no caller can receive, such as a failed background reload. Default: a console warning. */
-  onError?: (error: unknown) => void;
-};
-
-/** The {@link ChatHost} {@link createServerHost} returns, plus the connection. */
-export interface ServerHost extends ChatHost {
-  /** The client it speaks through (for other areas' hosts on the same connection). */
-  client: ServerClient;
-  /** The connection's state, for a status line or a sign-in prompt. */
-  connection: Readable<ServerClientState>;
-  /** Resolves once the first handshake and session list completed; rejects when the client was refused. */
-  ready: Promise<void>;
-  /** Re-reads the session list. */
-  refresh(): Promise<void>;
-  /** Closes the connection and stops reconnecting (also closes a client it was given). */
-  close(): void;
-}
-
-/** What the server calls a session that has no title yet (core's `DEFAULT_SESSION_TITLE`). */
-const UNTITLED = 'New session';
-
-/**
- * Converts a zidane server's session row into a {@link ChatSession}. The project root becomes the group, the main session is pinned, and the model id gets its provider prefix.
- *
- * @param row - The session row from the server.
- */
-export function toChatSession(row: SessionRow): ChatSession {
-  return {
-    id: row.id,
-    title: row.title || UNTITLED,
-    status: row.status,
-    createdAt: row.createdAt,
-    updatedAt: row.updatedAt,
-    ...(row.archived ? { archived: true } : {}),
-    ...(row.projectRoot
-      ? { group: row.projectRoot, groupLabel: row.projectRoot.split('/').pop() || row.projectRoot }
-      : {}),
-    ...(row.isMain ? { pinned: true } : {}),
-    ...(row.modelId ? { modelId: row.providerKey ? `${row.providerKey}/${row.modelId}` : row.modelId } : {}),
-  };
-}
-
-/**
- * Converts a zidane server's session row into a {@link SidebarListSession}: the chat session plus its folder and space.
- *
- * @param row - The session row from the server.
- */
-export function toSidebarListSession(row: SessionRow): SidebarListSession {
-  return {
-    ...toChatSession(row),
-    cwd: row.cwd ?? row.projectRoot ?? '',
-    ...(row.projectRoot ? { projectRoot: row.projectRoot } : {}),
-    ...(row.spaceId ? { spaceId: row.spaceId } : {}),
-    ...(row.isMain ? { isMain: true } : {}),
-    ...(row.favorite ? { favorite: true } : {}),
-    ...(row.agentId ? { agentId: row.agentId } : {}),
-    ...(row.facets && Object.keys(row.facets).length > 0 ? { facets: row.facets } : {}),
-  };
-}
-
-/**
- * Converts the server's model list into the model picker's providers.
- *
- * @param providers - `models.list`'s providers.
- */
-export function toChatModelProviders(providers: readonly HostModelProvider[]): ChatModelProvider[] {
-  return providers.map((p) => ({
-    key: p.key,
-    label: p.label,
-    models: p.models.map((m) => ({
-      id: m.id,
-      ...(m.name ? { label: m.name } : {}),
-      contextWindow: m.contextWindow,
-      ...(m.reasoning ? { thinking: true } : {}),
-      ...(m.options?.length
-        ? {
-            options: m.options.map(({ id, label, description }) => ({
-              id,
-              label,
-              ...(description ? { description } : {}),
-            })),
-          }
-        : {}),
-    })),
-  }));
-}
-
-/**
- * Creates a {@link ChatHost} on a running zidane-server. Pass a shared `client`, or the `url`
- * and `token` (and client options) to create one.
- *
- * @param options - The client, or what to create one with, plus the working directory for new sessions.
- */
-export function createServerHost(options: ServerHostOptions): ServerHost {
-  const onError = options.onError ?? ((error: unknown) => console.warn('createServerHost:', error));
-  const client = options.client ?? createServerClient(options);
-  const connection = writable<ServerClientState>(client.state());
-  const watched = new Set<string>();
-  const cursors = new Map<string, number | undefined>();
-  /** Last signal number seen per session, and the host process that numbered it. */
-  const seqs = new Map<string, number>();
-  let epoch: string | undefined;
-  /** Signals that arrive between a hydrate's snapshot and its replace, replayed after it. */
-  const hydrating = new Map<string, { signal: HostSignal; meta?: SignalMeta }[]>();
-  const models = writable<readonly ChatModelProvider[]>([]);
-
-  const state = createLiveState({
-    onOpen: (sessionId) => {
-      watched.add(sessionId);
-      if (client.hello()) void hydrate(sessionId).catch(onError);
-    },
-    onClose: (sessionId) => watched.delete(sessionId),
-    // `onOpen` loads a transcript again, so a closed one need not stay.
-    evict: true,
-  });
-
-  const changed = new Set<(sessionId: string) => void>();
-  const facetListeners = new Set<(sessionId: string, facets: Readonly<Record<string, unknown>>) => void>();
-  const onSignal = (signal: HostSignal, meta?: SignalMeta) => {
-    const sessionId = 'sessionId' in signal && typeof signal.sessionId === 'string' ? signal.sessionId : undefined;
-    if (sessionId && meta) seqs.set(sessionId, meta.seq);
-    if (
-      (signal.kind === 'event' || signal.kind === 'run:start' || signal.kind === 'run:end') &&
-      hydrating.has(signal.sessionId)
-    ) {
-      hydrating.get(signal.sessionId)!.push({ signal, ...(meta ? { meta } : {}) });
-      return;
-    }
-    switch (signal.kind) {
-      case 'event':
-        state.apply(signal.sessionId, signal.event as ChatEvent, signal.echo);
-        return;
-      case 'run:start':
-      case 'run:end':
-        if (signal.kind === 'run:start') state.setRunning(signal.sessionId, true);
-        else state.setRunning(signal.sessionId, false, signal.ok ? 'completed' : 'error');
-        // The server derives an untitled session's title from its first prompt when it reads it, and announces
-        // nothing: read the list again (at the run's start, and at its end if the list did not have it yet) so the
-        // header and the palette take the title the sidebar shows.
-        if (state.sessions.get().some((s) => s.id === signal.sessionId && s.title === UNTITLED))
-          void refreshTitles().catch(onError);
-        return;
-      case 'interaction:request':
-        state.addInteraction(signal.sessionId, signal.request);
-        return;
-      case 'interaction:resolved':
-        state.resolveInteraction(signal.requestId);
-        return;
-      case 'sessions:facets':
-        for (const listener of [...facetListeners]) listener(signal.sessionId, signal.facets);
-        return;
-      case 'sessions:changed':
-        for (const listener of [...changed]) listener(signal.sessionId);
-        void refresh().catch(onError);
-        if (signal.op === 'update' && watched.has(signal.sessionId)) void hydrate(signal.sessionId).catch(onError);
-    }
-  };
-
-  const loadPage = async (sessionId: string, before?: number): Promise<SessionEventsPage> => {
-    const params = { sessionId, limit: PAGE_TURNS, ...(before !== undefined ? { before } : {}) };
-    const result = (await client.call('sessions.loadEvents', params as IpcParams<'sessions.loadEvents'>)) as
-      SessionEventsPage | ChatEvent[];
-    return Array.isArray(result) ? { events: result as SessionEventsPage['events'] } : result;
-  };
-
-  const hydrate = async (sessionId: string) => {
-    // Signals after the snapshot are not in it: hold them until it lands.
-    const buffered: { signal: HostSignal; meta?: SignalMeta }[] = [];
-    hydrating.set(sessionId, buffered);
-    try {
-      const page = await loadPage(sessionId);
-      const running = await client.call('chat.isRunning', { sessionId });
-      cursors.set(sessionId, page.cursor);
-      state.hydrate(sessionId, page.events as unknown as ChatEvent[], {
-        running,
-        hasEarlier: page.cursor !== undefined,
-      });
-    } finally {
-      // A newer hydrate took over the buffer: it replays what follows its own snapshot.
-      if (hydrating.get(sessionId) === buffered) hydrating.delete(sessionId);
-      for (const { signal, meta } of buffered) onSignal(signal, meta);
-    }
-    const interactions: PendingInteraction[] = await client.call('interactions.list', { sessionId });
-    for (const i of state.pending(sessionId).get()) state.resolveInteraction(i.requestId);
-    for (const i of interactions) state.addInteraction(sessionId, i.request as InteractionRequest);
-  };
-
-  /** After a reconnect: replay what the transcript missed, or reload it when the server can't. */
-  const resume = async (sessionId: string) => {
-    const afterSeq = seqs.get(sessionId);
-    if (epoch && afterSeq !== undefined && client.can('sessions.resume')) {
-      const result = await client.call('sessions.resume', { sessionId, epoch, afterSeq });
-      if (result.ok) {
-        for (const { seq, signal } of result.signals) onSignal(signal, { seq });
-        return;
-      }
-    }
-    await hydrate(sessionId);
-  };
-
-  const loadEarlier = async (sessionId: string) => {
-    const before = cursors.get(sessionId);
-    const t = state.transcript(sessionId).state;
-    if (before === undefined || t.get().loadingEarlier) return;
-    t.set((s) => ({ ...s, loadingEarlier: true }));
-    try {
-      const page = await loadPage(sessionId, before);
-      cursors.set(sessionId, page.cursor);
-      t.set((s) => ({
-        ...s,
-        events: [...(page.events as unknown as ChatEvent[]), ...s.events],
-        hasEarlier: page.cursor !== undefined,
-        loadingEarlier: false,
-      }));
-    } catch (error) {
-      t.set((s) => ({ ...s, loadingEarlier: false }));
-      onError(error);
-    }
-  };
-
-  const refresh = async () => {
-    const rows = await client.call('sessions.list', { archive: 'all' });
-    state.sessions.set(rows.map(toChatSession));
-  };
-
-  /** Takes the listed titles only: a run's status, set from its signals, stays. */
-  const refreshTitles = async () => {
-    const rows = await client.call('sessions.list', { archive: 'all' });
-    const titles = new Map(rows.map((r) => [r.id, r.title || UNTITLED]));
-    state.sessions.set((all) =>
-      all.some((s) => titles.has(s.id) && titles.get(s.id) !== s.title)
-        ? all.map((s) => (titles.has(s.id) && titles.get(s.id) !== s.title ? { ...s, title: titles.get(s.id)! } : s))
-        : all,
-    );
-  };
-
-  const loadModels = async () => {
-    if (!client.can('models.list')) return;
-    const { providers } = await client.call('models.list', options.cwd ? { cwd: options.cwd } : {});
-    models.set(toChatModelProviders(providers));
-  };
-
-  const unsubscribe = [
-    client.onState((s) => connection.set(s)),
-    client.onSignal(onSignal),
-    client.onOpen((hello, reconnected) => {
-      const sameProcess = epoch !== undefined && hello.signalEpoch === epoch;
-      epoch = hello.signalEpoch;
-      if (!sameProcess) seqs.clear();
-      void loadModels().catch(onError);
-      if (!reconnected) return;
-      void refresh().catch(onError);
-      for (const id of watched) void resume(id).catch(onError);
-    }),
-  ];
-
-  // Ready once the session list is in, so a page can pick one.
-  const ready = client.ready.then(() => refresh());
-  ready.catch(onError);
-
-  // Built before the handshake: a member is offered until a hello says the server lacks its method.
-  const may = (method: Parameters<ServerClient['can']>[0]) => client.hello() === null || client.can(method);
-
-  /** Every session's requests in one list (`interactions.list` without a session), on the first read and after each reconnect. */
-  const listAll = async () => {
-    const listed: PendingInteraction[] = await client.call('interactions.list', {});
-    const ids = new Set(listed.map((i) => i.request.id));
-    for (const i of state.allPending.get()) if (!ids.has(i.requestId)) state.resolveInteraction(i.requestId);
-    for (const i of listed) state.addInteraction(i.sessionId, i.request as InteractionRequest);
-  };
-  let listingAll = false;
-  const allPending: Readable<readonly ChatInteraction[]> = {
-    get: state.allPending.get,
-    subscribe(onChange) {
-      if (!listingAll) {
-        listingAll = true;
-        unsubscribe.push(client.onOpen(() => void listAll().catch(onError)));
-        if (client.hello()) void listAll().catch(onError);
-      }
-      return state.allPending.subscribe(onChange);
-    },
-  };
-
-  /** `provider/model` → the server's pick, before a send that asks for another model. */
-  const applyChoice = async (sessionId: string, model?: string, thinking?: string) => {
-    if (model) {
-      const slash = model.indexOf('/');
-      if (slash > 0)
-        await client.call('sessions.setModel', {
-          sessionId,
-          providerKey: model.slice(0, slash),
-          modelId: model.slice(slash + 1),
-        });
-    }
-    if (thinking)
-      await client.call('sessions.setEffort', {
-        sessionId,
-        effort: thinking as IpcParams<'sessions.setEffort'>['effort'],
-      });
-  };
-
-  return {
-    client,
-    connection,
-    ready,
-    sessions: {
-      list: state.sessions,
-      async create(input) {
-        const row = await client.call('sessions.create', {
-          cwd: options.cwd ?? '',
-          ...(input?.title ? { title: input.title } : {}),
-        });
-        const session = toChatSession(row);
-        state.sessions.set((all) => (all.some((s) => s.id === session.id) ? all : [session, ...all]));
-        return session;
-      },
-      async rename(sessionId, title) {
-        await client.call('sessions.setTitle', { sessionId, title });
-        state.patchSession(sessionId, { title });
-      },
-      async setArchived(sessionId, archived) {
-        await client.call('sessions.setArchived', { sessionId, archived });
-        state.patchSession(sessionId, { archived });
-      },
-      async setFavorite(sessionId, favorite) {
-        await client.call('sessions.setFavorite', { sessionId, favorite });
-        state.patchSession(sessionId, { favorite });
-      },
-      async remove(sessionId) {
-        const { environment } = (await client.call('sessions.delete', { sessionId })) ?? {};
-        state.sessions.set((all) => all.filter((s) => s.id !== sessionId));
-        if (environment && !environment.removed)
-          return { kept: true, ...(environment.reason ? { reason: environment.reason } : {}) };
-      },
-      // One host per connection: a remote host id names none of this server's sessions.
-      query: async ({ archive, hostId }) =>
-        hostId ? [] : (await client.call('sessions.list', { archive })).map(toSidebarListSession),
-      async setSpace(sessionId, spaceId) {
-        await client.call('sessions.setSpace', { sessionId, spaceId });
-      },
-      async search(query, filter) {
-        const rows = await client.call('sessions.list', { archive: filter?.archive ?? 'active' });
-        if (rows.length === 0) return [];
-        const matches = await client.call('history.searchAll', { query, sessionIds: rows.map((r) => r.id) });
-        return rows
-          .flatMap((row) => {
-            const match = matches[row.id];
-            if (!match) return [];
-            const hit: SessionSearchHit = {
-              sessionId: row.id,
-              title: row.title || 'New session',
-              excerpt: match.excerpts[0]?.text ?? '',
-              matchCount: match.matchedTurnIds.length,
-              updatedAt: row.updatedAt,
-            };
-            return [{ hit, score: match.score }];
-          })
-          .sort((a, b) => b.score - a.score)
-          .map(({ hit }) => hit);
-      },
-      onChanged(listener) {
-        changed.add(listener);
-        return () => changed.delete(listener);
-      },
-      onFacets(listener) {
-        facetListeners.add(listener);
-        return () => facetListeners.delete(listener);
-      },
-      ...(may('orchestration.main') ? { main: () => client.call('orchestration.main', {}) } : {}),
-      ...(may('sidebar.getViews')
-        ? {
-            views: {
-              getViews: () => client.call('sidebar.getViews', {}),
-              setView: (spaceId, view) => client.call('sidebar.setView', { spaceId, view: { ...view } }),
-              getSpace: () => client.call('sidebar.getSpace', {}),
-              setSpace: (spaceId) => client.call('sidebar.setSpace', { spaceId }),
-            },
-          }
-        : {}),
-    },
-    transcript: (sessionId) => state.readable(sessionId, { loadEarlier: () => void loadEarlier(sessionId) }),
-    async send({ sessionId, prompt, attachments, model, thinking, activatedSkills, echo, keepDraft }) {
-      if (echo !== false) state.echoPrompt(sessionId, prompt, attachments);
-      await applyChoice(sessionId, model, thinking);
-      const uploads = (attachments ?? []).flatMap((a) => {
-        const m = a.dataUrl?.match(/^data:([^;,]+)?;base64,(.*)$/s);
-        return m ? [{ mediaType: m[1] || a.mediaType, data: m[2]!, name: a.name }] : [];
-      });
-      await client.call('chat.send', {
-        sessionId,
-        prompt,
-        // One id per submission: the host runs a resend of it once.
-        requestId: crypto.randomUUID(),
-        ...(activatedSkills?.length ? { activatedSkills: [...activatedSkills] } : {}),
-        ...(uploads.length ? { attachments: uploads } : {}),
-        ...(keepDraft ? { keepDraft: true } : {}),
-      });
-    },
-    // The server's own credentials: some provider has a source configured.
-    async providerReady() {
-      const { providers } = await client.call('auth.status', {});
-      return providers.some((p) => p.configured);
-    },
-    interrupt(sessionId) {
-      void client.call('chat.interrupt', { sessionId }).catch(onError);
-    },
-    steer: (sessionId, message) => client.call('chat.steer', { sessionId, message }),
-    followUp: (sessionId, message) => client.call('chat.followUp', { sessionId, message }),
-    interactions: {
-      pending: state.pending,
-      all: () => allPending,
-      async answer(requestId, response) {
-        await client.call('interactions.respond', { requestId, response });
-        state.resolveInteraction(requestId);
-      },
-      async cancel(requestId, reason) {
-        await client.call('interactions.cancel', { requestId, ...(reason ? { reason } : {}) });
-        state.resolveInteraction(requestId);
-      },
-    },
-    models,
-    toolOutput: (sessionId, callId) => client.call('sessions.getToolResult', { sessionId, callId }),
-    cancelTool(sessionId, callId) {
-      void client.call('chat.cancelWork', { sessionId, id: callId }).catch(onError);
-    },
-    ...createServerTranscriptMembers(client),
-    refresh,
-    close() {
-      for (const off of unsubscribe) off();
-      client.close();
-    },
-  };
-}