@kitn.ai/ui 0.20.1 → 0.21.0

package/dist/state/parts.d.ts

@@ -0,0 +1,85 @@
+import { MessagePart, RawOrigin } from '../elements/chat-types.js';
+import { ToolPart } from '../components/tool-types.js';
+import { CardEnvelope } from '../primitives/card-contract.js';
+/** Stable structural fingerprint. Key order independent, so an identical snapshot
+ *  arriving twice compares equal and can be skipped. */
+export declare function fingerprint(value: unknown): string;
+/** Appends to the trailing text part, or OPENS A NEW ONE if the last part is not
+ *  text. This is what stops a post-tool answer being glued onto the pre-tool text. */
+export declare function appendTextPart(parts: MessagePart[], delta: string): MessagePart[];
+export interface ReasoningOpts {
+    index?: number;
+    /** Namespaces `index` to one provider response stream. Producers that read more
+     *  than one stream into the SAME message must set it. See `appendReasoningPart`. */
+    streamId?: string;
+    label?: string;
+    signature?: string;
+    raw?: RawOrigin;
+}
+/** Keyed by `(streamId, index)` so parallel reasoning blocks stay distinct.
+ *
+ *  WHY THE KEY IS A PAIR. A block index alone is NOT unique inside one `parts`
+ *  array. Anthropic numbers content blocks per MESSAGE and restarts at 0 on the
+ *  next one, while a tool loop folds every round into a single assistant turn.
+ *  Keyed on index alone, round 2's thinking block (index 0) merges into round 1's
+ *  part: the text concatenates and `raw: opts.raw ?? cur.raw` OVERWRITES round 1's
+ *  verbatim provider payload with round 2's. `toAnthropicMessages` then emits one
+ *  thinking block where two belong, carrying round 2's signature in round 1's
+ *  position -- a modified-and-filtered thinking block, which is exactly the 400
+ *  the verbatim `raw` channel exists to prevent.
+ *
+ *  `streamId` is the namespace: one value per provider response stream, attached
+ *  by `consumeModelStream`. Two rounds are two streams, so their index 0s are two
+ *  parts. Producers that drive a sink from a single stream can omit it; `undefined`
+ *  is its own namespace and behaves exactly as before.
+ *
+ *  Returns the SAME array reference when the merge produces an identical part,
+ *  for the same reason `upsertToolPart` does: a new `parts` array is the
+ *  re-render signal, so handing one back for a delta that changed nothing is a
+ *  spurious render.
+ *
+ *  An EMPTY delta is not a no-op and must still reach here: it is how a redacted
+ *  reasoning block, a `signature_delta` and an assembled `content_block_stop`
+ *  block arrive, and how a format opens a block at the right position so block
+ *  ORDER survives into `parts`. Those carry a new `raw`/`signature`/index and so
+ *  compare unequal and DO rebuild. What the check absorbs is the other empty
+ *  frame: one carrying nothing new, which a provider is free to send repeatedly.
+ *
+ *  `signature` and `raw` resolve with `??`, so an explicit `undefined` from a
+ *  later delta never blanks a value an earlier one established. Pass a DEFINED
+ *  value to replace either; there is no way to clear them. */
+export declare function appendReasoningPart(parts: MessagePart[], delta: string, opts?: ReasoningOpts): MessagePart[];
+/** Creates or REPLACES a card part, keyed on `envelope.id`. Returns the SAME array
+ *  reference when the incoming envelope is structurally identical to the current
+ *  one, for the same reason `upsertToolPart` does: a new `parts` array is the
+ *  re-render signal, so handing one back for a revision that changed nothing is a
+ *  spurious render.
+ *
+ *  WHY THIS REPLACES WHERE `upsertToolPart` MERGES. A tool part is patched
+ *  fragment-by-fragment as its arguments stream in, which is why that function
+ *  needs carry-forward rules for `raw` and `kind` — a later patch that omits a
+ *  field is not asserting the field is gone. A card envelope is the opposite: it
+ *  arrives WHOLE, as one complete tool result, so an omitted field IS an
+ *  assertion. Last-write-wins is both simpler and the only semantics under which
+ *  a host can CLEAR `resolution` to re-open a dismissed card — a field-by-field
+ *  merge can only ever set that field, never unset it, so `CardPolicy.onReopen`
+ *  (see `primitives/card-contract.ts`) would have no way to express its result.
+ *
+ *  The PART-level `raw` is preserved across a revision. It is a different field
+ *  from anything inside the envelope: the untranslated provider payload the part
+ *  was built from, attached once by the producer, which a fresh envelope carries
+ *  no opinion about.
+ *
+ *  Position is preserved: a revised card stays where it first appeared in the
+ *  thread rather than jumping past the text that followed it. */
+export declare function upsertCardPart(parts: MessagePart[], envelope: CardEnvelope): MessagePart[];
+/** Creates or merges a tool part. Returns the SAME array reference when the merge
+ *  produces an identical tool, so repeated snapshots do not trigger a re-render.
+ *
+ *  Two fields do NOT follow plain spread semantics, because a streaming provider
+ *  hands them over on one fragment and then keeps patching the rest:
+ *  - `kind`: a value the consumer set is preserved across later patches instead
+ *    of being reverted to `classifyTool(type)` (see `resolveKind`).
+ *  - `raw`: an explicit `raw: undefined` never blanks a `raw` an earlier patch
+ *    established. Pass a DEFINED `raw` to replace it; there is no way to clear it. */
+export declare function upsertToolPart(parts: MessagePart[], toolCallId: string, patch: Partial<ToolPart>): MessagePart[];

package/dist/state/stream.d.ts

@@ -1,18 +1,24 @@
-import { ChatMessage } from '../elements/chat-types';
-import { ToolPart } from '../components/tool-types';
+import { ChatMessage, Source } from '../elements/chat-types.js';
+import { ToolPart } from '../components/tool-types.js';
+import { CardEnvelope } from '../primitives/card-contract.js';
+import { AttachmentData } from '../components/attachment-types.js';
+import { ReasoningOpts } from './parts.js';
 /** The one universal contract: a functional-updater setter (React setState shape). */
 export type SetMessages = (updater: (prev: ChatMessage[]) => ChatMessage[]) => void;
 /** A fluent builder for one in-flight assistant message. Owns no state. */
 export interface AssistantStream {
     readonly id: string;
     appendText(delta: string): AssistantStream;
-    setText(content: string): AssistantStream;
-    appendReasoning(delta: string, label?: string): AssistantStream;
-    setReasoning(text: string, label?: string): AssistantStream;
-    upsertTool(tool: ToolPart): AssistantStream;
-    updateTool(toolCallId: string, patch: Partial<ToolPart>): AssistantStream;
-    patch(patch: Partial<ChatMessage>): AssistantStream;
-    done(final?: Partial<ChatMessage>): void;
+    appendReasoning(delta: string, opts?: ReasoningOpts): AssistantStream;
+    upsertTool(toolCallId: string, patch: Partial<ToolPart>): AssistantStream;
+    /** Adds a card, or REPLACES the existing one with the same `envelope.id`. A
+     *  model that revises a card mid-turn re-sends the whole envelope, so a second
+     *  call with a known id revises that card in place rather than rendering a
+     *  second copy of it. See `upsertCardPart`. */
+    addCard(envelope: CardEnvelope): AssistantStream;
+    addSource(source: Source): AssistantStream;
+    addFile(attachment: AttachmentData): AssistantStream;
+    done(): void;
     abort(reason?: string): void;
 }
 /** Start an assistant message and drive it through `set`. New refs on every mutation. */

package/dist/state.d.ts

@@ -0,0 +1,5 @@
+// GENERATED by scripts/emit-subpath-dts.mjs — do not edit.
+// Sibling declarations for dist/state.js, so that RELATIVE imports
+// of this bundle (which bypass package.json "exports") still resolve to types.
+// Without this, tsc resolves the path to the .js and reports TS7016.
+export * from './state/index.js';

package/dist/state.js

@@ -1,117 +1,286 @@
-function c(t, u) {
-  return [...t, u];
+function y(t) {
+  const e = t.toLowerCase();
+  return e ? e.includes("bash") || e.includes("command") || e.includes("shell") || e.includes("terminal") || e.includes("exec") ? "command" : e.includes("edit") || e.includes("write") || e.includes("patch") || e.includes("replace") || e.includes("delete") ? "file-change" : e.includes("search") || e.includes("grep") || e.includes("glob") || e.includes("find") ? "search" : e.includes("fetch") || e.includes("http") || e.includes("browse") || e.includes("crawl") ? "fetch" : e.includes("mcp") ? "mcp" : e.includes("image") || e.includes("screenshot") || e.includes("vision") ? "image" : "generic" : "generic";
 }
-function f(t, u) {
-  const o = t.findIndex((d) => d.id === u.id);
-  if (o === -1) return [...t, u];
-  const e = t.slice();
-  return e[o] = u, e;
+function d(t) {
+  const e = /* @__PURE__ */ new WeakSet(), n = (r) => {
+    if (r === null || typeof r != "object") return r;
+    if (e.has(r)) return "[circular]";
+    e.add(r);
+    const i = r, u = Array.isArray(r) ? r.map(n) : Object.fromEntries(Object.keys(i).sort().map((o) => [o, n(i[o])]));
+    return e.delete(r), u;
+  };
+  return JSON.stringify(n(t)) ?? "";
+}
+function k(t, e) {
+  const n = t[t.length - 1];
+  return (n == null ? void 0 : n.type) === "text" ? [...t.slice(0, -1), { ...n, text: n.text + e }] : [...t, { type: "text", text: e }];
+}
+function h(t, e, n = {}) {
+  const r = n.index ?? 0, i = n.streamId, u = t.findIndex(
+    (s) => s.type === "reasoning" && (s.index ?? 0) === r && s.streamId === i
+  );
+  if (u < 0)
+    return [...t, { type: "reasoning", text: e, index: r, streamId: i, label: n.label, signature: n.signature, raw: n.raw }];
+  const o = t[u], a = {
+    ...o,
+    text: o.text + e,
+    label: n.label ?? o.label,
+    signature: n.signature ?? o.signature,
+    raw: n.raw ?? o.raw
+  };
+  return O(o, a) ? t : [...t.slice(0, u), a, ...t.slice(u + 1)];
+}
+const I = [
+  "type",
+  "text",
+  "index",
+  "streamId",
+  "label",
+  "signature",
+  "raw"
+], T = {
+  type: (t, e) => t.type === e.type,
+  text: (t, e) => t.text === e.text,
+  index: (t, e) => t.index === e.index,
+  streamId: (t, e) => t.streamId === e.streamId,
+  label: (t, e) => t.label === e.label,
+  signature: (t, e) => t.signature === e.signature,
+  raw: (t, e) => t.raw === e.raw
+};
+function O(t, e) {
+  return I.every((n) => T[n](t, e));
+}
+function _(t, e) {
+  const n = t.findIndex((i) => i.type === "card" && i.envelope.id === e.id);
+  if (n < 0) return [...t, { type: "card", envelope: e }];
+  const r = t[n];
+  return d(r.envelope) === d(e) ? t : [...t.slice(0, n), { ...r, envelope: e }, ...t.slice(n + 1)];
+}
+function b(t, e, n) {
+  const r = t.findIndex((o) => o.type === "tool" && o.tool.toolCallId === e);
+  if (r < 0) {
+    const o = {
+      type: n.type ?? "unknown",
+      state: n.state ?? "input-streaming",
+      ...n,
+      toolCallId: e
+    };
+    return o.kind = o.kind ?? y(o.type), [...t, { type: "tool", tool: o }];
+  }
+  const i = t[r].tool, u = { ...i, ...n, toolCallId: e };
+  return u.kind = M(i, n, u.type), u.raw === void 0 && i.raw !== void 0 && (u.raw = i.raw), E(i, u) ? t : [...t.slice(0, r), { type: "tool", tool: u }, ...t.slice(r + 1)];
+}
+function M(t, e, n) {
+  return e.kind !== void 0 ? e.kind : t.kind === void 0 || t.kind === y(t.type) ? y(n) : t.kind;
+}
+const S = [
+  "type",
+  "state",
+  "kind",
+  "toolCallId",
+  "errorText",
+  "rawInput",
+  "raw",
+  "input",
+  "output"
+], R = {
+  type: (t, e) => t.type === e.type,
+  state: (t, e) => t.state === e.state,
+  kind: (t, e) => t.kind === e.kind,
+  toolCallId: (t, e) => t.toolCallId === e.toolCallId,
+  errorText: (t, e) => t.errorText === e.errorText,
+  rawInput: (t, e) => t.rawInput === e.rawInput,
+  raw: (t, e) => t.raw === e.raw,
+  input: (t, e) => t.input === e.input || d(t.input) === d(e.input),
+  output: (t, e) => t.output === e.output || d(t.output) === d(e.output)
+};
+function E(t, e) {
+  return S.every((n) => R[n](t, e));
 }
-function T(t, u, o) {
+function C() {
+  return typeof crypto < "u" && crypto.randomUUID ? crypto.randomUUID() : "kai-" + Math.random().toString(36).slice(2);
+}
+function U(t, e, n = {}) {
+  return { id: n.id ?? C(), role: t, parts: [{ type: "text", text: e }], ...n };
+}
+function j(t) {
+  return t.filter((e) => e.type === "text").map((e) => e.text).join("");
+}
+function L(t, e) {
+  return [...t, e];
+}
+function $(t, e) {
+  const n = t.findIndex((i) => i.id === e.id);
+  if (n === -1) return [...t, e];
+  const r = t.slice();
+  return r[n] = e, r;
+}
+function F(t, e, n) {
   return t.map(
-    (e) => e.id === u ? typeof o == "function" ? o(e) : { ...e, ...o } : e
+    (r) => r.id === e ? typeof n == "function" ? n(r) : { ...r, ...n } : r
   );
 }
-function g(t, u) {
-  return t.filter((o) => o.id !== u);
+function Y(t, e) {
+  return t.filter((n) => n.id !== e);
 }
-function I(t, u, o) {
-  return t.map((e) => e.id === u ? { ...e, content: e.content + o } : e);
+function q(t, e, n) {
+  return t.map((r) => r.id === e ? { ...r, parts: k(r.parts, n) } : r);
 }
-function x(t, u) {
-  return t.includes(u) ? t.slice() : [...t, u];
+function G(t, e) {
+  return t.includes(e) ? t.slice() : [...t, e];
 }
-function y(t, u) {
-  return t.filter((o) => o !== u);
+function J(t, e) {
+  return t.filter((n) => n !== e);
 }
-function l() {
-  return typeof crypto < "u" && typeof crypto.randomUUID == "function" ? crypto.randomUUID() : "kai-" + Math.random().toString(36).slice(2);
+function A() {
+  return typeof crypto < "u" && crypto.randomUUID ? crypto.randomUUID() : "kai-" + Math.random().toString(36).slice(2);
 }
-function b(t, u = {}) {
-  const o = u.id ?? l(), e = { id: o, role: "assistant", content: "", ...u };
-  t((n) => [...n, e]);
-  const d = (n) => t((r) => r.map((a) => a.id === o ? n(a) : a)), i = {
-    id: o,
-    appendText(n) {
-      return d((r) => ({ ...r, content: r.content + n })), i;
-    },
-    setText(n) {
-      return d((r) => ({ ...r, content: n })), i;
+function W(t, e = {}) {
+  const n = e.id ?? A();
+  let r = !1;
+  t((o) => [...o, { id: n, role: "assistant", parts: [], ...e }]);
+  const i = (o) => {
+    r || t((a) => {
+      const s = a.findIndex((l) => l.id === n);
+      if (s < 0) return a;
+      const c = o(a[s].parts);
+      return c === a[s].parts ? a : [...a.slice(0, s), { ...a[s], parts: c }, ...a.slice(s + 1)];
+    });
+  }, u = {
+    id: n,
+    appendText(o) {
+      return i((a) => k(a, o)), u;
     },
-    appendReasoning(n, r) {
-      return d((a) => {
-        var s, p;
-        return { ...a, reasoning: { text: (((s = a.reasoning) == null ? void 0 : s.text) ?? "") + n, label: r ?? ((p = a.reasoning) == null ? void 0 : p.label) } };
-      }), i;
+    appendReasoning(o, a) {
+      return i((s) => h(s, o, a)), u;
     },
-    setReasoning(n, r) {
-      return d((a) => {
-        var s;
-        return { ...a, reasoning: { text: n, label: r ?? ((s = a.reasoning) == null ? void 0 : s.label) } };
-      }), i;
+    upsertTool(o, a) {
+      return i((s) => b(s, o, a)), u;
     },
-    upsertTool(n) {
-      return d((r) => {
-        const a = r.tools ? r.tools.slice() : [], s = n.toolCallId != null ? a.findIndex((p) => p.toolCallId === n.toolCallId) : a.findIndex((p) => p.type === n.type);
-        return s === -1 ? a.push(n) : a[s] = n, { ...r, tools: a };
-      }), i;
+    // Upsert, not append: keyed on envelope.id so a revised card replaces itself.
+    addCard(o) {
+      return i((a) => _(a, o)), u;
     },
-    updateTool(n, r) {
-      return d((a) => ({ ...a, tools: (a.tools ?? []).map((s) => s.toolCallId === n ? { ...s, ...r } : s) })), i;
+    addSource(o) {
+      return i((a) => [...a, { type: "source", source: o }]), u;
     },
-    patch(n) {
-      return d((r) => ({ ...r, ...n })), i;
+    addFile(o) {
+      return i((a) => [...a, { type: "file", attachment: o }]), u;
     },
-    done(n) {
-      n && d((r) => ({ ...r, ...n }));
+    done() {
+      r = !0;
     },
-    abort(n) {
-      n ? d((r) => ({ ...r, tools: (r.tools ?? []).map((a) => ({ ...a, state: "output-error", errorText: n })) })) : t((r) => r.filter((a) => a.id !== o));
+    abort(o) {
+      i((a) => a.map((s) => s.type === "tool" && s.tool.state !== "output-available" ? { ...s, tool: { ...s.tool, state: "output-error", errorText: o } } : s)), r = !0;
     }
   };
-  return i;
+  return u;
 }
-function R(t, u) {
-  const o = {
+function v(t, e) {
+  const n = {
     id: t.id,
-    appendText(e) {
-      return t.appendText(e), o;
+    appendText(r) {
+      return t.appendText(r), n;
     },
-    setText(e) {
-      return t.setText(e), o;
+    appendReasoning(r, i) {
+      return t.appendReasoning(r, i), n;
     },
-    appendReasoning(e, d) {
-      return t.appendReasoning(e, d), o;
+    upsertTool(r, i) {
+      return t.upsertTool(r, i), n;
     },
-    setReasoning(e, d) {
-      return t.setReasoning(e, d), o;
+    addCard(r) {
+      return t.addCard(r), n;
     },
-    upsertTool(e) {
-      return t.upsertTool(e), o;
+    addSource(r) {
+      return t.addSource(r), n;
     },
-    updateTool(e, d) {
-      return t.updateTool(e, d), o;
+    addFile(r) {
+      return t.addFile(r), n;
     },
-    patch(e) {
-      return t.patch(e), o;
+    done() {
+      t.done(), e();
     },
-    done(e) {
-      t.done(e), u();
-    },
-    abort(e) {
-      t.abort(e), u();
+    abort(r) {
+      t.abort(r), e();
     }
   };
-  return o;
+  return n;
+}
+const K = "kai-mock", N = "_kai_mock", w = "no provider was contacted — this reply was generated locally by createMockResponder() from @kitn.ai/ui/state", m = `: kai-mock — NO PROVIDER WAS CONTACTED. ${w}.`, g = [
+  "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."
+];
+function P(t, e) {
+  const n = t.split(/(\s+)/).filter((i) => i !== "");
+  if (e <= 1) return n;
+  const r = [];
+  for (let i = 0; i < n.length; i += e)
+    r.push(n.slice(i, i + e).join(""));
+  return r;
+}
+function p(t, e) {
+  return `data: ${JSON.stringify({
+    [N]: w,
+    id: t,
+    object: "chat.completion.chunk",
+    model: K,
+    ...e
+  })}
+
+`;
+}
+const D = (t) => t > 0 ? new Promise((e) => setTimeout(e, t)) : Promise.resolve();
+function z(t = {}) {
+  const {
+    replies: e = g,
+    delayMs: n = 24,
+    chunkSize: r = 1,
+    announce: i = !0
+  } = t, u = e.length > 0 ? e : g;
+  let o = 0, a = !1;
+  return function(c) {
+    const l = u[o % u.length], f = `kai-mock-${o + 1}`;
+    return o += 1, {
+      async *[Symbol.asyncIterator]() {
+        i && !a && (a = !0, console.info(`[kai] ${m.slice(2)}`)), yield `${m}
+
+`, yield p(f, { choices: [{ index: 0, delta: { role: "assistant" }, finish_reason: null }] });
+        for (const x of P(l, r))
+          await D(n), yield p(f, { choices: [{ index: 0, delta: { content: x }, finish_reason: null }] });
+        yield p(f, {
+          choices: [{ index: 0, delta: {}, finish_reason: "stop" }],
+          usage: { prompt_tokens: 0, completion_tokens: 0, total_tokens: 0 }
+        }), yield `data: [DONE]
+
+`;
+      }
+    };
+  };
 }
 export {
-  x as addSuggestion,
-  I as appendContent,
-  c as appendMessage,
-  b as createAssistantStream,
-  R as onStreamSettled,
-  g as removeMessage,
-  y as removeSuggestion,
-  T as updateMessage,
-  f as upsertMessage
+  g as DEFAULT_MOCK_REPLIES,
+  m as MOCK_BANNER,
+  w as MOCK_MARKER,
+  N as MOCK_MARKER_KEY,
+  K as MOCK_MODEL_ID,
+  G as addSuggestion,
+  L as appendMessage,
+  h as appendReasoningPart,
+  q as appendText,
+  k as appendTextPart,
+  y as classifyTool,
+  W as createAssistantStream,
+  z as createMockResponder,
+  d as fingerprint,
+  v as onStreamSettled,
+  j as partsToText,
+  Y as removeMessage,
+  J as removeSuggestion,
+  U as textMessage,
+  F as updateMessage,
+  _ as upsertCardPart,
+  $ as upsertMessage,
+  b as upsertToolPart
 };

package/dist/ui/action-icons.d.ts

@@ -1,5 +1,5 @@
 import { Component } from 'solid-js';
-import { ChatMessageAction } from '../elements/chat-types';
+import { ChatMessageAction } from '../elements/chat-types.js';
 type IconComponent = Component<{
     class?: string;
 }>;

package/dist/ui/collapsible.d.ts

@@ -14,7 +14,7 @@ export interface CollapsibleController {
     open: Accessor<boolean>;
     setOpen: (v: boolean) => void;
 }
-export declare function Collapsible(props: {
+export interface CollapsibleProps {
     open?: boolean;
     defaultOpen?: boolean;
     onOpenChange?: (open: boolean) => void;
@@ -26,16 +26,21 @@ export declare function Collapsible(props: {
     controllerRef?: (api: CollapsibleController) => void;
     children: JSX.Element;
     class?: string;
-}): JSX.Element;
-export declare function CollapsibleTrigger(props: {
+}
+export declare function Collapsible(props: CollapsibleProps): JSX.Element;
+export interface CollapsibleTriggerProps {
     children?: JSX.Element;
     class?: string;
     as?: (props: Record<string, any>) => JSX.Element;
     onClick?: JSX.EventHandlerUnion<HTMLButtonElement, MouseEvent>;
+    /** Remaining attributes are spread onto the rendered trigger. */
     [k: string]: any;
-}): JSX.Element;
-export declare function CollapsibleContent(props: {
+}
+export declare function CollapsibleTrigger(props: CollapsibleTriggerProps): JSX.Element;
+export interface CollapsibleContentProps {
     children?: JSX.Element;
     class?: string;
+    /** Remaining attributes are spread onto the rendered panel. */
     [k: string]: any;
-}): JSX.Element;
+}
+export declare function CollapsibleContent(props: CollapsibleContentProps): JSX.Element;