zidane-ui 9.0.4 → 9.1.3

package/src/server/scripted-provider.ts

@@ -1,174 +0,0 @@
-/**
- * A deterministic, offline zidane `Provider` for demos and end-to-end tests:
- * no API key, no network. Each model call asks `script` what to say next
- * from the conversation so far (the latest prompt and the tool results the
- * run has gathered since), and streams the answer in word chunks so a client
- * sees a live reply.
- *
- * The default script calls the `lookup` tool once (see `demo-tools.ts`), then
- * answers with what it returned. zidane ships no public mock provider (its
- * own lives in `test/`), hence this one.
- */
-import type { Provider, StreamCallbacks, ToolResult, ToolSpec, TurnResult } from 'zidane/providers';
-import type { SessionMessage } from 'zidane';
-
-/** What a script sees for one model call: the latest prompt and what the run did since. */
-export interface ScriptInput {
-  /** The text of the latest user prompt. */
-  prompt: string;
-  /** Tool results returned since that prompt, oldest first. */
-  toolResults: readonly { callId: string; output: string; isError: boolean }[];
-  /** Model calls made since that prompt (0 on the first). */
-  step: number;
-}
-
-/** What a script answers for one model call: text, optional thinking, and optional tool calls. */
-export interface ScriptedTurn {
-  /** The reply text, streamed to the client in word chunks. */
-  text: string;
-  /** Reasoning text streamed before the reply. */
-  thinking?: string;
-  /** Tool calls the turn makes. With none, the run ends after this turn. */
-  toolCalls?: readonly { id: string; name: string; input: Record<string, unknown> }[];
-}
-
-/** Options for {@link createScriptedProvider}. */
-export interface ScriptedProviderOptions {
-  /** Decides what the provider says for each model call. Default: {@link defaultScript}. */
-  script?: (input: ScriptInput) => ScriptedTurn;
-  /** Milliseconds between streamed chunks (default 15; 0 streams synchronously). */
-  delayMs?: number;
-  /** Words per streamed chunk (default 2). */
-  wordsPerChunk?: number;
-}
-
-/**
- * Calls `lookup` with the prompt, then replies with its result.
- *
- * @param input - The {@link ScriptInput} for the model call.
- */
-export function defaultScript({ prompt, toolResults, step }: ScriptInput): ScriptedTurn {
-  if (step === 0) {
-    return {
-      text: 'Let me look that up.',
-      toolCalls: [{ id: `lookup-${Date.now().toString(36)}`, name: 'lookup', input: { query: prompt } }],
-    };
-  }
-  const found = toolResults.map((r) => r.output).join('\n');
-  return { text: `Here is the scripted answer to “${prompt}”: ${found}` };
-}
-
-type Block = SessionMessage['content'][number];
-
-function textOf(blocks: readonly Block[]): string {
-  return blocks
-    .map((b) => (b.type === 'text' ? b.text : ''))
-    .join('')
-    .trim();
-}
-
-function outputText(output: unknown): string {
-  if (typeof output === 'string') return output;
-  if (Array.isArray(output))
-    return output.map((p) => (p && typeof p === 'object' && 'text' in p ? String(p.text) : '')).join('');
-  return JSON.stringify(output ?? '');
-}
-
-/**
- * The latest prompt and what the run did since, read off the wire messages.
- *
- * @param messages - The conversation messages sent to the provider.
- */
-export function readScriptInput(messages: readonly SessionMessage[]): ScriptInput {
-  let prompt = '';
-  let start = 0;
-  for (let i = messages.length - 1; i >= 0; i--) {
-    const m = messages[i]!;
-    if (m.role !== 'user') continue;
-    const text = textOf(m.content);
-    if (text && !m.content.some((b) => b.type === 'tool_result')) {
-      prompt = text;
-      start = i + 1;
-      break;
-    }
-  }
-  const after = messages.slice(start);
-  const toolResults = after.flatMap((m) =>
-    m.content.flatMap((b) =>
-      b.type === 'tool_result' ? [{ callId: b.callId, output: outputText(b.output), isError: Boolean(b.isError) }] : [],
-    ),
-  );
-  return { prompt, toolResults, step: after.filter((m) => m.role === 'assistant').length };
-}
-
-/**
- * Creates a deterministic, offline zidane `Provider` for demos and tests. Each model call asks `script` what to say and streams the answer in word chunks.
- *
- * @param options - The `script` and the streaming pace.
- */
-export function createScriptedProvider(options: ScriptedProviderOptions = {}): Provider {
-  const script = options.script ?? defaultScript;
-  const delay = options.delayMs ?? 15;
-  const perChunk = options.wordsPerChunk ?? 2;
-  const wait = (signal?: AbortSignal) =>
-    delay > 0 && !signal?.aborted ? new Promise((resolve) => setTimeout(resolve, delay)) : Promise.resolve();
-
-  return {
-    name: 'scripted',
-    meta: { defaultModel: 'scripted', isMock: true },
-    formatTools: (tools: ToolSpec[]) => tools,
-    userMessage: (content: string): SessionMessage => ({ role: 'user', content: [{ type: 'text', text: content }] }),
-    assistantMessage: (content: string): SessionMessage => ({
-      role: 'assistant',
-      content: [{ type: 'text', text: content }],
-    }),
-    toolResultsMessage: (results: ToolResult[]): SessionMessage => ({
-      role: 'user',
-      content: results.map((r) => ({
-        type: 'tool_result' as const,
-        callId: r.id,
-        output: r.content,
-        ...(r.isError ? { isError: true as const } : {}),
-      })),
-    }),
-    async stream(streamOptions, callbacks: StreamCallbacks): Promise<TurnResult> {
-      const signal = (streamOptions as { signal?: AbortSignal }).signal;
-      const turn = script(readScriptInput(streamOptions.messages));
-      if (turn.thinking) {
-        for (const chunk of chunks(turn.thinking, perChunk)) {
-          await wait(signal);
-          if (signal?.aborted) break;
-          callbacks.onThinking?.(chunk);
-        }
-      }
-      let streamed = '';
-      for (const chunk of chunks(turn.text, perChunk)) {
-        await wait(signal);
-        if (signal?.aborted) break;
-        streamed += chunk;
-        callbacks.onText(chunk);
-      }
-      const aborted = Boolean(signal?.aborted);
-      const toolCalls = aborted ? [] : [...(turn.toolCalls ?? [])];
-      const content: SessionMessage['content'] = [];
-      if (turn.thinking) content.push({ type: 'thinking', text: turn.thinking });
-      if (streamed) content.push({ type: 'text', text: streamed });
-      for (const call of toolCalls)
-        content.push({ type: 'tool_call', id: call.id, name: call.name, input: call.input });
-      return {
-        assistantMessage: { role: 'assistant', content },
-        text: streamed,
-        toolCalls,
-        done: toolCalls.length === 0,
-        usage: { input: 10, output: streamed.length },
-      };
-    },
-  };
-}
-
-function chunks(text: string, perChunk: number): string[] {
-  const words = text.split(/(?<=\s)/);
-  const out: string[] = [];
-  for (let i = 0; i < words.length; i += perChunk) out.push(words.slice(i, i + perChunk).join(''));
-  return out;
-}

package/src/server/sse-handler.ts

@@ -1,457 +0,0 @@
-/**
- * The server half of the SSE adapter: a Web-standard
- * `(request: Request) => Promise<Response>` (works in `Bun.serve`, Deno,
- * Node's fetch-style servers, Hono, …) that runs zidane's own chat engine
- * (`createChatHost` from `zidane/chat`, the one zidane-server, the TUI and
- * the desktop app run) and streams its live `StreamEvent`s per session.
- * Protocol: `../adapters/sse-protocol.ts`.
- *
- * Sessions persist in the environment's `SessionStore`; transcripts hydrate
- * with zidane's `eventsFromTurns`. The handler keeps each watched session's
- * transcript (and a bounded replay buffer) in memory, so a reconnecting
- * client resumes where it dropped.
- *
- * Security: every request runs `authorize` first, and the agent's tools run
- * on this machine, in `cwd`. Put real auth in front (a session cookie, a
- * bearer token) and give the agent a directory it may change.
- */
-import { randomUUID } from 'node:crypto';
-
-import type { InteractionResponse } from 'zidane/chat';
-import { createChatHost, eventsFromTurns } from 'zidane/chat';
-
-import type { ChatEvent, ChatInteraction, ChatModelProvider, ChatSession } from '../chat/headless/host';
-import { applyLiveEvent, finishLive } from '../adapters/live-events';
-import {
-  attachmentsFromPreviews,
-  encodeSseRecord,
-  formatCursor,
-  parseCursor,
-  SSE_PROTOCOL_HEADER,
-  SSE_PROTOCOL_VERSION,
-  type HydrateResponse,
-  type SendBody,
-  type StreamRecord,
-} from '../adapters/sse-protocol';
-import type { EnvironmentFactory } from './environment';
-
-type Engine = ReturnType<typeof createChatHost>;
-type Env = Awaited<ReturnType<EnvironmentFactory>>;
-type CreateSessionParams = Parameters<Engine['createSession']>[0];
-
-/** Options for {@link createSseHandler}. */
-export interface SseHandlerOptions {
-  /** zidane's chat environment: `createLocalEnvironment({ provider, tools })`, or `createDaemonEnvironment` from `zidane/ipc` for the machine's own config. */
-  environment: EnvironmentFactory;
-  /** Working directory of every new session: the agent's tools act here. */
-  cwd: string;
-  /**
-   * Called on every request before anything else; resolve false to answer 401.
-   * Required: pass `() => true` only for a server nobody else can reach.
-   */
-  authorize: (request: Request) => boolean | Promise<boolean>;
-  /** Path the handler is mounted at (default `''`), e.g. `'/api/chat'`. */
-  basePath?: string;
-  /** Extra fields for every new session (`providerKey`, `modelId`, `agentId`). */
-  newSession?: Omit<CreateSessionParams, 'cwd' | 'title'>;
-  /** What `GET /models` lists (default none: the composer hides its model picker). */
-  models?: readonly ChatModelProvider[];
-  /** Stream records kept per session for `Last-Event-ID` resumes (default 2000). */
-  replayLimit?: number;
-  /** Keep-alive comment interval in ms (default 15000). */
-  heartbeatMs?: number;
-}
-
-/** A request handler from {@link createSseHandler}: a Web-standard function from `Request` to `Response` that also exposes the engine and a `close` method. */
-export interface SseHandler {
-  (request: Request): Promise<Response>;
-  /** The engine. Starts it when no request has started it yet. */
-  engine(): Promise<Engine>;
-  /** Stop the engine, end every stream, and remove the environment's temp directory. */
-  close(): Promise<void>;
-}
-
-interface Channel {
-  ready: Promise<void>;
-  loaded: boolean;
-  /** Live events that arrived while the history loaded. */
-  early: { event: ChatEvent }[];
-  events: ChatEvent[];
-  seq: number;
-  buffer: { seq: number; record: StreamRecord }[];
-  listeners: Set<(id: string, record: StreamRecord) => void>;
-  /** Ends each open stream of this session. */
-  closers: Set<() => void>;
-}
-
-const json = (body: unknown, status = 200) =>
-  new Response(JSON.stringify(body), {
-    status,
-    headers: { 'Content-Type': 'application/json', [SSE_PROTOCOL_HEADER]: String(SSE_PROTOCOL_VERSION) },
-  });
-const empty = (status: number) =>
-  new Response(null, { status, headers: { [SSE_PROTOCOL_HEADER]: String(SSE_PROTOCOL_VERSION) } });
-
-/**
- * Creates a Web-standard request handler that runs zidane's chat engine and serves it over HTTP and server-sent events, for {@link createSseHost} to talk to. Every request goes through `authorize` first, and the agent's tools run on this machine.
- *
- * @param options - The environment, working directory, and `authorize` check, plus optional base path, models, and stream tuning.
- */
-export function createSseHandler(options: SseHandlerOptions): SseHandler {
-  const basePath = (options.basePath ?? '').replace(/\/+$/, '');
-  const replayLimit = options.replayLimit ?? 2000;
-  const heartbeatMs = options.heartbeatMs ?? 15_000;
-  const epoch = randomUUID().slice(0, 8);
-  const channels = new Map<string, Channel>();
-  const closers = new Set<() => void>();
-  let started: Promise<{ env: Env; engine: Engine }> | null = null;
-
-  const start = () => {
-    if (started) return started;
-    const p = (async () => {
-      const env = await options.environment((signal) => onSignal(signal as Signal));
-      return { env, engine: createChatHost(env) };
-    })();
-    // A failed start is retried by the next request, not cached.
-    p.catch(() => {
-      if (started === p) started = null;
-    });
-    return (started = p);
-  };
-
-  const record = (sessionId: string, rec: StreamRecord) => {
-    const ch = channels.get(sessionId);
-    if (!ch) return;
-    const seq = ++ch.seq;
-    ch.buffer.push({ seq, record: rec });
-    if (ch.buffer.length > replayLimit) ch.buffer.splice(0, ch.buffer.length - replayLimit);
-    const id = formatCursor(epoch, seq);
-    for (const l of ch.listeners) l(id, rec);
-  };
-
-  const live = (sessionId: string, event: ChatEvent) => {
-    const ch = channels.get(sessionId);
-    if (!ch) return;
-    if (ch.loaded) ch.events = applyLiveEvent(ch.events, event);
-    else ch.early.push({ event });
-  };
-
-  type Signal = { kind: string; sessionId?: string } & Record<string, unknown>;
-  function onSignal(signal: Signal) {
-    const sessionId = signal.sessionId;
-    if (!sessionId || !channels.has(sessionId)) return;
-    switch (signal.kind) {
-      case 'event': {
-        const event = signal.event as ChatEvent;
-        live(sessionId, event);
-        record(sessionId, { type: 'event', data: { event, ...(signal.echo ? { echo: true } : {}) } });
-        return;
-      }
-      case 'run:start':
-        record(sessionId, { type: 'run', data: { running: true } });
-        void pushSession(sessionId);
-        return;
-      case 'run:end': {
-        const ch = channels.get(sessionId)!;
-        if (ch.loaded) ch.events = finishLive(ch.events);
-        const ok = signal.ok !== false;
-        record(sessionId, {
-          type: 'run',
-          data: { running: false, ok, ...(typeof signal.error === 'string' ? { error: signal.error } : {}) },
-        });
-        void pushSession(sessionId);
-        return;
-      }
-      case 'interaction:request':
-        record(sessionId, { type: 'interaction', data: { request: signal.request as ChatInteraction['request'] } });
-        return;
-      case 'interaction:resolved':
-        record(sessionId, { type: 'interaction-resolved', data: { requestId: String(signal.requestId) } });
-        return;
-      case 'sessions:changed':
-        if (signal.op === 'update') void pushSession(sessionId);
-    }
-  }
-
-  const toSession = (
-    engine: Engine,
-    row: { id: string; metadata: Record<string, unknown>; createdAt?: number; updatedAt: number; status?: string },
-  ): ChatSession => {
-    const m = row.metadata ?? {};
-    const stored = (row.status as ChatSession['status']) ?? 'idle';
-    // The engine knows first: a stored `running` it no longer runs is a store write still in flight.
-    const status = engine.isSessionRunning(row.id) ? 'running' : stored === 'running' ? 'idle' : stored;
-    return {
-      id: row.id,
-      title: typeof m.title === 'string' && m.title ? m.title : 'New session',
-      status,
-      createdAt: row.createdAt ?? row.updatedAt,
-      updatedAt: row.updatedAt,
-      ...(m.archived === true ? { archived: true } : {}),
-      ...(m.favorite === true ? { favorite: true } : {}),
-      ...(typeof m.modelId === 'string' ? { modelId: m.modelId } : {}),
-    };
-  };
-
-  const loadSession = async (id: string): Promise<ChatSession | null> => {
-    const { env, engine } = await start();
-    const meta = env.store.getMeta ? await env.store.getMeta(id) : await env.store.load(id);
-    return meta ? toSession(engine, meta) : null;
-  };
-
-  const pushSession = async (sessionId: string) => {
-    const session = await loadSession(sessionId).catch(() => null);
-    if (session) record(sessionId, { type: 'session', data: { session } });
-  };
-
-  const listSessions = async (): Promise<ChatSession[]> => {
-    const { env, engine } = await start();
-    const rows = env.store.listMeta
-      ? await env.store.listMeta()
-      : (await Promise.all((await env.store.list()).map((id) => env.store.load(id)))).filter((d) => d !== null);
-    return rows.map((r) => toSession(engine, r)).sort((a, b) => b.updatedAt - a.updatedAt);
-  };
-
-  const channel = async (sessionId: string): Promise<Channel | null> => {
-    let ch = channels.get(sessionId);
-    if (!ch) {
-      const { env } = await start();
-      const created: Channel = {
-        ready: Promise.resolve(),
-        loaded: false,
-        early: [],
-        events: [],
-        seq: 0,
-        buffer: [],
-        listeners: new Set(),
-        closers: new Set(),
-      };
-      channels.set(sessionId, created);
-      created.ready = (async () => {
-        const data = await env.store.load(sessionId).catch((error: unknown) => {
-          // Not left in place: the next request loads it again.
-          if (channels.get(sessionId) === created) channels.delete(sessionId);
-          throw error;
-        });
-        if (!data) {
-          channels.delete(sessionId);
-          return;
-        }
-        let events = eventsFromTurns(data.turns, data.runs) as unknown as ChatEvent[];
-        for (const { event } of created.early) events = applyLiveEvent(events, event);
-        created.events = events;
-        created.early = [];
-        created.loaded = true;
-      })();
-      ch = created;
-    }
-    await ch.ready;
-    return channels.get(sessionId) === ch ? ch : null;
-  };
-
-  const stream = (request: Request, sessionId: string, ch: Channel): Response => {
-    const encoder = new TextEncoder();
-    const last = parseCursor(request.headers.get('Last-Event-ID'));
-    let cleanup = () => {};
-    const body = new ReadableStream<Uint8Array>({
-      start(controller) {
-        const write = (text: string) => {
-          try {
-            controller.enqueue(encoder.encode(text));
-          } catch {
-            cleanup();
-          }
-        };
-        write('retry: 1000\n\n');
-        const oldest = ch.buffer[0]?.seq ?? ch.seq + 1;
-        if (last && (last.epoch !== epoch || last.seq > ch.seq || last.seq < oldest - 1)) {
-          // The records after `last` are gone: the client hydrates again.
-          write(encodeSseRecord(null, { type: 'reset', data: {} }));
-        } else {
-          const after = last?.seq ?? ch.seq;
-          for (const b of ch.buffer) if (b.seq > after) write(encodeSseRecord(formatCursor(epoch, b.seq), b.record));
-        }
-        const listener = (id: string, rec: StreamRecord) => write(encodeSseRecord(id, rec));
-        ch.listeners.add(listener);
-        const beat = setInterval(() => write(': keep-alive\n\n'), heartbeatMs);
-        let closed = false;
-        cleanup = () => {
-          if (closed) return;
-          closed = true;
-          clearInterval(beat);
-          ch.listeners.delete(listener);
-          ch.closers.delete(cleanup);
-          closers.delete(cleanup);
-          try {
-            controller.close();
-          } catch {
-            // already closed
-          }
-        };
-        closers.add(cleanup);
-        ch.closers.add(cleanup);
-        if (request.signal.aborted) cleanup();
-        else request.signal.addEventListener('abort', () => cleanup(), { once: true });
-      },
-      cancel() {
-        cleanup();
-      },
-    });
-    return new Response(body, {
-      headers: {
-        'Content-Type': 'text/event-stream; charset=utf-8',
-        'Cache-Control': 'no-cache, no-transform',
-        Connection: 'keep-alive',
-        'X-Accel-Buffering': 'no',
-        [SSE_PROTOCOL_HEADER]: String(SSE_PROTOCOL_VERSION),
-      },
-    });
-  };
-
-  const readJson = async <T>(request: Request): Promise<T | null> => {
-    const text = await request.text();
-    if (!text) return {} as T;
-    try {
-      const value = JSON.parse(text);
-      return typeof value === 'object' && value !== null ? (value as T) : null;
-    } catch {
-      return null;
-    }
-  };
-
-  const send = async (engine: Engine, sessionId: string, body: SendBody) => {
-    if (body.model) {
-      const at = body.model.indexOf('/');
-      const providerKey = at > 0 ? body.model.slice(0, at) : (options.newSession?.providerKey ?? 'anthropic');
-      const modelId = at > 0 ? body.model.slice(at + 1) : body.model;
-      await engine.setSessionModel(sessionId, {
-        providerKey,
-        modelId,
-        ...(body.thinking ? { effort: body.thinking } : {}),
-      } as Parameters<Engine['setSessionModel']>[1]);
-    }
-    const attachments = attachmentsFromPreviews(body.attachments);
-    await engine.sendPrompt({ sessionId, prompt: body.prompt, ...(attachments.length ? { attachments } : {}) });
-  };
-
-  const route = async (request: Request): Promise<Response> => {
-    const url = new URL(request.url);
-    if (url.pathname !== basePath && !url.pathname.startsWith(`${basePath}/`)) return empty(404);
-    const parts = url.pathname
-      .slice(basePath.length)
-      .split('/')
-      .filter(Boolean)
-      .map((p) => decodeURIComponent(p));
-    const method = request.method.toUpperCase();
-    if (!(await options.authorize(request))) return json({ error: 'unauthorized' }, 401);
-    const { env, engine } = await start();
-
-    if (parts[0] === 'models' && parts.length === 1 && method === 'GET') return json(options.models ?? []);
-
-    if (parts[0] === 'interactions' && parts.length === 3 && method === 'POST') {
-      const [, requestId, action] = parts as [string, string, string];
-      if (action === 'answer') {
-        const body = await readJson<{ response?: InteractionResponse }>(request);
-        if (!body?.response) return json({ error: 'response required' }, 400);
-        return json(engine.interactions.respond(requestId, body.response));
-      }
-      if (action === 'cancel') {
-        const body = await readJson<{ reason?: string }>(request);
-        return json(engine.interactions.cancel(requestId, typeof body?.reason === 'string' ? body.reason : undefined));
-      }
-      return empty(404);
-    }
-
-    if (parts[0] !== 'sessions') return empty(404);
-    if (parts.length === 1) {
-      if (method === 'GET') return json(await listSessions());
-      if (method === 'POST') {
-        const body = await readJson<{ title?: string }>(request);
-        if (!body) return json({ error: 'invalid JSON' }, 400);
-        const id = await engine.createSession({
-          ...options.newSession,
-          cwd: options.cwd,
-          ...(typeof body.title === 'string' && body.title ? { title: body.title } : {}),
-        });
-        await channel(id);
-        return json(await loadSession(id), 201);
-      }
-      return empty(405);
-    }
-
-    const sessionId = parts[1]!;
-    const action = parts[2];
-    if (!(await env.store.load(sessionId))) return json({ error: 'no such session' }, 404);
-
-    if (action === undefined) {
-      if (method === 'PATCH') {
-        const body = await readJson<{ title?: unknown; archived?: unknown; favorite?: unknown }>(request);
-        if (!body) return json({ error: 'invalid JSON' }, 400);
-        const patch: Record<string, unknown> = {};
-        if (typeof body.title === 'string') patch.title = body.title;
-        if (typeof body.archived === 'boolean') patch.archived = body.archived;
-        if (typeof body.favorite === 'boolean') patch.favorite = body.favorite;
-        if (Object.keys(patch).length) await engine.patchSessionMeta(sessionId, patch, { bumpUpdatedAt: false });
-        return json(await loadSession(sessionId));
-      }
-      if (method === 'DELETE') {
-        await engine.deleteSession(sessionId);
-        const ch = channels.get(sessionId);
-        channels.delete(sessionId);
-        for (const close of [...(ch?.closers ?? [])]) close();
-        return empty(204);
-      }
-      return empty(405);
-    }
-
-    const ch = await channel(sessionId);
-    if (!ch) return json({ error: 'no such session' }, 404);
-
-    if (action === 'events' && method === 'GET') {
-      const body: HydrateResponse = {
-        events: ch.events,
-        running: engine.isSessionRunning(sessionId),
-        cursor: formatCursor(epoch, ch.seq),
-        interactions: engine.interactions
-          .list(sessionId)
-          .map((p) => ({ requestId: p.request.id, sessionId, request: p.request })),
-      };
-      return json(body);
-    }
-    if (action === 'stream' && method === 'GET') return stream(request, sessionId, ch);
-    if (method !== 'POST') return empty(405);
-
-    if (action === 'send') {
-      const body = await readJson<SendBody>(request);
-      if (!body || typeof body.prompt !== 'string') return json({ error: 'prompt required' }, 400);
-      await send(engine, sessionId, body);
-      return json({ ok: true }, 202);
-    }
-    if (action === 'interrupt') {
-      engine.interrupt(sessionId);
-      return empty(204);
-    }
-    if (action === 'steer' || action === 'follow-up') {
-      const body = await readJson<{ message?: unknown }>(request);
-      if (!body || typeof body.message !== 'string') return json({ error: 'message required' }, 400);
-      const ok = action === 'steer' ? engine.steer(sessionId, body.message) : engine.followUp(sessionId, body.message);
-      return json({ ok });
-    }
-    return empty(404);
-  };
-
-  const handler = (async (request: Request) => {
-    try {
-      return await route(request);
-    } catch (error) {
-      return json({ error: error instanceof Error ? error.message : String(error) }, 500);
-    }
-  }) as SseHandler;
-  handler.engine = async () => (await start()).engine;
-  handler.close = async () => {
-    for (const c of [...closers]) c();
-    if (started) (await started).engine.shutdown();
-    options.environment.dispose?.();
-  };
-  return handler;
-}

package/src/server/testing/index.ts

@@ -1,7 +0,0 @@
-/**
- * `zidane-ui/server/testing` (Node and Bun): a scripted provider that answers
- * without a model, and demo tools, to run the kit's server half in docs, demos
- * and tests without credentials.
- */
-export * from '../scripted-provider';
-export * from '../demo-tools';