zidane-ui 9.1.1 → 9.1.4

package/src/adapters/worker-host.ts

@@ -1,192 +0,0 @@
-/**
- * The run host, split across a Web Worker: `exposeRunHost(run)` inside the
- * worker runs your `RunFn`; `createWorkerHost(worker)` in the page is a
- * `createRunHost` whose runs are proxied there (protocol in
- * `worker-protocol.ts`). Sessions, transcripts and interactions live in the
- * page; the worker only runs.
- */
-import type { InteractionResponse } from 'zidane/chat';
-
-import type { ChatHost } from '../chat/headless/host';
-import { createRunHost, type RunFn, type RunHostOptions } from './run-host';
-import {
-  decodeFromWorker,
-  decodeToWorker,
-  type FromWorker,
-  type MessageEndpoint,
-  type ToWorker,
-  WORKER_PROTOCOL_VERSION,
-} from './worker-protocol';
-
-interface Proxied {
-  context: Parameters<RunFn>[0];
-  done: (error?: string) => void;
-}
-
-/** Options for {@link createWorkerHost}: the {@link RunHostOptions} except `run`, plus `newRunId`. */
-export interface WorkerHostOptions extends Omit<RunHostOptions, 'run'> {
-  /** Run ids (default: `crypto.randomUUID()`). */
-  newRunId?: () => string;
-}
-
-/**
- * Creates a {@link ChatHost} in the page whose runs execute in a Web Worker. Sessions, transcripts, and interactions stay in the page; the worker runs the agent through {@link exposeRunHost}.
- *
- * @param worker - The worker, or any object that posts and receives messages like one.
- * @param options - Initial sessions, transcripts, models, and an optional run id generator.
- */
-export function createWorkerHost(
-  worker: MessageEndpoint,
-  options: WorkerHostOptions = {},
-): ChatHost & {
-  /** Stop listening to the worker (it keeps running; terminate it yourself). */
-  dispose(): void;
-} {
-  const runs = new Map<string, Proxied>();
-  const newRunId = options.newRunId ?? (() => crypto.randomUUID());
-  const post = (message: ToWorker) => worker.postMessage(message);
-  let warned = false;
-
-  const onMessage = (event: MessageEvent) => {
-    const message = decodeFromWorker(event.data);
-    if (message === 'version') {
-      if (!warned)
-        console.warn(`createWorkerHost: the worker speaks another protocol version (want ${WORKER_PROTOCOL_VERSION})`);
-      warned = true;
-      return;
-    }
-    if (!message || message.type === 'ready') return;
-    const run = runs.get(message.runId);
-    if (!run) return;
-    handle(message, run);
-  };
-
-  const handle = (message: Exclude<FromWorker, { type: 'ready' }>, run: Proxied) => {
-    switch (message.type) {
-      case 'event':
-        run.context.emit(message.event);
-        return;
-      case 'ask':
-        void run.context
-          .ask(message.request)
-          .then((response: InteractionResponse | null) =>
-            post({ v: 1, type: 'answer', requestId: message.request.id, response }),
-          );
-        return;
-      case 'steerable':
-        run.context.onSteer((text) => post({ v: 1, type: 'steer', runId: message.runId, message: text }));
-        return;
-      case 'done':
-        runs.delete(message.runId);
-        run.done(message.error);
-    }
-  };
-  worker.addEventListener('message', onMessage);
-
-  const run: RunFn = (context) =>
-    new Promise<void>((resolve, reject) => {
-      const runId = newRunId();
-      runs.set(runId, { context, done: (error) => (error === undefined ? resolve() : reject(new Error(error))) });
-      // An interrupted run is over for the page at once, whenever the worker's `done` comes.
-      context.signal.addEventListener(
-        'abort',
-        () => {
-          post({ v: 1, type: 'interrupt', runId });
-          runs.delete(runId);
-          resolve();
-        },
-        { once: true },
-      );
-      post({
-        v: 1,
-        type: 'send',
-        runId,
-        input: {
-          sessionId: context.sessionId,
-          prompt: context.prompt,
-          attachments: context.attachments,
-          ...(context.model ? { model: context.model } : {}),
-          ...(context.thinking ? { thinking: context.thinking } : {}),
-        },
-      });
-    });
-
-  const host = createRunHost({ ...options, run });
-  return { ...host, dispose: () => worker.removeEventListener('message', onMessage) };
-}
-
-/**
- * Serve `run` to the page over `scope` (default: the worker's global scope).
- * Returns a function that stops listening.
- *
- * @param run - The function that runs the agent for each prompt.
- * @param scope - The endpoint to listen on and post to. Defaults to the worker's global scope.
- */
-export function exposeRunHost(
-  run: RunFn,
-  scope: MessageEndpoint = globalThis as unknown as MessageEndpoint,
-): () => void {
-  const runs = new Map<string, { controller: AbortController; steer?: (message: string) => void }>();
-  const waiters = new Map<string, (response: InteractionResponse | null) => void>();
-  const post = (message: FromWorker) => scope.postMessage(message);
-
-  const start = (runId: string, input: Extract<ToWorker, { type: 'send' }>['input']) => {
-    const controller = new AbortController();
-    const entry: { controller: AbortController; steer?: (message: string) => void } = { controller };
-    runs.set(runId, entry);
-    const finish = (error?: string) => {
-      if (!runs.delete(runId)) return;
-      post({ v: 1, type: 'done', runId, ...(error === undefined ? {} : { error }) });
-    };
-    Promise.resolve()
-      .then(() =>
-        run({
-          ...input,
-          signal: controller.signal,
-          emit: (event) => post({ v: 1, type: 'event', runId, event }),
-          ask: (request) =>
-            new Promise((resolve) => {
-              waiters.set(request.id, resolve);
-              post({ v: 1, type: 'ask', runId, request });
-              controller.signal.addEventListener('abort', () => resolve(null), { once: true });
-            }),
-          onSteer: (listener) => {
-            entry.steer = listener;
-            post({ v: 1, type: 'steerable', runId });
-          },
-        }),
-      )
-      .then(
-        () => finish(),
-        (error: unknown) => finish(error instanceof Error ? error.message : String(error)),
-      );
-  };
-
-  const onMessage = (event: MessageEvent) => {
-    const message = decodeToWorker(event.data);
-    if (message === 'version') {
-      console.warn(`exposeRunHost: the page speaks another protocol version (want ${WORKER_PROTOCOL_VERSION})`);
-      return;
-    }
-    if (!message) return;
-    switch (message.type) {
-      case 'send':
-        start(message.runId, message.input);
-        return;
-      case 'interrupt':
-        runs.get(message.runId)?.controller.abort();
-        return;
-      case 'steer':
-        runs.get(message.runId)?.steer?.(message.message);
-        return;
-      case 'answer': {
-        const waiter = waiters.get(message.requestId);
-        waiters.delete(message.requestId);
-        waiter?.(message.response);
-      }
-    }
-  };
-  scope.addEventListener('message', onMessage);
-  post({ v: 1, type: 'ready' });
-  return () => scope.removeEventListener('message', onMessage);
-}

package/src/adapters/worker-protocol.ts

@@ -1,97 +0,0 @@
-/**
- * The postMessage protocol between `createWorkerHost` (the page) and
- * `exposeRunHost` (inside a Web Worker). Version 1. Every message is a plain
- * structured-clone object carrying `v` (the protocol version) and `type`;
- * a side drops messages of another version and logs a console warning (the
- * page once, the worker on each message).
- *
- * Page → worker
- *   send       { runId, input }                 start a run (`input`: sessionId, prompt, attachments, model?, thinking?)
- *   interrupt  { runId }                        abort it (the run's `signal` fires)
- *   steer      { runId, message }               hand a message to the run's `onSteer` listener
- *   answer     { requestId, response | null }   the user answered (`null`: dismissed) a request the run raised
- *
- * Worker → page
- *   ready      {}                               the worker listens (sent once, on `exposeRunHost`)
- *   event      { runId, event }                 one live StreamEvent (zidane's delta rule, see `live.ts`)
- *   ask        { runId, request }               the run raised an InteractionRequest
- *   steerable  { runId }                        the run registered an `onSteer` listener
- *   done       { runId, error? }                the run returned (or threw: `error` is its message)
- */
-import type { InteractionRequest, InteractionResponse } from 'zidane/chat';
-
-import type { ChatAttachment, ChatEvent, SendInput } from '../chat/headless/host';
-
-/** Version of the postMessage protocol between {@link createWorkerHost} and {@link exposeRunHost}. A side drops messages of another version. */
-export const WORKER_PROTOCOL_VERSION = 1;
-
-/** The prompt the page sends to start a run in the worker. */
-export interface WorkerRunInput {
-  /** Id of the session the prompt was sent to. */
-  sessionId: string;
-  /** The prompt text. */
-  prompt: string;
-  /** Files sent with the prompt. */
-  attachments: readonly ChatAttachment[];
-  /** The model the user picked, as `provider/model` or a bare id. */
-  model?: string;
-  /** The reasoning effort the user picked. */
-  thinking?: SendInput['thinking'];
-}
-
-/** A message from the page to the worker: `send` starts a run, `interrupt` aborts it, `steer` passes guidance to it, and `answer` returns the user's reply to a request. */
-export type ToWorker =
-  | { v: 1; type: 'send'; runId: string; input: WorkerRunInput }
-  | { v: 1; type: 'interrupt'; runId: string }
-  | { v: 1; type: 'steer'; runId: string; message: string }
-  | { v: 1; type: 'answer'; requestId: string; response: InteractionResponse | null };
-
-/** A message from the worker to the page: `ready`, a live `event`, an `ask` request, `steerable`, or `done` when the run ends. */
-export type FromWorker =
-  | { v: 1; type: 'ready' }
-  | { v: 1; type: 'event'; runId: string; event: ChatEvent }
-  | { v: 1; type: 'ask'; runId: string; request: InteractionRequest }
-  | { v: 1; type: 'steerable'; runId: string }
-  | { v: 1; type: 'done'; runId: string; error?: string };
-
-/** What both ends need of a `Worker` / `DedicatedWorkerGlobalScope` / `MessagePort`. */
-export interface MessageEndpoint {
-  /** Sends a message to the other side. */
-  postMessage(message: unknown): void;
-  /** Registers a listener for messages from the other side. */
-  addEventListener(type: 'message', listener: (event: MessageEvent) => void): void;
-  /** Removes a listener added with `addEventListener`. */
-  removeEventListener(type: 'message', listener: (event: MessageEvent) => void): void;
-}
-
-const TO_WORKER = new Set(['send', 'interrupt', 'steer', 'answer']);
-const FROM_WORKER = new Set(['ready', 'event', 'ask', 'steerable', 'done']);
-
-function isMessage(data: unknown, types: ReadonlySet<string>): data is { v: unknown; type: string } {
-  return (
-    typeof data === 'object' &&
-    data !== null &&
-    typeof (data as { type?: unknown }).type === 'string' &&
-    types.has((data as { type: string }).type)
-  );
-}
-
-/**
- * A protocol message for the worker, or why not: `'version'` (another protocol version), `null` (not ours).
- *
- * @param data - The `data` of a received message.
- */
-export function decodeToWorker(data: unknown): ToWorker | 'version' | null {
-  if (!isMessage(data, TO_WORKER)) return null;
-  return data.v === WORKER_PROTOCOL_VERSION ? (data as ToWorker) : 'version';
-}
-
-/**
- * Checks a message the page received from the worker. Returns the {@link FromWorker} message, `'version'` when it speaks another protocol version, or `null` when it is not a protocol message.
- *
- * @param data - The `data` of a received message.
- */
-export function decodeFromWorker(data: unknown): FromWorker | 'version' | null {
-  if (!isMessage(data, FROM_WORKER)) return null;
-  return data.v === WORKER_PROTOCOL_VERSION ? (data as FromWorker) : 'version';
-}

package/src/app/AppHostProvider.tsx

@@ -1,135 +0,0 @@
-/**
- * Puts an `AppHost` in context, and each area's host in its own provider, so
- * an app wraps once:
- *
- *   <AppHostProvider host={{ chat, onboarding }}>
- *     <SessionList … />
- *   </AppHostProvider>
- *
- * Today that is `ChatProvider` when `host.chat` is present,
- * `SessionProvider` when `host.session` is, `ApprovalsProvider` when
- * `host.approvals` is, `ExtensionsProvider` when `host.extensions` is, `FilesProvider` when `host.files` is, `GitProvider` when `host.git` is, `MachinesProvider` when `host.machines` is, `SettingsProvider` when `host.settings` is, `TerminalProvider` when `host.terminal` is, `KeybindingsProvider` when `host.keybindings` is and
- * `AppearanceProvider` when `host.appearance` is, and always a `KeyCommandsProvider` (the key command
- * registry: register shortcuts with `useKeyCommands`). `host.workspace` goes in
- * context for each `WorkspaceProvider` below (`WorkspaceHostProvider`), and
- * `host.onboarding` for each `OnboardingProvider` below (`OnboardingHostProvider`), `host.composer`
- * for each rich composer below (`ComposerHostProvider`), `host.sidebar` for the
- * sidebar and the session menus below (`SidebarHostProvider`):
- * a run mounts where the app opens the wizard, with the flow's own props.
- */
-import { createContext, useContext, type ReactNode } from 'react';
-
-import { AppearanceProvider } from '../appearance/AppearanceProvider';
-import { ApprovalsProvider } from '../approvals/ApprovalsProvider';
-import { ChatProvider } from '../chat/ChatProvider';
-import { ComposerHostProvider } from '../chat/composer/ComposerHostProvider';
-import type { ChatLabels } from '../chat/headless/labels';
-import { ExtensionsProvider } from '../extensions/ExtensionsProvider';
-import type { ExtensionModuleLoader } from '../extensions/ExtensionComponent';
-import { SidebarHostProvider } from '../chat/sidebar/SidebarHostProvider';
-import { FilesProvider } from '../files/FilesProvider';
-import { GitProvider } from '../git/GitProvider';
-import { KeybindingsProvider } from '../keybindings/KeybindingsProvider';
-import { KeyCommandsProvider } from '../keybindings/KeyCommands';
-import { MachinesProvider } from '../machines/MachinesProvider';
-import { OnboardingHostProvider } from '../onboarding/OnboardingProvider';
-import { PaletteProvider } from '../palette/PaletteProvider';
-import { SessionProvider } from '../session/SessionProvider';
-import { SettingsProvider } from '../settings/SettingsProvider';
-import { TerminalProvider } from '../terminal/TerminalProvider';
-import { WorkspaceHostProvider } from '../workspace/WorkspaceProvider';
-import type { AppHost } from './headless/app-host';
-
-const AppHostContext = createContext<AppHost | null>(null);
-
-/** Props for {@link AppHostProvider}. */
-export interface AppHostProviderProps {
-  /** Every area's host the app offers. */
-  host: AppHost;
-  /** Overrides for the chat components' strings, passed to `ChatProvider`. Keys you leave out keep the default English label. */
-  chatLabels?: Partial<ChatLabels>;
-  /** Loads an extension's `ui.tsx` module for the extension components (`ExtensionsProvider`'s `loadModule`). Absent: extension items draw their data. */
-  loadExtensionModule?: ExtensionModuleLoader;
-  /** The app's components. */
-  children: ReactNode;
-}
-
-/**
- * Provides an {@link AppHost} to the components below it, `host.chat` through a `ChatProvider` and `host.palette` through a `PaletteProvider` when present.
- *
- * @param props - Provider props: the `host`, optional `chatLabels`, and the `children` to render.
- */
-export function AppHostProvider({ host, chatLabels, loadExtensionModule, children: app }: AppHostProviderProps) {
-  // The workspace host only goes in context: each `WorkspaceProvider` (the app's scope and tabs) reads it.
-  // Like the workspace host, the onboarding host only goes in context: each `OnboardingProvider` (one run) reads it.
-  const onboarding = host.onboarding ? (
-    <OnboardingHostProvider host={host.onboarding}>{app}</OnboardingHostProvider>
-  ) : (
-    app
-  );
-  // Like the workspace host, the composer host only goes in context: each rich composer below reads it.
-  const composer = host.composer ? (
-    <ComposerHostProvider host={host.composer}>{onboarding}</ComposerHostProvider>
-  ) : (
-    onboarding
-  );
-  // The sidebar host only goes in context: the sidebar's rows and every session menu read it.
-  const sidebar = host.sidebar ? <SidebarHostProvider host={host.sidebar}>{composer}</SidebarHostProvider> : composer;
-  const terminal = host.terminal ? <TerminalProvider host={host.terminal}>{sidebar}</TerminalProvider> : sidebar;
-  const workspace = host.workspace ? (
-    <WorkspaceHostProvider host={host.workspace}>{terminal}</WorkspaceHostProvider>
-  ) : (
-    terminal
-  );
-  const approvals = host.approvals ? (
-    <ApprovalsProvider host={host.approvals}>{workspace}</ApprovalsProvider>
-  ) : (
-    workspace
-  );
-  const extensions = host.extensions ? (
-    <ExtensionsProvider host={host.extensions} {...(loadExtensionModule ? { loadModule: loadExtensionModule } : {})}>
-      {approvals}
-    </ExtensionsProvider>
-  ) : (
-    approvals
-  );
-  const files = host.files ? <FilesProvider host={host.files}>{extensions}</FilesProvider> : extensions;
-  const git = host.git ? <GitProvider host={host.git}>{files}</GitProvider> : files;
-  const machines = host.machines ? <MachinesProvider host={host.machines}>{git}</MachinesProvider> : git;
-  const session = host.session ? <SessionProvider host={host.session}>{machines}</SessionProvider> : machines;
-  const settings = host.settings ? <SettingsProvider host={host.settings}>{session}</SettingsProvider> : session;
-  // The key command registry and its dispatcher, under the bindings: every part registers with `useKeyCommands`.
-  const commands = <KeyCommandsProvider>{settings}</KeyCommandsProvider>;
-  const keybindings = host.keybindings ? (
-    <KeybindingsProvider host={host.keybindings}>{commands}</KeybindingsProvider>
-  ) : (
-    commands
-  );
-  const children = host.appearance ? (
-    <AppearanceProvider host={host.appearance} {...(host.extensions ? { extensions: host.extensions } : {})}>
-      {keybindings}
-    </AppearanceProvider>
-  ) : (
-    keybindings
-  );
-  // The palette's provider (its state and sources) sits inside the chat one, so sources can read chat.
-  const withPalette = host.palette ? <PaletteProvider host={host.palette}>{children}</PaletteProvider> : children;
-  return (
-    <AppHostContext.Provider value={host}>
-      {host.chat ? (
-        <ChatProvider host={host.chat} {...(chatLabels ? { labels: chatLabels } : {})}>
-          {withPalette}
-        </ChatProvider>
-      ) : (
-        withPalette
-      )}
-    </AppHostContext.Provider>
-  );
-}
-
-/** Returns the {@link AppHost} from the nearest {@link AppHostProvider}. Throws when called outside one. */
-export function useAppHost(): AppHost {
-  const host = useContext(AppHostContext);
-  if (!host) throw new Error('zidane-ui/app: wrap the app in <AppHostProvider host={…}>');
-  return host;
-}