@kitn.ai/ui 0.27.0 → 0.29.0

package/src/solid.ts

@@ -1,165 +0,0 @@
-// `@kitn.ai/ui/solid` — the COMPLETE SolidJS surface.
-//
-// WHY THIS EXISTS
-// ---------------
-// Solid is this kit's authored layer, so every registered `kai-*` element must be
-// writable as a Solid component (`verify:solid-coverage` enforces 79/79 plus a
-// `<Name>Props` type for every public component). But the root entry "." is what
-// EVERY consumer resolves, including the React/Vue/Svelte/vanilla majority who
-// only ever touch the web components. Growing "." to full Solid coverage cost
-// them 591,359 -> 705,031 bytes (+113,672, +19.2%; +23,160 gzipped) for a surface
-// four of the five supported frameworks cannot even call.
-//
-// So the full Solid catalog lives here instead, and this file is compiled as its
-// OWN build target (vite.config.solid.ts -> dist/solid.js, plus the SSR twin
-// vite.config.solid.server.ts -> dist/solid.server.js, mirroring "."). Nothing
-// below is reachable from dist/index.js, which is the entire point: a React
-// consumer's bundle never sees it.
-//
-// WHY IT COMPOSES "." INSTEAD OF RESTATING IT
-// -------------------------------------------
-// `export * from './index'` makes "./solid is a superset of ." a COMPILER
-// invariant rather than a promise two hand-maintained lists have to keep. This
-// repo has been bitten repeatedly by copied lists that no compiler watches; a
-// restated 400-line barrel would be exactly that, and the failure mode is silent
-// (an export lands on "." only, and Solid consumers never learn it exists).
-//
-// This costs nothing at the package boundary. The composition is resolved at
-// SOURCE level and bundled away: dist/solid.js is a standalone artifact with no
-// runtime dependency on dist/index.js, so importing "./solid" does not drag in a
-// second entry, and importing "." does not drag in any of this.
-//
-// A Solid consumer therefore needs exactly one import:
-//   import { Thread, Dialog, Message, type ThreadProps } from '@kitn.ai/ui/solid';
-export * from './index';
-
-// ---------------------------------------------------------------------------
-// Layer 2 additions: UI primitives the coarse elements render.
-// ---------------------------------------------------------------------------
-export { HoverCardRoot, HoverCardTrigger, HoverCardContent } from './ui/hover-card';
-export type {
-  HoverCardRootProps, HoverCardTriggerProps, HoverCardContentProps,
-} from './ui/hover-card';
-export {
-  DropdownSeparator, DropdownLabel, DropdownCheckboxItem, DropdownRadioItem,
-  DropdownSub, DropdownSubTrigger, DropdownSubContent,
-} from './ui/dropdown';
-export type {
-  DropdownSeparatorProps, DropdownLabelProps, DropdownCheckboxItemProps, DropdownRadioItemProps,
-  DropdownSubProps, DropdownSubTriggerProps, DropdownSubContentProps,
-} from './ui/dropdown';
-export { clampBasis } from './ui/resizable';
-export { Input } from './ui/input';
-export type { InputProps } from './ui/input';
-export { Kbd } from './ui/kbd';
-export type { KbdProps, KbdPlatform } from './ui/kbd';
-export { Checkbox } from './ui/checkbox';
-export type { CheckboxProps } from './ui/checkbox';
-export { Radio, RadioGroup } from './ui/radio';
-export type { RadioProps, RadioGroupProps, RadioOption } from './ui/radio';
-export { CheckboxGroup } from './ui/checkbox-group';
-export type { CheckboxGroupProps, CheckboxOption } from './ui/checkbox-group';
-export { Switch } from './ui/switch';
-export type { SwitchProps } from './ui/switch';
-export { Slider } from './ui/slider';
-export type { SliderProps } from './ui/slider';
-export { Select } from './ui/select';
-export type { SelectProps, SelectOption } from './ui/select';
-export { Tabs } from './ui/tabs';
-export type { TabsProps, TabsVariant, KaiTabItem } from './ui/tabs';
-export { Segmented } from './ui/segmented';
-export type { SegmentedProps, SegmentedOption } from './ui/segmented';
-export { Status } from './ui/status';
-export type { StatusProps, StatusKind } from './ui/status';
-export { ProgressBar } from './ui/progress-bar';
-export type { ProgressBarProps, ProgressTone } from './ui/progress-bar';
-export { Notice } from './ui/notice';
-export type { NoticeProps, NoticeSeverity } from './ui/notice';
-export { EditableLabel } from './ui/editable-label';
-export type { EditableLabelProps } from './ui/editable-label';
-export { Dialog } from './ui/dialog';
-export type { DialogProps, DialogController } from './ui/dialog';
-export { Dock, DockLauncherGlyph, DockCloseGlyph } from './ui/dock';
-export type { DockProps, DockController, DockPosition, DockFocusOnOpen } from './ui/dock';
-export { Popover } from './ui/popover';
-export type { PopoverProps, PopoverController } from './ui/popover';
-export { Nav } from './ui/nav';
-export type { NavProps, KaiNavItem, NavItemStatus, NavStatusTone } from './ui/nav';
-export { CommandList } from './ui/command';
-export type { CommandListProps, CommandRow, CommandGroup } from './ui/command';
-export { AgentCard } from './ui/agent-card';
-export type { AgentCardProps, AgentStatus, AgentStatusTone } from './ui/agent-card';
-export { Pane } from './ui/pane';
-export type { PaneProps, PaneStatus, PaneStatusTone } from './ui/pane';
-export { PaneGroup } from './ui/pane-group';
-export type { PaneGroupProps, PaneTab, PaneTabStatus } from './ui/pane-group';
-// PaneGrid and the three overlay primitives have Storybook pages that tell a
-// consumer to `import { … } from '@kitn.ai/ui'` — and were exported from NEITHER
-// entry, so those snippets named symbols nobody could import. They belong on
-// ./solid (Solid-only building blocks, and the overlay trio is what you compose a
-// custom popover/tooltip out of).
-export { PaneGrid } from './ui/pane-grid';
-export type { PaneGridProps } from './ui/pane-grid';
-export { createPresence, usePosition, useDismiss } from './ui/overlay';
-export type { UsePositionOptions, UseDismissOptions, DismissReason } from './ui/overlay';
-export { PromptDock } from './ui/prompt-dock';
-export type { PromptDockProps, PromptDockFrame, PromptDockAppearance } from './ui/prompt-dock';
-export { SettingsGroup, SettingItem } from './ui/settings-group';
-export type { SettingsGroupProps, SettingItemProps } from './ui/settings-group';
-// `kai-icon` renders no kit component — it calls this. Solid consumers resolving
-// the same `icon` strings (named icon | URL | text fallback) need it too.
-export { renderIcon } from './ui/icon';
-
-// ---------------------------------------------------------------------------
-// Layer 3 additions: AI/feature components.
-// ---------------------------------------------------------------------------
-export { ChainOfThoughtAccordion } from './components/chain-of-thought';
-export type { ChainOfThoughtAccordionProps } from './components/chain-of-thought';
-export { VoiceOutput } from './components/voice-output';
-export type { VoiceOutputProps, VoiceOutputController } from './components/voice-output';
-export { CollapsedRail } from './components/conversation-list';
-export type { CollapsedRailProps } from './components/conversation-list';
-
-// ---------------------------------------------------------------------------
-// Layer 3b: the composed thread/shell components the coarse elements wrap.
-// These are what `<kai-thread>`, `<kai-chat>`, `<kai-screen>`, `<kai-coachmark>` and
-// `<kai-composer>` render, so a Solid consumer writes one component for one element
-// instead of re-deriving the scroll/feedback/staging behaviour by hand.
-// ---------------------------------------------------------------------------
-export { Thread } from './components/thread';
-export type { ThreadProps, ThreadController } from './components/thread';
-// ChatThread — the component behind `<kai-chat>`. VERIFIED standalone: rendered in
-// a plain Vite+Solid app (no custom element, no shadow root) it draws its header,
-// the full message list and its BUILT-IN composer; typing into that composer and
-// pressing Send fires `onSubmit` with the typed text and the thread updates, with
-// no console errors.
-//
-// It does emit 5 `<slot>` elements — header-start, header-end, input-top,
-// toolbar-start, toolbar-end. Those are OPTIONAL INJECT points with no assigned
-// nodes outside the facade, so they render nothing; they are only fillable from
-// `<kai-chat>`'s light DOM. The REPLACE/INJECT props (`sidebar`, `empty`,
-// `composer`, `headerFull`, `footer`, `composerActions`) are opt-in switches that
-// the FACADE sets when a host slots content — left at their default they emit no
-// slot at all and the built-in UI renders. So a Solid consumer can ignore all of
-// it; they just cannot project content into those five points without the element.
-export { ChatThread } from './components/chat-thread';
-export type { ChatThreadProps, ChatThreadController, ChatThreadContextUsage } from './components/chat-thread';
-export { Screen } from './components/screen';
-export type { ScreenProps, ScreenController } from './components/screen';
-export { Coachmark } from './components/coachmark';
-export type { CoachmarkProps, CoachmarkController } from './components/coachmark';
-export { Composer } from './components/composer';
-export type {
-  ComposerProps, ComposerController, ComposerChange, TriggerDef, TriggerItem, HighlightRule,
-} from './components/composer';
-// AudioVisualizer — the component behind `<kai-audio-visualizer>`. It arrived on
-// main after this entry was written, and the coverage guard caught it as the one
-// element with no writable SolidJS equivalent, which is exactly the job.
-export { AudioVisualizer } from './components/audio-visualizer';
-export type {
-  AudioVisualizerProps, VisualizerVariant, ShaderSpec, ShaderVariantProps,
-} from './components/audio-visualizer';
-export type { VisualizerSize } from './components/audio-visualizer/sizes';
-export { WorkspaceShell, type WorkspaceShellProps, type WorkspaceShellController, type WorkspaceAsideSide, type WorkspaceAsideToggleDetail, type WorkspaceAsideResizeDetail } from './components/workspace-shell';
-export { createConversationItemsController, readConversationItemId } from './components/conversation-list';
-export type { ConversationItemsController, ConversationItemsControllerOptions } from './components/conversation-list';

package/src/state/index.ts

@@ -1,44 +0,0 @@
-// Framework-neutral state core for @kitn.ai/ui. Pure functions over ChatMessage[]
-// + a typed streaming handle. No React/Solid runtime — drives a consumer setter.
-export { appendMessage, upsertMessage, updateMessage, removeMessage, appendText, textMessage, partsToText } from './messages';
-export { addSuggestion, removeSuggestion } from './suggestions';
-export { createAssistantStream, onStreamSettled } from './stream';
-export type { SetMessages, AssistantStream } from './stream';
-export { appendTextPart, appendReasoningPart, upsertToolPart, upsertCardPart, fingerprint } from './parts';
-export type { ReasoningOpts } from './parts';
-
-// Multi-thread mechanics (the workspace recast, spec §3b): the id-bound
-// SetMessages fold + the in-flight-turn bookkeeping. The consumer's record
-// shape and every persistence/retention decision stay outside — see ./threads.
-export { updateThreadMessages, bindThreadMessages, createThreadSessions } from './threads';
-export type { ThreadLike, SetThreads, BindThreadOptions, ThreadSessions } from './threads';
-
-// The persistence SEAM, not persistence: the stored-thread validator (F-18,
-// variant list derived from the MessagePart union) and the debounce/flush
-// shape. No storage backend, no default delay — policy is the consumer's.
-export { parseStoredThread, createSaveScheduler } from './persistence';
-export type { ParsedThread, DroppedStored, SaveScheduler, SaveSchedulerOptions } from './persistence';
-
-// The zero-config mock. Produces SSE frames rather than folding parts directly,
-// so the no-backend preview runs through the SAME parser a real provider does —
-// and is deliberately impossible to mistake for one. See ./mock.
-export { createMockResponder, DEFAULT_MOCK_REPLIES, MOCK_BANNER, MOCK_MARKER, MOCK_MARKER_KEY, MOCK_MODEL_ID } from './mock';
-export type { MockReply, MockResponder, MockResponderOptions, MockToolCall, MockTurn } from './mock';
-
-// The content-model types every signature above mentions. Without these a
-// consumer importing only from '@kitn.ai/ui/state' cannot annotate the very
-// values these helpers take and return (the missing-annotation gap that made an
-// un-annotated `const history = [...]` widen to `string` and fail TS2322).
-export type {
-  ChatMessage, ChatMessageAction, CustomAction, AvatarData, FeedbackVote, MessagePart,
-  MessageSource, RawOrigin,
-} from '../elements/chat-types';
-export type { ToolPart } from '../components/tool-types';
-export type { ToolKind } from '../components/tool-classify';
-// upsertToolPart defaults `kind` to classifyTool(type) and reverts it on a type
-// change (see ./parts), and ToolPart.kind's doc comment names the function, so a
-// consumer computing `kind` itself needs the identical classifier — not a
-// hand-rolled copy that drifts from ours.
-export { classifyTool } from '../components/tool-classify';
-export type { CardEnvelope } from '../primitives/card-contract';
-export type { AttachmentData } from '../components/attachment-types';

package/src/state/messages.ts

@@ -1,53 +0,0 @@
-import type { ChatMessage, MessagePart } from '../elements/chat-types';
-import { appendTextPart } from './parts';
-
-function newId(): string {
-  if (typeof crypto !== 'undefined' && crypto.randomUUID) return crypto.randomUUID();
-  return 'kai-' + Math.random().toString(36).slice(2);
-}
-
-/** Convenience for the common single-text-part message. */
-export function textMessage(role: ChatMessage['role'], text: string, init: Partial<ChatMessage> = {}): ChatMessage {
-  return { id: init.id ?? newId(), role, parts: [{ type: 'text', text }], ...init };
-}
-
-/** Concatenates every text part. Use where a plain string is genuinely needed
- *  (copy-to-clipboard, TTS, a length check). Do NOT use it for rendering. */
-export function partsToText(parts: MessagePart[]): string {
-  return parts.filter((p) => p.type === 'text').map((p) => p.text).join('');
-}
-
-/** Append a message; returns a new array. */
-export function appendMessage(messages: ChatMessage[], msg: ChatMessage): ChatMessage[] {
-  return [...messages, msg];
-}
-
-/** Replace a same-id message, or append when absent. */
-export function upsertMessage(messages: ChatMessage[], msg: ChatMessage): ChatMessage[] {
-  const i = messages.findIndex((x) => x.id === msg.id);
-  if (i === -1) return [...messages, msg];
-  const next = messages.slice();
-  next[i] = msg;
-  return next;
-}
-
-/** Patch the matched message (object patch or updater). Untouched items keep their reference. */
-export function updateMessage(
-  messages: ChatMessage[],
-  id: string,
-  patch: Partial<ChatMessage> | ((m: ChatMessage) => ChatMessage),
-): ChatMessage[] {
-  return messages.map((x) =>
-    x.id === id ? (typeof patch === 'function' ? patch(x) : { ...x, ...patch }) : x,
-  );
-}
-
-/** Remove the matched message. */
-export function removeMessage(messages: ChatMessage[], id: string): ChatMessage[] {
-  return messages.filter((x) => x.id !== id);
-}
-
-/** Streaming primitive: append `delta` onto the matched message's trailing text part. */
-export function appendText(messages: ChatMessage[], id: string, delta: string): ChatMessage[] {
-  return messages.map((x) => (x.id === id ? { ...x, parts: appendTextPart(x.parts, delta) } : x));
-}

package/src/state/mock.ts

@@ -1,297 +0,0 @@
-// The mock responder: the zero-config first win, standardized.
-//
-// WHAT IT IS
-// ----------
-// `createMockResponder()` returns a function that produces a STREAM SOURCE —
-// SSE text frames in the OpenAI chat-completions shape — which the caller hands
-// to `readOpenAIStream` from `@kitn.ai/ui/wire` exactly as it would hand over a
-// `fetch()` Response. There is no network, no key and no provider.
-//
-// WHY IT PRODUCES A WIRE INSTEAD OF FOLDING PARTS DIRECTLY
-// -------------------------------------------------------
-// The obvious cheaper design is to yield text deltas and let the caller fold
-// them onto `parts` with `appendTextPart`. That is what the scaffolder and all
-// five composed starters used to do, in seven separate copies, and it is worse
-// on every axis that matters:
-//
-//   · It BYPASSES the kit's own parser. The zero-config default is the code path
-//     every new developer runs first, and under the folding design it exercised
-//     none of `sseDataFrames` / `sseJson` / `openaiChatFormat` /
-//     `consumeModelStream`. Producing a wire makes the first-run path a live
-//     regression test of the thing every real integration depends on.
-//   · It makes the mock scaffold and the real scaffold STRUCTURALLY DIFFERENT,
-//     so "swap the mock for a real backend" is a rewrite of the submit handler
-//     rather than a one-expression change. With a wire, the only difference
-//     between the two emitted scaffolds is `mockResponse(value)` vs
-//     `await fetch('/api/chat', …)`; `createAssistantStream`, `readOpenAIStream`,
-//     the try/catch/finally and the abort handling are byte-identical.
-//   · The hand-rolled folds drifted. One of them replaced `parts` wholesale,
-//     which silently deleted any reasoning/tool parts already on the message.
-//
-// The frames are the OpenAI chat-completions shape because the mock stands in
-// for the consumer's `/api/chat` ROUTE, not for a provider: every integration in
-// the kit's catalog except this one re-frames its provider to that shape
-// server-side (see `readOpenAIStream`), so matching it is what keeps the swap to
-// a real backend a one-line change.
-//
-// WHY YOU CAN TELL IT IS A MOCK — READ THIS BEFORE CHANGING ANY STRING BELOW
-// -------------------------------------------------------------------------
-// A mock that is indistinguishable from a real response is how a fabricated turn
-// gets believed. This repo has already shipped that bug once: a scaffold seeded a
-// tool call from fixture data, the panel rendered "search Completed", and the
-// fabricated turn was POSTed to the provider AHEAD of the user's own message. A
-// human demoing it saw success; only an assertion on the round-2 answer failed.
-//
-// Choosing a real provider's frame SHAPE (above) means shape alone can no longer
-// distinguish the mock, so the tells are deliberate and layered. Each is visible
-// at a different altitude, so whichever one a developer happens to be looking at,
-// something says "no provider was contacted":
-//
-//   1. RAW STREAM — the first bytes are an SSE comment banner (`: kai-mock …`).
-//      Comment lines are dropped by `sseDataFrames`, so this is free
-//      semantically and unmissable to anyone reading the stream or a capture.
-//   2. EVERY FRAME — carries `_kai_mock`, a full sentence naming this function.
-//      The OpenAI reader ignores fields it does not know, so it costs nothing
-//      and it survives JSON parsing: logging any single frame shows it.
-//   3. FIELD LEVEL — `model` is `kai-mock`, which is not a model any provider
-//      serves. If a mock frame were ever echoed back upstream it would be
-//      REJECTED rather than quietly accepted, which is the specific failure the
-//      fabricated-tool-call bug needed and did not get.
-//   4. TURN LEVEL — usage is all zeros. A real turn that produced text cannot
-//      report zero completion tokens, so `turn.usage` disambiguates in the app,
-//      not merely in the bytes.
-//   5. UI LEVEL — the reply says so in words. The WEAKEST tell and the only one
-//      a real model could imitate, which is exactly why it is not the only one.
-//
-// CONSTRAINTS
-// -----------
-// Zero dependencies, no DOM, no Solid, no network, and nothing that is not a
-// global in both Node and the browser (`setTimeout`, `JSON`). This module is
-// part of `@kitn.ai/ui/state`, which is import-safe on a server — see
-// `verify:ssr`. It deliberately does NOT import from `@kitn.ai/ui/wire`: it
-// yields `AsyncIterable<string>`, which is structurally a `StreamSource`, so the
-// dependency runs one way (a caller pairs them) and `state` keeps its charter of
-// owning no wire format.
-
-/** The `model` every mock frame reports. Not a model any provider serves — see
- *  tell 3 in the header. */
-export const MOCK_MODEL_ID = 'kai-mock';
-
-/** The marker field carried by every mock frame. Tell 2. */
-export const MOCK_MARKER_KEY = '_kai_mock';
-
-/** The value of that marker: a whole sentence, because it is read by a human
- *  staring at a logged frame and wondering where the reply came from. */
-export const MOCK_MARKER =
-  'no provider was contacted — this reply was generated locally by createMockResponder() from @kitn.ai/ui/state';
-
-/** The SSE comment that opens every mock stream. Tell 1. */
-export const MOCK_BANNER = `: kai-mock — NO PROVIDER WAS CONTACTED. ${MOCK_MARKER}.`;
-
-/** The default canned replies, cycled per turn so a multi-turn preview stays
- *  coherent instead of repeating one line forever. */
-export const DEFAULT_MOCK_REPLIES: readonly string[] = [
-  "Hi! I'm a local mock — no backend, no API key, no provider was contacted. I'm streaming through the same parser a real model would, so what you're seeing is the real rendering path with a canned reply.",
-  "Still the mock. Swap `createMockResponder()` for a `fetch('/api/chat', …)` and nothing else in this handler changes — that's the whole point of the seam.",
-  'Mock again. Every frame I send is tagged `_kai_mock` and my usage reports zero tokens, so nothing here can be mistaken for a real turn.',
-];
-
-/** One scripted tool call for a mock turn. Framed exactly the way the OpenAI
- *  chat-completions wire frames a real one — an announce fragment carrying
- *  `id`/`function.name`, then the argument JSON streamed in fragments — so the
- *  kit's own reader (`readOpenAIStream`) reassembles it through the same path a
- *  real provider's call takes. */
-export interface MockToolCall {
-  /** The tool name, e.g. `'get_weather'` or a card tool like `'kai_confirm'`. */
-  name: string;
-  /** The call's arguments. Serialized with `JSON.stringify` and streamed as
-   *  fragments, like a real provider. Defaults to `{}`. */
-  arguments?: unknown;
-  /** Explicit tool-call id. Defaults to `call_kai-mock-<turn>-<n>`, which keeps
-   *  the mock's naming tell (see tell 3): no provider issues ids in that shape. */
-  id?: string;
-}
-
-/** A scripted mock turn: optional text, then optional tool calls. A turn with
- *  tool calls finishes `finish_reason: 'tool_calls'`, exactly as a real
- *  tool-calling turn does; a turn without them finishes `'stop'`. */
-export interface MockTurn {
-  /** Text streamed (token by token) before the tool calls. */
-  text?: string;
-  /** Tool calls announced this turn, in order. */
-  toolCalls?: readonly MockToolCall[];
-}
-
-/** A canned reply: plain text, or a scripted turn. A string is exactly
- *  `{ text }` — the pre-tool-call API unchanged. */
-export type MockReply = string | MockTurn;
-
-export interface MockResponderOptions {
-  /** Canned replies, cycled one per turn. Plain strings stream as text; a
-   *  `MockTurn` can also script tool calls (`{ text, toolCalls }`), which is
-   *  what lets the zero-config mock exercise the kit's tool/card path without
-   *  hand-rolled SSE framing. Defaults to `DEFAULT_MOCK_REPLIES`. */
-  replies?: readonly MockReply[];
-  /** Delay between chunks, in ms. Defaults to 24 — fast enough to feel alive,
-   *  slow enough that the streaming is visible. `0` streams as fast as the
-   *  event loop allows, which is what tests want. */
-  delayMs?: number;
-  /** How many whitespace-delimited tokens ride in each frame. Defaults to 1
-   *  (token by token). Larger values coarsen the cadence. */
-  chunkSize?: number;
-  /** Log a one-time notice on the first turn. Defaults to `true`: the point of
-   *  this module is that a mock reply is hard to mistake for a real one, and a
-   *  console line is the fastest way for a human to notice. Pass `false` in
-   *  tests, or wherever the banner and the frame markers are tell enough. */
-  announce?: boolean;
-}
-
-/** Produces one turn's worth of SSE frames. Structurally a `StreamSource`, so it
- *  goes straight into `readOpenAIStream(responder(text), stream)`. */
-export type MockResponder = (prompt?: string) => AsyncIterable<string>;
-
-/** Split into whitespace-preserving tokens, so re-joining the deltas reproduces
- *  the reply exactly (the separators are tokens too). */
-function tokenize(reply: string, chunkSize: number): string[] {
-  const parts = reply.split(/(\s+)/).filter((t) => t !== '');
-  if (chunkSize <= 1) return parts;
-  const out: string[] = [];
-  for (let i = 0; i < parts.length; i += chunkSize) {
-    out.push(parts.slice(i, i + chunkSize).join(''));
-  }
-  return out;
-}
-
-function frame(id: string, body: Record<string, unknown>): string {
-  // The marker goes FIRST so it is the first thing visible in a logged or
-  // captured frame, before the payload a reader would skim for.
-  return `data: ${JSON.stringify({
-    [MOCK_MARKER_KEY]: MOCK_MARKER,
-    id,
-    object: 'chat.completion.chunk',
-    model: MOCK_MODEL_ID,
-    ...body,
-  })}\n\n`;
-}
-
-const delay = (ms: number): Promise<void> =>
-  ms > 0 ? new Promise((r) => setTimeout(r, ms)) : Promise.resolve();
-
-/** Normalize a canned reply: a plain string is exactly `{ text }`. */
-const asTurn = (reply: MockReply): MockTurn => (typeof reply === 'string' ? { text: reply } : reply);
-
-/** How many characters of argument JSON ride in each tool-call fragment. Small
- *  enough that any realistic argument object spans several frames, so the
- *  reader's fragment-reassembly path — the one a real provider exercises — is
- *  exercised here too, rather than a single-frame shortcut it would never see
- *  in production. */
-const TOOL_ARG_FRAGMENT_CHARS = 16;
-
-/** Split argument JSON into the fragments a provider streams. Never empty: an
- *  empty-object call still sends its `'{}'` so the reader has arguments to
- *  parse. */
-function argumentFragments(json: string): string[] {
-  const out: string[] = [];
-  for (let i = 0; i < json.length; i += TOOL_ARG_FRAGMENT_CHARS) {
-    out.push(json.slice(i, i + TOOL_ARG_FRAGMENT_CHARS));
-  }
-  return out.length > 0 ? out : [''];
-}
-
-/**
- * Build a mock responder.
- *
- * ```ts
- * import { createAssistantStream, createMockResponder } from '@kitn.ai/ui/state';
- * import { readOpenAIStream } from '@kitn.ai/ui/wire';
- *
- * const mockResponse = createMockResponder();
- * const stream = createAssistantStream(setMessages);
- * await readOpenAIStream(mockResponse(value), stream);   // <- swap for fetch()
- * stream.done();
- * ```
- */
-export function createMockResponder(options: MockResponderOptions = {}): MockResponder {
-  const {
-    replies = DEFAULT_MOCK_REPLIES,
-    delayMs = 24,
-    chunkSize = 1,
-    announce = true,
-  } = options;
-
-  const pool = replies.length > 0 ? replies : DEFAULT_MOCK_REPLIES;
-  let turn = 0;
-  let announced = false;
-
-  return function respond(_prompt?: string): AsyncIterable<string> {
-    const scripted = asTurn(pool[turn % pool.length]);
-    const id = `kai-mock-${turn + 1}`;
-    const turnNumber = turn + 1;
-    turn += 1;
-
-    return {
-      async *[Symbol.asyncIterator]() {
-        if (announce && !announced) {
-          announced = true;
-          // Not console.warn: nothing is wrong. This is the mock announcing
-          // itself so a developer never has to wonder whether the reply they
-          // are looking at came from a model.
-          console.info(`[kai] ${MOCK_BANNER.slice(2)}`);
-        }
-
-        // Tell 1. Dropped by the parser (`sseDataFrames` skips ':' lines), so it
-        // costs nothing semantically — and it exercises that comment-skipping
-        // path, which real providers use for keep-alives.
-        yield `${MOCK_BANNER}\n\n`;
-
-        // The role frame a real OpenAI stream opens with: no content, so it also
-        // exercises the reader's empty-delta path.
-        yield frame(id, { choices: [{ index: 0, delta: { role: 'assistant' }, finish_reason: null }] });
-
-        for (const token of tokenize(scripted.text ?? '', chunkSize)) {
-          await delay(delayMs);
-          yield frame(id, { choices: [{ index: 0, delta: { content: token }, finish_reason: null }] });
-        }
-
-        // Scripted tool calls, framed the way the OpenAI wire frames real ones:
-        // one announce fragment per call (`index`/`id`/`function.name` + empty
-        // arguments), then the argument JSON in fragments. The kit's reader
-        // reassembles them through the exact path a real provider's call takes.
-        const toolCalls = scripted.toolCalls ?? [];
-        for (let index = 0; index < toolCalls.length; index += 1) {
-          const call = toolCalls[index];
-          // Tell 3's shape, extended to call ids: no provider issues these.
-          const callId = call.id ?? `call_${MOCK_MODEL_ID}-${turnNumber}-${index + 1}`;
-          await delay(delayMs);
-          yield frame(id, {
-            choices: [{
-              index: 0,
-              delta: { tool_calls: [{ index, id: callId, function: { name: call.name, arguments: '' } }] },
-              finish_reason: null,
-            }],
-          });
-          for (const fragment of argumentFragments(JSON.stringify(call.arguments ?? {}))) {
-            await delay(delayMs);
-            yield frame(id, {
-              choices: [{
-                index: 0,
-                delta: { tool_calls: [{ index, function: { arguments: fragment } }] },
-                finish_reason: null,
-              }],
-            });
-          }
-        }
-
-        // Tell 4: zero usage. A real turn that produced this much text cannot
-        // report zero completion tokens. A turn that announced tool calls ends
-        // `tool_calls`, exactly as a real one does, so the consumer's tool loop
-        // branches the same way it would against a provider.
-        yield frame(id, {
-          choices: [{ index: 0, delta: {}, finish_reason: toolCalls.length > 0 ? 'tool_calls' : 'stop' }],
-          usage: { prompt_tokens: 0, completion_tokens: 0, total_tokens: 0 },
-        });
-        yield 'data: [DONE]\n\n';
-      },
-    };
-  };
-}