@kanzo-tech/ai 0.16.0 → 0.18.0

package/dist/chat.d.ts

@@ -0,0 +1,41 @@
+import { UIMessage } from '@kanzo-tech/llm';
+import { UseChatHelpers } from '@ai-sdk/react';
+import { ToolPart } from './tool.js';
+import * as React from "react";
+/** Every word `Chat` draws. English by default. */
+export interface ChatTranslations {
+    /** The composer's placeholder. */
+    placeholder: string;
+    /** Announced to a screen reader with the error that stopped an answer. */
+    failed: string;
+}
+/**
+ * How a host draws its own tools' results, by tool name. Each gets the call's part — typed, when the
+ * host's messages are (`InferAgentUIMessage<typeof agent>`) — and draws inside the tool's frame,
+ * under its input: a result table, a chart, an action that takes the result somewhere.
+ */
+export type ChatToolRenderers = Record<string, (part: ToolPart) => React.ReactNode>;
+/** What `Chat` reads from `useChat` — the helpers, not the hook, so any chat state can drive it. */
+type ChatState<M extends UIMessage> = Pick<UseChatHelpers<M>, "messages" | "status" | "error" | "sendMessage" | "stop" | "regenerate">;
+export interface ChatProps<M extends UIMessage> {
+    /** `useChat(...)`'s return. */
+    chat: ChatState<M>;
+    tools?: ChatToolRenderers;
+    /** What the panel says before the first question. */
+    empty?: React.ReactNode;
+    /** Questions to start from, while the conversation is empty. Pressing one asks it. */
+    suggestions?: string[];
+    translations?: Partial<ChatTranslations>;
+    className?: string;
+}
+/**
+ * A conversation with a model, whole: the transcript, the model's reasoning and calls as they
+ * happen, markdown that streams, and a composer that sends, stops and retries. A host brings the
+ * chat (`useChat`) and draws its own tools' results; everything else is here.
+ *
+ * Each part is drawn from the AI SDK's own message parts, so nothing is translated on the way in:
+ * text as markdown, `reasoning` folded away, every tool call in its frame with the SDK's state.
+ */
+export declare function Chat<M extends UIMessage>(props: ChatProps<M>): React.JSX.Element;
+export {};
+//# sourceMappingURL=chat.d.ts.map

package/dist/chat.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chat.d.ts","sourceRoot":"","sources":["../src/chat.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAC/B,OAAO,EAA6B,KAAK,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAC5E,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAYpD,OAAO,EAAwD,KAAK,QAAQ,EAAE,MAAM,WAAW,CAAC;AAEhG,mDAAmD;AACnD,MAAM,WAAW,gBAAgB;IAC/B,kCAAkC;IAClC,WAAW,EAAE,MAAM,CAAC;IACpB,0EAA0E;IAC1E,MAAM,EAAE,MAAM,CAAC;CAChB;AAOD;;;;GAIG;AACH,MAAM,MAAM,iBAAiB,GAAG,MAAM,CAAC,MAAM,EAAE,CAAC,IAAI,EAAE,QAAQ,KAAK,KAAK,CAAC,SAAS,CAAC,CAAC;AAEpF,oGAAoG;AACpG,KAAK,SAAS,CAAC,CAAC,SAAS,SAAS,IAAI,IAAI,CACxC,cAAc,CAAC,CAAC,CAAC,EACjB,UAAU,GAAG,QAAQ,GAAG,OAAO,GAAG,aAAa,GAAG,MAAM,GAAG,YAAY,CACxE,CAAC;AAEF,MAAM,WAAW,SAAS,CAAC,CAAC,SAAS,SAAS;IAC5C,+BAA+B;IAC/B,IAAI,EAAE,SAAS,CAAC,CAAC,CAAC,CAAC;IACnB,KAAK,CAAC,EAAE,iBAAiB,CAAC;IAC1B,qDAAqD;IACrD,KAAK,CAAC,EAAE,KAAK,CAAC,SAAS,CAAC;IACxB,sFAAsF;IACtF,WAAW,CAAC,EAAE,MAAM,EAAE,CAAC;IACvB,YAAY,CAAC,EAAE,OAAO,CAAC,gBAAgB,CAAC,CAAC;IACzC,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED;;;;;;;GAOG;AACH,wBAAgB,IAAI,CAAC,CAAC,SAAS,SAAS,EAAE,KAAK,EAAE,SAAS,CAAC,CAAC,CAAC,qBAiG5D"}

package/dist/chat.js

@@ -0,0 +1,77 @@
+"use client";
+import { jsxs as o, jsx as t } from "react/jsx-runtime";
+import * as N from "react";
+import { isToolUIPart as C, getToolName as S } from "@kanzo-tech/llm";
+import { Suggestions as b, Suggestion as I, cn as w } from "@kanzo-tech/ui";
+import { Conversation as M, ConversationContent as k, ConversationScrollButton as P } from "./conversation.js";
+import { MessageMarkdown as j } from "./markdown.js";
+import { MessageList as D, Message as H, MessageContent as L } from "./message.js";
+import { PromptInput as R, PromptInputTextarea as $, PromptInputToolbar as A, PromptInputSubmit as B } from "./prompt-input.js";
+import { Reasoning as E } from "./reasoning.js";
+import { Tool as G, ToolHeader as O, ToolContent as U, ToolInput as q, ToolOutput as z } from "./tool.js";
+const F = {
+  placeholder: "Ask anything…",
+  failed: "The answer stopped:"
+};
+function ee(p) {
+  const { chat: s, tools: h = {}, empty: f, suggestions: a, translations: g, className: x } = p, i = { ...F, ...g }, [l, c] = N.useState(""), m = s.status === "submitted" || s.status === "streaming", v = s.messages.at(-1), d = (e) => {
+    e.trim() && (s.sendMessage({ text: e }), c(""));
+  };
+  return /* @__PURE__ */ o("div", { className: w("flex min-h-0 flex-1 flex-col gap-3", x), "data-slot": "chat", children: [
+    /* @__PURE__ */ o(M, { children: [
+      /* @__PURE__ */ o(k, { children: [
+        s.messages.length === 0 ? /* @__PURE__ */ o("div", { className: "flex flex-1 flex-col items-center justify-center gap-4 text-center", "data-slot": "chat-empty", children: [
+          f,
+          a && a.length > 0 && /* @__PURE__ */ t(b, { className: "justify-center", children: a.map((e) => /* @__PURE__ */ t(I, { onSelect: d, value: e, children: e }, e)) })
+        ] }) : /* @__PURE__ */ t(D, { children: s.messages.map((e) => /* @__PURE__ */ t(H, { role: e.role, children: /* @__PURE__ */ t(L, { children: e.parts.map((r, y) => {
+          const n = `${e.id}-${y}`, T = m && e === v;
+          if (r.type === "text")
+            return e.role === "user" ? /* @__PURE__ */ t("p", { className: "whitespace-pre-wrap break-words", children: r.text }, n) : /* @__PURE__ */ t(j, { streaming: T && r.state === "streaming", children: r.text }, n);
+          if (r.type === "reasoning") return /* @__PURE__ */ t(E, { part: r }, n);
+          if (C(r)) {
+            const u = h[S(r)];
+            return /* @__PURE__ */ o(G, { part: r, children: [
+              /* @__PURE__ */ t(O, {}),
+              /* @__PURE__ */ o(U, { children: [
+                /* @__PURE__ */ t(q, {}),
+                u && r.state === "output-available" ? u(r) : /* @__PURE__ */ t(z, {})
+              ] })
+            ] }, n);
+          }
+          return null;
+        }) }) }, e.id)) }),
+        s.error && /* @__PURE__ */ o("p", { className: "text-destructive-foreground text-sm", "data-slot": "chat-error", role: "alert", children: [
+          /* @__PURE__ */ o("span", { className: "sr-only", children: [
+            i.failed,
+            " "
+          ] }),
+          s.error.message
+        ] })
+      ] }),
+      /* @__PURE__ */ t(P, {})
+    ] }),
+    /* @__PURE__ */ o(
+      R,
+      {
+        onSubmit: (e) => {
+          e.preventDefault(), m ? s.stop() : s.status === "error" && !l.trim() ? s.regenerate() : d(l);
+        },
+        children: [
+          /* @__PURE__ */ t(
+            $,
+            {
+              onChange: (e) => c(e.target.value),
+              placeholder: i.placeholder,
+              value: l
+            }
+          ),
+          /* @__PURE__ */ t(A, { children: /* @__PURE__ */ t(B, { status: s.status }) })
+        ]
+      }
+    )
+  ] });
+}
+export {
+  ee as Chat
+};
+//# sourceMappingURL=chat.js.map

package/dist/chat.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"chat.js","sources":["../src/chat.tsx"],"sourcesContent":["\"use client\";\n\nimport * as React from \"react\";\nimport { getToolName, isToolUIPart, type UIMessage } from \"@kanzo-tech/llm\";\nimport type { UseChatHelpers } from \"@ai-sdk/react\";\nimport { cn, Suggestion, Suggestions } from \"@kanzo-tech/ui\";\nimport { Conversation, ConversationContent, ConversationScrollButton } from \"./conversation.js\";\nimport { MessageMarkdown } from \"./markdown.js\";\nimport { Message, MessageContent, MessageList } from \"./message.js\";\nimport {\n  PromptInput,\n  PromptInputSubmit,\n  PromptInputTextarea,\n  PromptInputToolbar,\n} from \"./prompt-input.js\";\nimport { Reasoning } from \"./reasoning.js\";\nimport { Tool, ToolContent, ToolHeader, ToolInput, ToolOutput, type ToolPart } from \"./tool.js\";\n\n/** Every word `Chat` draws. English by default. */\nexport interface ChatTranslations {\n  /** The composer's placeholder. */\n  placeholder: string;\n  /** Announced to a screen reader with the error that stopped an answer. */\n  failed: string;\n}\n\nconst ENGLISH: ChatTranslations = {\n  placeholder: \"Ask anything…\",\n  failed: \"The answer stopped:\",\n};\n\n/**\n * How a host draws its own tools' results, by tool name. Each gets the call's part — typed, when the\n * host's messages are (`InferAgentUIMessage<typeof agent>`) — and draws inside the tool's frame,\n * under its input: a result table, a chart, an action that takes the result somewhere.\n */\nexport type ChatToolRenderers = Record<string, (part: ToolPart) => React.ReactNode>;\n\n/** What `Chat` reads from `useChat` — the helpers, not the hook, so any chat state can drive it. */\ntype ChatState<M extends UIMessage> = Pick<\n  UseChatHelpers<M>,\n  \"messages\" | \"status\" | \"error\" | \"sendMessage\" | \"stop\" | \"regenerate\"\n>;\n\nexport interface ChatProps<M extends UIMessage> {\n  /** `useChat(...)`'s return. */\n  chat: ChatState<M>;\n  tools?: ChatToolRenderers;\n  /** What the panel says before the first question. */\n  empty?: React.ReactNode;\n  /** Questions to start from, while the conversation is empty. Pressing one asks it. */\n  suggestions?: string[];\n  translations?: Partial<ChatTranslations>;\n  className?: string;\n}\n\n/**\n * A conversation with a model, whole: the transcript, the model's reasoning and calls as they\n * happen, markdown that streams, and a composer that sends, stops and retries. A host brings the\n * chat (`useChat`) and draws its own tools' results; everything else is here.\n *\n * Each part is drawn from the AI SDK's own message parts, so nothing is translated on the way in:\n * text as markdown, `reasoning` folded away, every tool call in its frame with the SDK's state.\n */\nexport function Chat<M extends UIMessage>(props: ChatProps<M>) {\n  const { chat, tools = {}, empty, suggestions, translations, className } = props;\n  const t = { ...ENGLISH, ...translations };\n  const [draft, setDraft] = React.useState(\"\");\n  const busy = chat.status === \"submitted\" || chat.status === \"streaming\";\n  const last = chat.messages.at(-1);\n\n  const ask = (text: string) => {\n    if (!text.trim()) return;\n    void chat.sendMessage({ text });\n    setDraft(\"\");\n  };\n\n  return (\n    <div className={cn(\"flex min-h-0 flex-1 flex-col gap-3\", className)} data-slot=\"chat\">\n      <Conversation>\n        <ConversationContent>\n          {chat.messages.length === 0 ? (\n            <div className=\"flex flex-1 flex-col items-center justify-center gap-4 text-center\" data-slot=\"chat-empty\">\n              {empty}\n              {suggestions && suggestions.length > 0 && (\n                <Suggestions className=\"justify-center\">\n                  {suggestions.map((s) => (\n                    <Suggestion key={s} onSelect={ask} value={s}>\n                      {s}\n                    </Suggestion>\n                  ))}\n                </Suggestions>\n              )}\n            </div>\n          ) : (\n            <MessageList>\n              {chat.messages.map((m) => (\n                <Message key={m.id} role={m.role}>\n                  <MessageContent>\n                    {m.parts.map((part, i) => {\n                      const key = `${m.id}-${i}`;\n                      const streaming = busy && m === last;\n                      if (part.type === \"text\") {\n                        return m.role === \"user\" ? (\n                          <p className=\"whitespace-pre-wrap break-words\" key={key}>\n                            {part.text}\n                          </p>\n                        ) : (\n                          <MessageMarkdown key={key} streaming={streaming && part.state === \"streaming\"}>\n                            {part.text}\n                          </MessageMarkdown>\n                        );\n                      }\n                      if (part.type === \"reasoning\") return <Reasoning key={key} part={part} />;\n                      if (isToolUIPart(part)) {\n                        const draw = tools[getToolName(part)];\n                        return (\n                          <Tool key={key} part={part}>\n                            <ToolHeader />\n                            <ToolContent>\n                              <ToolInput />\n                              {draw && part.state === \"output-available\" ? draw(part) : <ToolOutput />}\n                            </ToolContent>\n                          </Tool>\n                        );\n                      }\n                      return null;\n                    })}\n                  </MessageContent>\n                </Message>\n              ))}\n            </MessageList>\n          )}\n          {chat.error && (\n            <p className=\"text-destructive-foreground text-sm\" data-slot=\"chat-error\" role=\"alert\">\n              <span className=\"sr-only\">{t.failed} </span>\n              {chat.error.message}\n            </p>\n          )}\n        </ConversationContent>\n        <ConversationScrollButton />\n      </Conversation>\n      <PromptInput\n        onSubmit={(event) => {\n          event.preventDefault();\n          if (busy) void chat.stop();\n          else if (chat.status === \"error\" && !draft.trim()) void chat.regenerate();\n          else ask(draft);\n        }}\n      >\n        <PromptInputTextarea\n          onChange={(event) => setDraft(event.target.value)}\n          placeholder={t.placeholder}\n          value={draft}\n        />\n        <PromptInputToolbar>\n          <PromptInputSubmit status={chat.status} />\n        </PromptInputToolbar>\n      </PromptInput>\n    </div>\n  );\n}\n"],"names":[],"mappings":";;;;;;;;;;;AA0BA;AAAkC;AACnB;AAEf;AAmCO;AACL;AAOE;AAEW;AAGb;AAEI;AACE;AACG;AAEI;AAAA;AAQC;AASM;AAEA;AACE;AAUF;AACA;AACE;AACA;AAEI;AAAY;AAEV;AAAW;AAC2D;AACxE;AACF;AAGJ;AAAO;AAKjB;AAIE;AAA2B;AAAE;AAAO;AAAC;AACzB;AACd;AAEJ;AAC0B;AAC5B;AACA;AAAC;AAAA;AAEG;AAGc;AAChB;AAEA;AAAA;AAAC;AAAA;AACiD;AACjC;AACR;AAAA;AAAA;AAIT;AAAA;AAAA;AAAA;AAIR;;;;"}

package/dist/engine.d.ts

@@ -0,0 +1,101 @@
+/** A value the model offers a field. LSP 3.18's `InlineCompletionItem`, as a field needs it. */
+export interface Proposal {
+    text: string;
+    /**
+     * What taking it replaces, as `[from, to)` in the field's value: an empty range at the caret is a
+     * continuation, the whole value is a replacement. Absent for a new item in a list field (tags),
+     * where taking it adds rather than edits.
+     */
+    range?: [from: number, to: number];
+    /** Why the model offered it. Shown as the candidate's tooltip. */
+    rationale?: string;
+}
+/**
+ * What happened to a proposal, for a host that learns from it (HAX G13). The lifecycle VS Code's
+ * inline completions report, in one callback: it was **shown**, taken whole (**accepted**) or a word
+ * at a time (**partial**), turned down by the reader (**rejected**: Esc, or a candidate's ✕), or
+ * left to die because they typed something else (**ignored**).
+ */
+export interface AssistEvent {
+    kind: "shown" | "accepted" | "partial" | "rejected" | "ignored";
+    proposal: Proposal;
+    /** The field's accessible name — which field it was. */
+    field: string;
+}
+/** Where a request has got to. Internal: no surface exposes it, they draw from it. */
+export type Status = "idle" | "loading" | "ready" | "error";
+/**
+ * Open a source and pull it to the end, handing each value to `each`; `false` from `each` stops it.
+ * A new run supersedes the one in flight, and resolves to what happened to **this** run, so a loop
+ * that outlives its render never reads a stale status.
+ */
+export declare function useStream<T>(errorText: string): {
+    run: (src: (signal: AbortSignal) => AsyncIterable<T>, each: (value: T) => boolean | void) => Promise<Status>;
+    cancel: () => void;
+    reset: () => void;
+    status: Status;
+    error: string | null;
+};
+/**
+ * The continuation is appended verbatim, with one safety net: a model that restated the value
+ * before continuing gets that prefix dropped, and an echo still arriving renders as nothing until it
+ * diverges — painting the value twice is worse than a few frames of nothing.
+ */
+export declare function cleanGhost(base: string, cont: string): string;
+/** Below this there is not enough text to continue, so nothing is asked. */
+export declare const MIN_CONTINUE_LENGTH = 4;
+export type Trigger = "invoked" | "automatic";
+export interface ContinuationRequest {
+    value: string;
+    position: number;
+    trigger: Trigger;
+    /** Continuations already offered at this point; an alternative must differ from them. */
+    avoid: string[];
+    signal: AbortSignal;
+}
+/**
+ * Ghost text that does not own the value: the field owns it and performs the insertion.
+ *
+ * **The offer survives typing that agrees with it.** An offer made at `from` stays on the table
+ * while what was typed since is a prefix of it, and the ghost is what is left — no request at all.
+ * That is LSP's `filterText` rule and the only way to Smart Compose's 60 ms budget: not asking.
+ *
+ * **Alternatives** are LSP's `Invoked` case: asking again at the same point appends a different
+ * offer rather than replacing the one on the table, and `cycle` moves between them (Alt+] / Alt+[).
+ */
+export declare function useContinuation(options: {
+    source: (request: ContinuationRequest) => AsyncIterable<string>;
+    onEvent: (kind: AssistEvent["kind"], proposal: Proposal) => void;
+    debounceMs?: number;
+}): {
+    ghost: string;
+    status: Status;
+    error: string | null;
+    setValue: (value: string, position?: number) => void;
+    ask: (value: string, position?: number) => void;
+    cycle: (step: 1 | -1) => void;
+    settle: (kind: "accepted" | "partial", text: string) => void;
+    dismiss: (why?: "rejected" | "ignored") => void;
+};
+/**
+ * A streamed list of whole values, deduped against what the field already holds. A budget rather
+ * than a window: nothing refills when one is taken or dismissed.
+ */
+export declare function useCandidates(options: {
+    source: (request: {
+        existing: string[];
+        signal: AbortSignal;
+    }) => AsyncIterable<Proposal>;
+    existing: string[];
+    onEvent: (kind: AssistEvent["kind"], proposal: Proposal) => void;
+    limit?: number;
+}): {
+    items: Proposal[];
+    status: Status;
+    error: string | null;
+    press: () => void;
+    take: (t: string) => void;
+    dismiss: (t: string) => void;
+    cancel: () => void;
+};
+//# sourceMappingURL=engine.d.ts.map

package/dist/engine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"engine.d.ts","sourceRoot":"","sources":["../src/engine.ts"],"names":[],"mappings":"AAQA,gGAAgG;AAChG,MAAM,WAAW,QAAQ;IACvB,IAAI,EAAE,MAAM,CAAC;IACb;;;;OAIG;IACH,KAAK,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,CAAC,CAAC;IACnC,kEAAkE;IAClE,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED;;;;;GAKG;AACH,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,OAAO,GAAG,UAAU,GAAG,SAAS,GAAG,UAAU,GAAG,SAAS,CAAC;IAChE,QAAQ,EAAE,QAAQ,CAAC;IACnB,wDAAwD;IACxD,KAAK,EAAE,MAAM,CAAC;CACf;AAED,sFAAsF;AACtF,MAAM,MAAM,MAAM,GAAG,MAAM,GAAG,SAAS,GAAG,OAAO,GAAG,OAAO,CAAC;AAO5D;;;;GAIG;AACH,wBAAgB,SAAS,CAAC,CAAC,EAAE,SAAS,EAAE,MAAM;eAepC,CAAC,MAAM,EAAE,WAAW,KAAK,aAAa,CAAC,CAAC,CAAC,QAAQ,CAAC,KAAK,EAAE,CAAC,KAAK,OAAO,GAAG,IAAI;;;;;EAqCtF;AA+BD;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAO7D;AAID,4EAA4E;AAC5E,eAAO,MAAM,mBAAmB,IAAI,CAAC;AAErC,MAAM,MAAM,OAAO,GAAG,SAAS,GAAG,WAAW,CAAC;AAE9C,MAAM,WAAW,mBAAmB;IAClC,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,OAAO,CAAC;IACjB,yFAAyF;IACzF,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,MAAM,EAAE,WAAW,CAAC;CACrB;AAQD;;;;;;;;;GASG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE;IACvC,MAAM,EAAE,CAAC,OAAO,EAAE,mBAAmB,KAAK,aAAa,CAAC,MAAM,CAAC,CAAC;IAChE,OAAO,EAAE,CAAC,IAAI,EAAE,WAAW,CAAC,MAAM,CAAC,EAAE,QAAQ,EAAE,QAAQ,KAAK,IAAI,CAAC;IACjE,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;;;;sBA4FW,MAAM;iBAkBN,MAAM;kBAaP,CAAC,GAAG,CAAC,CAAC;mBAgBN,UAAU,GAAG,SAAS,QAAQ,MAAM;oBA3FpC,UAAU,GAAG,SAAS;EAoHhC;AAMD;;;GAGG;AACH,wBAAgB,aAAa,CAAC,OAAO,EAAE;IACrC,MAAM,EAAE,CAAC,OAAO,EAAE;QAAE,QAAQ,EAAE,MAAM,EAAE,CAAC;QAAC,MAAM,EAAE,WAAW,CAAA;KAAE,KAAK,aAAa,CAAC,QAAQ,CAAC,CAAC;IAC1F,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,OAAO,EAAE,CAAC,IAAI,EAAE,WAAW,CAAC,MAAM,CAAC,EAAE,QAAQ,EAAE,QAAQ,KAAK,IAAI,CAAC;IACjE,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;;;;;cAuDiD,MAAM;iBAAyC,MAAM;;EACtG"}

package/dist/engine.js

@@ -0,0 +1,197 @@
+"use client";
+import { useState as I, useRef as y, useCallback as f, useEffect as F, useMemo as H } from "react";
+const U = (c, r) => c instanceof Error && c.message ? c.message : r;
+function O(c) {
+  const [r, u] = I("idle"), [g, k] = I(null), W = y("idle"), m = y(void 0), a = f((s, w = null) => {
+    W.current = s, u(s), k(w);
+  }, []);
+  F(() => () => {
+    var s;
+    return (s = m.current) == null ? void 0 : s.abort();
+  }, []);
+  const h = f(
+    (s, w) => {
+      var T;
+      (T = m.current) == null || T.abort();
+      const l = new AbortController();
+      return m.current = l, a("loading"), (async () => {
+        try {
+          for await (const i of s(l.signal)) {
+            if (l.signal.aborted) return "idle";
+            if (w(i) === !1) {
+              l.abort();
+              break;
+            }
+          }
+        } catch (i) {
+          return l.signal.aborted ? "idle" : (a("error", U(i, c)), "error");
+        }
+        return m.current === l && a("ready"), "ready";
+      })();
+    },
+    [c, a]
+  ), b = f(() => {
+    var s;
+    (s = m.current) == null || s.abort(), a("idle");
+  }, [a]), n = f(() => {
+    W.current !== "loading" && a("idle");
+  }, [a]);
+  return H(() => ({ run: h, cancel: b, reset: n, status: r, error: g }), [b, g, n, h, r]);
+}
+function V(c) {
+  let r, u = !1;
+  const g = () => {
+    u = !0, r === void 0 && (r = requestAnimationFrame(() => {
+      r = void 0, u = !1, c();
+    }));
+  }, k = () => {
+    r !== void 0 && cancelAnimationFrame(r), r = void 0, u = !1;
+  };
+  return Object.assign(g, { flush: () => {
+    const m = u;
+    k(), m && c();
+  }, cancel: k });
+}
+function z(c, r) {
+  const u = c.trimEnd();
+  if (!u || !r) return r;
+  const g = { base: u.toLowerCase(), cont: r.toLowerCase() };
+  return g.cont.startsWith(g.base) ? r.slice(u.length) : g.base.startsWith(g.cont) ? "" : r;
+}
+const D = 4;
+function K(c) {
+  const { run: r, cancel: u, status: g, error: k } = O("Couldn’t complete"), [W, m] = I(""), a = y(c);
+  a.current = c;
+  const h = y([]), b = y(0), n = y({ value: "", position: 0 }), s = y(void 0), w = y(null), l = () => h.current[b.current] ?? null, T = f(() => {
+    const t = l();
+    if (!t) return "";
+    const { value: e, position: d } = n.current;
+    if (d < t.from) return "";
+    const x = e.slice(t.from, d);
+    return t.text.startsWith(x) ? t.text.slice(x.length) : "";
+  }, []), i = f(() => {
+    const t = l();
+    if (!t) return !1;
+    const { value: e, position: d } = n.current;
+    if (d < t.from) return !1;
+    const x = e.slice(t.from, d);
+    return t.text.startsWith(x) || !t.done && x.startsWith(t.text);
+  }, []), N = (t) => ({ text: t.text, range: [t.from, t.from] }), o = y(void 0);
+  o.current ?? (o.current = V(() => {
+    const t = T();
+    m(t);
+    const e = l();
+    t && e && w.current !== e && (w.current = e, a.current.onEvent("shown", N(e)));
+  }));
+  const E = f(
+    (t) => {
+      var d;
+      clearTimeout(s.current), (d = o.current) == null || d.cancel();
+      const e = l();
+      t && e && w.current === e && a.current.onEvent(t, N(e)), h.current = [], b.current = 0, w.current = null, u(), m("");
+    },
+    [u]
+  ), p = f(
+    (t, e, d) => {
+      const x = h.current.filter((C) => C.from === e).map((C) => C.text), L = { from: e, text: "", done: !1 };
+      h.current = [...h.current.filter((C) => C.from === e), L], b.current = h.current.length - 1;
+      const B = t.slice(0, e);
+      let j = "";
+      r(
+        (C) => a.current.source({ value: t, position: e, trigger: d, avoid: x, signal: C }),
+        (C) => {
+          var A;
+          if (l() !== L) return !1;
+          j += C, L.text = z(B, j), (A = o.current) == null || A.call(o);
+        }
+      ).then((C) => {
+        var A, q;
+        L.done = !0, l() === L && (C === "ready" ? (A = o.current) == null || A.flush() : (q = o.current) == null || q.cancel());
+      });
+    },
+    [r]
+  ), v = (t) => t.trim().length < D, S = f(
+    (t, e = t.length) => {
+      if (n.current = { value: t, position: e }, i()) {
+        m(T());
+        return;
+      }
+      E("ignored"), !v(t) && (s.current = setTimeout(
+        () => p(t, e, "automatic"),
+        a.current.debounceMs ?? 350
+      ));
+    },
+    [i, E, T, p]
+  ), M = f(
+    (t, e = t.length) => {
+      const d = n.current.value === t && n.current.position === e;
+      n.current = { value: t, position: e }, d || E("ignored"), clearTimeout(s.current), !v(t) && p(t, e, "invoked");
+    },
+    [E, p]
+  ), R = f(
+    (t) => {
+      var d;
+      const e = b.current + t;
+      if (!(e < 0)) {
+        if (e >= h.current.length) {
+          const { value: x, position: L } = n.current;
+          M(x, L);
+          return;
+        }
+        b.current = e, m(T()), (d = o.current) == null || d.call(o);
+      }
+    },
+    [M, T]
+  ), _ = f(
+    (t, e) => {
+      var x;
+      l() && a.current.onEvent(t, { text: e, range: [n.current.position, n.current.position] }), t === "accepted" && (h.current = [], b.current = 0, w.current = null, clearTimeout(s.current), (x = o.current) == null || x.cancel(), u(), m(""));
+    },
+    [u]
+  );
+  return F(
+    () => () => {
+      var t;
+      clearTimeout(s.current), (t = o.current) == null || t.cancel();
+    },
+    []
+  ), { ghost: W, status: g, error: k, setValue: S, ask: M, cycle: R, settle: _, dismiss: E };
+}
+const G = (c) => c.trim().toLowerCase();
+function P(c) {
+  const { run: r, cancel: u, reset: g, status: k, error: W } = O("Couldn’t load suggestions"), [m, a] = I([]), h = y([]), b = y(c);
+  b.current = c;
+  const n = f((i) => {
+    h.current = i, a(i);
+  }, []), s = f(() => {
+    const { existing: i, limit: N = 6, source: o } = b.current, E = new Set(i.map(G).filter(Boolean)), p = [];
+    n([]), r(
+      (v) => o({ existing: i, signal: v }),
+      (v) => {
+        const S = G(v.text);
+        return !S || E.has(S) ? !0 : (E.add(S), p.push(v), n([...p]), b.current.onEvent("shown", v), p.length < N);
+      }
+    );
+  }, [n, r]), w = f(() => {
+    k !== "loading" && s();
+  }, [s, k]), l = f(
+    (i, N) => {
+      const o = G(i), E = h.current.find((v) => G(v.text) === o);
+      E && b.current.onEvent(N, E);
+      const p = h.current.filter((v) => G(v.text) !== o);
+      n(p), p.length === 0 && g();
+    },
+    [n, g]
+  ), T = f(() => {
+    u(), n([]);
+  }, [u, n]);
+  return { items: m, status: k, error: W, press: w, take: (i) => l(i, "accepted"), dismiss: (i) => l(i, "rejected"), cancel: T };
+}
+export {
+  D as MIN_CONTINUE_LENGTH,
+  z as cleanGhost,
+  P as useCandidates,
+  K as useContinuation,
+  O as useStream
+};
+//# sourceMappingURL=engine.js.map

package/dist/engine.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"engine.js","sources":["../src/engine.ts"],"sourcesContent":["\"use client\";\n\n// The machinery behind `Assist`, and none of it is public. A field offers a **proposal** — text the\n// reader may take — and this file is everything about getting proposals out of a stream and keeping\n// them honest while the reader types: one engine, the inline continuation, and the candidate list.\n\nimport { useCallback, useEffect, useMemo, useRef, useState } from \"react\";\n\n/** A value the model offers a field. LSP 3.18's `InlineCompletionItem`, as a field needs it. */\nexport interface Proposal {\n  text: string;\n  /**\n   * What taking it replaces, as `[from, to)` in the field's value: an empty range at the caret is a\n   * continuation, the whole value is a replacement. Absent for a new item in a list field (tags),\n   * where taking it adds rather than edits.\n   */\n  range?: [from: number, to: number];\n  /** Why the model offered it. Shown as the candidate's tooltip. */\n  rationale?: string;\n}\n\n/**\n * What happened to a proposal, for a host that learns from it (HAX G13). The lifecycle VS Code's\n * inline completions report, in one callback: it was **shown**, taken whole (**accepted**) or a word\n * at a time (**partial**), turned down by the reader (**rejected**: Esc, or a candidate's ✕), or\n * left to die because they typed something else (**ignored**).\n */\nexport interface AssistEvent {\n  kind: \"shown\" | \"accepted\" | \"partial\" | \"rejected\" | \"ignored\";\n  proposal: Proposal;\n  /** The field's accessible name — which field it was. */\n  field: string;\n}\n\n/** Where a request has got to. Internal: no surface exposes it, they draw from it. */\nexport type Status = \"idle\" | \"loading\" | \"ready\" | \"error\";\n\nconst message = (e: unknown, fallback: string) =>\n  e instanceof Error && e.message ? e.message : fallback;\n\n// ── The engine ───────────────────────────────────────────────────────────────\n\n/**\n * Open a source and pull it to the end, handing each value to `each`; `false` from `each` stops it.\n * A new run supersedes the one in flight, and resolves to what happened to **this** run, so a loop\n * that outlives its render never reads a stale status.\n */\nexport function useStream<T>(errorText: string) {\n  const [status, setStatus] = useState<Status>(\"idle\");\n  const [error, setError] = useState<string | null>(null);\n  const statusRef = useRef<Status>(\"idle\");\n  const ctrl = useRef<AbortController>(undefined);\n\n  const set = useCallback((s: Status, e: string | null = null) => {\n    statusRef.current = s;\n    setStatus(s);\n    setError(e);\n  }, []);\n\n  useEffect(() => () => ctrl.current?.abort(), []);\n\n  const run = useCallback(\n    (src: (signal: AbortSignal) => AsyncIterable<T>, each: (value: T) => boolean | void) => {\n      ctrl.current?.abort();\n      const c = new AbortController();\n      ctrl.current = c;\n      set(\"loading\");\n\n      return (async (): Promise<Status> => {\n        try {\n          for await (const value of src(c.signal)) {\n            if (c.signal.aborted) return \"idle\";\n            if (each(value) === false) {\n              c.abort();\n              break;\n            }\n          }\n        } catch (e) {\n          if (c.signal.aborted) return \"idle\";\n          set(\"error\", message(e, errorText));\n          return \"error\";\n        }\n        if (ctrl.current === c) set(\"ready\");\n        return \"ready\";\n      })();\n    },\n    [errorText, set],\n  );\n\n  const cancel = useCallback(() => {\n    ctrl.current?.abort();\n    set(\"idle\");\n  }, [set]);\n\n  const reset = useCallback(() => {\n    if (statusRef.current !== \"loading\") set(\"idle\");\n  }, [set]);\n\n  return useMemo(() => ({ run, cancel, reset, status, error }), [cancel, error, reset, run, status]);\n}\n\n/**\n * Run `paint` at most once a frame, and once more on `flush()`. A token stream arrives faster than\n * the display refreshes, so a `setState` per chunk renders work nobody sees.\n */\nfunction coalesce(paint: () => void) {\n  let frame: number | undefined;\n  let queued = false;\n  const run = () => {\n    queued = true;\n    if (frame !== undefined) return;\n    frame = requestAnimationFrame(() => {\n      frame = undefined;\n      queued = false;\n      paint();\n    });\n  };\n  const cancel = () => {\n    if (frame !== undefined) cancelAnimationFrame(frame);\n    frame = undefined;\n    queued = false;\n  };\n  const flush = () => {\n    const pending = queued;\n    cancel();\n    if (pending) paint();\n  };\n  return Object.assign(run, { flush, cancel });\n}\n\n/**\n * The continuation is appended verbatim, with one safety net: a model that restated the value\n * before continuing gets that prefix dropped, and an echo still arriving renders as nothing until it\n * diverges — painting the value twice is worse than a few frames of nothing.\n */\nexport function cleanGhost(base: string, cont: string): string {\n  const b = base.trimEnd();\n  if (!b || !cont) return cont;\n  const lower = { base: b.toLowerCase(), cont: cont.toLowerCase() };\n  if (lower.cont.startsWith(lower.base)) return cont.slice(b.length);\n  if (lower.base.startsWith(lower.cont)) return \"\";\n  return cont;\n}\n\n// ── The continuation: one offer at the caret, with alternatives ──────────────\n\n/** Below this there is not enough text to continue, so nothing is asked. */\nexport const MIN_CONTINUE_LENGTH = 4;\n\nexport type Trigger = \"invoked\" | \"automatic\";\n\nexport interface ContinuationRequest {\n  value: string;\n  position: number;\n  trigger: Trigger;\n  /** Continuations already offered at this point; an alternative must differ from them. */\n  avoid: string[];\n  signal: AbortSignal;\n}\n\ninterface Offer {\n  from: number;\n  text: string;\n  done: boolean;\n}\n\n/**\n * Ghost text that does not own the value: the field owns it and performs the insertion.\n *\n * **The offer survives typing that agrees with it.** An offer made at `from` stays on the table\n * while what was typed since is a prefix of it, and the ghost is what is left — no request at all.\n * That is LSP's `filterText` rule and the only way to Smart Compose's 60 ms budget: not asking.\n *\n * **Alternatives** are LSP's `Invoked` case: asking again at the same point appends a different\n * offer rather than replacing the one on the table, and `cycle` moves between them (Alt+] / Alt+[).\n */\nexport function useContinuation(options: {\n  source: (request: ContinuationRequest) => AsyncIterable<string>;\n  onEvent: (kind: AssistEvent[\"kind\"], proposal: Proposal) => void;\n  debounceMs?: number;\n}) {\n  const { run, cancel, status, error } = useStream<string>(\"Couldn’t complete\");\n  const [ghost, setGhost] = useState(\"\");\n  const opts = useRef(options);\n  opts.current = options;\n\n  const offers = useRef<Offer[]>([]);\n  const index = useRef(0);\n  const field = useRef({ value: \"\", position: 0 });\n  const timer = useRef<ReturnType<typeof setTimeout>>(undefined);\n  const shown = useRef<Offer | null>(null);\n\n  const current = () => offers.current[index.current] ?? null;\n\n  const rendered = useCallback((): string => {\n    const o = current();\n    if (!o) return \"\";\n    const { value, position } = field.current;\n    if (position < o.from) return \"\";\n    const typed = value.slice(o.from, position);\n    return o.text.startsWith(typed) ? o.text.slice(typed.length) : \"\";\n  }, []);\n\n  const alive = useCallback((): boolean => {\n    const o = current();\n    if (!o) return false;\n    const { value, position } = field.current;\n    if (position < o.from) return false;\n    const typed = value.slice(o.from, position);\n    // Typing ahead of a stream still arriving is not a mismatch yet: the next chunk may agree.\n    return o.text.startsWith(typed) || (!o.done && typed.startsWith(o.text));\n  }, []);\n\n  const proposal = (o: Offer): Proposal => ({ text: o.text, range: [o.from, o.from] });\n\n  const painter = useRef<ReturnType<typeof coalesce>>(undefined);\n  painter.current ??= coalesce(() => {\n    const next = rendered();\n    setGhost(next);\n    const o = current();\n    if (next && o && shown.current !== o) {\n      shown.current = o;\n      opts.current.onEvent(\"shown\", proposal(o));\n    }\n  });\n\n  /** Forget every offer. `why` is reported once, for the offer on screen. */\n  const drop = useCallback(\n    (why?: \"rejected\" | \"ignored\") => {\n      clearTimeout(timer.current);\n      painter.current?.cancel();\n      const o = current();\n      if (why && o && shown.current === o) opts.current.onEvent(why, proposal(o));\n      offers.current = [];\n      index.current = 0;\n      shown.current = null;\n      cancel();\n      setGhost(\"\");\n    },\n    [cancel],\n  );\n\n  const start = useCallback(\n    (value: string, position: number, trigger: Trigger) => {\n      const avoid = offers.current.filter((o) => o.from === position).map((o) => o.text);\n      const mine: Offer = { from: position, text: \"\", done: false };\n      offers.current = [...offers.current.filter((o) => o.from === position), mine];\n      index.current = offers.current.length - 1;\n      const base = value.slice(0, position);\n      let raw = \"\";\n      void run(\n        (signal) => opts.current.source({ value, position, trigger, avoid, signal }),\n        (chunk) => {\n          if (current() !== mine) return false;\n          raw += chunk;\n          mine.text = cleanGhost(base, raw);\n          painter.current?.();\n        },\n      ).then((outcome) => {\n        mine.done = true;\n        if (current() !== mine) return;\n        if (outcome === \"ready\") painter.current?.flush();\n        else painter.current?.cancel();\n      });\n    },\n    [run],\n  );\n\n  const short = (value: string) => value.trim().length < MIN_CONTINUE_LENGTH;\n\n  /** The field changed. Ask after a debounce — unless the offer on the table survives it. */\n  const setValue = useCallback(\n    (value: string, position = value.length) => {\n      field.current = { value, position };\n      if (alive()) {\n        setGhost(rendered());\n        return;\n      }\n      drop(\"ignored\");\n      if (short(value)) return;\n      timer.current = setTimeout(\n        () => start(value, position, \"automatic\"),\n        opts.current.debounceMs ?? 350,\n      );\n    },\n    [alive, drop, rendered, start],\n  );\n\n  /** Ask now — the ✨, and Alt+] past the last alternative. */\n  const ask = useCallback(\n    (value: string, position = value.length) => {\n      const same = field.current.value === value && field.current.position === position;\n      field.current = { value, position };\n      if (!same) drop(\"ignored\");\n      clearTimeout(timer.current);\n      if (short(value)) return;\n      start(value, position, \"invoked\");\n    },\n    [drop, start],\n  );\n\n  /** Move between alternatives; past the last one, ask for another. */\n  const cycle = useCallback(\n    (step: 1 | -1) => {\n      const next = index.current + step;\n      if (next < 0) return;\n      if (next >= offers.current.length) {\n        const { value, position } = field.current;\n        ask(value, position);\n        return;\n      }\n      index.current = next;\n      setGhost(rendered());\n      painter.current?.();\n    },\n    [ask, rendered],\n  );\n\n  const settle = useCallback(\n    (kind: \"accepted\" | \"partial\", text: string) => {\n      const o = current();\n      if (o) opts.current.onEvent(kind, { text, range: [field.current.position, field.current.position] });\n      if (kind === \"accepted\") {\n        offers.current = [];\n        index.current = 0;\n        shown.current = null;\n        clearTimeout(timer.current);\n        painter.current?.cancel();\n        cancel();\n        setGhost(\"\");\n      }\n    },\n    [cancel],\n  );\n\n  useEffect(\n    () => () => {\n      clearTimeout(timer.current);\n      painter.current?.cancel();\n    },\n    [],\n  );\n\n  return { ghost, status, error, setValue, ask, cycle, settle, dismiss: drop };\n}\n\n// ── The candidates: N whole values, deduped ──────────────────────────────────\n\nconst norm = (v: string) => v.trim().toLowerCase();\n\n/**\n * A streamed list of whole values, deduped against what the field already holds. A budget rather\n * than a window: nothing refills when one is taken or dismissed.\n */\nexport function useCandidates(options: {\n  source: (request: { existing: string[]; signal: AbortSignal }) => AsyncIterable<Proposal>;\n  existing: string[];\n  onEvent: (kind: AssistEvent[\"kind\"], proposal: Proposal) => void;\n  limit?: number;\n}) {\n  const { run, cancel: abort, reset, status, error } = useStream<Proposal>(\"Couldn’t load suggestions\");\n  const [items, setItems] = useState<Proposal[]>([]);\n  const shown = useRef<Proposal[]>([]);\n  const opts = useRef(options);\n  opts.current = options;\n\n  const put = useCallback((next: Proposal[]) => {\n    shown.current = next;\n    setItems(next);\n  }, []);\n\n  const refresh = useCallback(() => {\n    const { existing, limit = 6, source } = opts.current;\n    const seen = new Set(existing.map(norm).filter(Boolean));\n    const taken: Proposal[] = [];\n    put([]);\n    void run(\n      (signal) => source({ existing, signal }),\n      (item) => {\n        const key = norm(item.text);\n        if (!key || seen.has(key)) return true;\n        seen.add(key);\n        taken.push(item);\n        put([...taken]);\n        opts.current.onEvent(\"shown\", item);\n        return taken.length < limit;\n      },\n    );\n  }, [put, run]);\n\n  /** The ✨: a first set, a different set, or a retry — never inert, except while loading. */\n  const press = useCallback(() => {\n    if (status === \"loading\") return;\n    refresh();\n  }, [refresh, status]);\n\n  const remove = useCallback(\n    (text: string, kind: \"accepted\" | \"rejected\") => {\n      const key = norm(text);\n      const item = shown.current.find((p) => norm(p.text) === key);\n      if (item) opts.current.onEvent(kind, item);\n      const next = shown.current.filter((p) => norm(p.text) !== key);\n      put(next);\n      // Nothing left of an answer is not an answer with nothing in it.\n      if (next.length === 0) reset();\n    },\n    [put, reset],\n  );\n\n  const cancel = useCallback(() => {\n    abort();\n    put([]);\n  }, [abort, put]);\n\n  return { items, status, error, press, take: (t: string) => remove(t, \"accepted\"), dismiss: (t: string) => remove(t, \"rejected\"), cancel };\n}\n"],"names":[],"mappings":";;AAqCA;AAUO;AACL;AAME;AAEU;AAGZ;;AAAsB;AAAc;AAEpC;AAAY;;AAER;AACA;AACA;AAIE;AACE;AACE;AACA;AACE;AACA;AAAA;AACF;AACF;AAEA;AAEO;AAET;AACO;AACT;AACF;AACe;;AAIf;AACU;AAIV;AAA+C;AAGjD;AACF;AAMA;AACE;AAEA;AAEE;AAEE;AAEA;AACD;AAGD;AAES;AAOX;AAJE;AACA;AACa;AAGjB;AAOO;AACL;AACA;AACA;AACA;AAGF;AAKO;AA6BA;AAKL;AAGA;AAEA;AASE;AACA;AACA;AACA;AACA;AACA;AAA+D;AAI/D;AACA;AACA;AACA;AACA;AAEA;AAAsE;AAMxE;AACE;AACA;AACA;AACA;AAE2C;AAK7C;AAAa;;AAET;AAEA;AACA;AAKW;AACb;AACO;AAGK;AAEV;AAEA;AAEA;AACA;AACA;AAAK;AACwE;;AAEzE;AACA;AAEA;AACF;;AAGA;AAEsB;AACvB;AACH;AACI;AAMW;AAGb;AACE;AACA;AAAA;AAGF;AACgB;AAC0B;AACb;AAAA;AAE/B;AAC6B;AAInB;AAER;AAIA;AACgC;AAClC;AACY;AAIA;;AAEV;AACA;AACA;AACE;AACA;AACA;AAAA;AAEF;AAEA;AAAA;AACF;AACc;AAGD;;AAGX;AAQa;AAEf;AACO;AAGT;AAAA;;AAEI;AACiB;AACnB;AACA;AAIJ;AAIA;AAMO;AAML;AAIA;AAEA;AACE;AACa;AAIb;AAGA;AACK;AACoC;AAErC;AACA;AAKsB;AACxB;AAAA;AAMF;AACA;AAGa;AAEX;AAEA;AACA;AACA;AAEuB;AACzB;AACW;AAIX;AACM;AAGR;AACF;;;;;;;;"}

package/dist/index.d.ts

@@ -1,25 +1,8 @@
-export { Conversation, ConversationContent, ConversationScrollButton, } from './conversation.js';
-export { Message, MessageActions, MessageAvatar, MessageContent, MessageList, } from './message.js';
-export { MessageText } from './message-text.js';
-export type { MessageProps, MessageAvatarProps, MessageRole } from './message.js';
-export type { MessageTextProps } from './message-text.js';
-export { PromptInput, PromptInputSubmit, PromptInputTextarea, PromptInputToolbar, } from './prompt-input.js';
-export type { PromptInputSubmitProps } from './prompt-input.js';
-export { Reasoning, ReasoningContent, ReasoningTrigger } from './reasoning.js';
-export type { ReasoningProps } from './reasoning.js';
-export { Tool, ToolContent, ToolHeader, ToolInput, ToolOutput } from './tool.js';
-export type { ToolProps, ToolIoProps } from './tool.js';
-export { Task, TaskList, TaskStatus, TaskTitle } from './task.js';
-export type { TaskProps, RunState } from './task.js';
-export { CompleteRoot, CompleteTextarea, CompleteGhost, CompleteHint, CompleteKeys, CompleteError, CompleteMark, } from './complete.js';
-export { AiMark } from './ai-mark.js';
-export type { AiMarkProps } from './ai-mark.js';
-export { SuggestRoot, SuggestMark, SuggestList } from './suggest.js';
-export type { SuggestRootProps, SuggestListProps, SuggestTrigger } from './suggest.js';
-export type { CompleteRootProps } from './complete.js';
-export { useAiStream, useInlineCompletion, useSuggestions, cleanGhost } from './use-ai.js';
-export type { AiStatus, AiStream, InlineCompletion, InlineCompletionRequest, InlineCompletionTrigger, SuggestionsController, UseInlineCompletionOptions, UseSuggestionsOptions, } from './use-ai.js';
-export type { Candidate } from './types.js';
-export { isTextPart, isReasoningPart, isToolPart, isTaskPart } from './message-part.js';
-export type { AiMessage, AiMessagePart, AiReasoningPart, AiTaskPart, AiTextPart, AiToolPart, StreamState, } from './message-part.js';
+export { AssistProvider, Assist } from './assist.js';
+export type { AssistProviderProps, AssistProps, AssistTranslations } from './assist.js';
+export type { AssistEvent, Proposal } from './engine.js';
+export { Chat } from './chat.js';
+export type { ChatProps, ChatToolRenderers, ChatTranslations } from './chat.js';
+export type { ToolPart } from './tool.js';
+export { useChat } from '@ai-sdk/react';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAYA,OAAO,EACL,YAAY,EACZ,mBAAmB,EACnB,wBAAwB,GACzB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EACL,OAAO,EACP,cAAc,EACd,aAAa,EACb,cAAc,EACd,WAAW,GACZ,MAAM,cAAc,CAAC;AACtB,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAChD,YAAY,EAAE,YAAY,EAAE,kBAAkB,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAClF,YAAY,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAG1D,OAAO,EACL,WAAW,EACX,iBAAiB,EACjB,mBAAmB,EACnB,kBAAkB,GACnB,MAAM,mBAAmB,CAAC;AAC3B,YAAY,EAAE,sBAAsB,EAAE,MAAM,mBAAmB,CAAC;AAGhE,OAAO,EAAE,SAAS,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAC/E,YAAY,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AACrD,OAAO,EAAE,IAAI,EAAE,WAAW,EAAE,UAAU,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AACjF,YAAY,EAAE,SAAS,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AACxD,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC;AAClE,YAAY,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,WAAW,CAAC;AAGrD,OAAO,EACL,YAAY,EACZ,gBAAgB,EAChB,aAAa,EACb,YAAY,EACZ,YAAY,EACZ,aAAa,EACb,YAAY,GACb,MAAM,eAAe,CAAC;AAIvB,OAAO,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AACtC,YAAY,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAChD,OAAO,EAAE,WAAW,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AACrE,YAAY,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AACvF,YAAY,EAAE,iBAAiB,EAAE,MAAM,eAAe,CAAC;AAEvD,OAAO,EAAE,WAAW,EAAE,mBAAmB,EAAE,cAAc,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAC3F,YAAY,EACV,QAAQ,EACR,QAAQ,EACR,gBAAgB,EAChB,uBAAuB,EACvB,uBAAuB,EACvB,qBAAqB,EACrB,0BAA0B,EAC1B,qBAAqB,GACtB,MAAM,aAAa,CAAC;AAErB,YAAY,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAI5C,OAAO,EAAE,UAAU,EAAE,eAAe,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AACxF,YAAY,EACV,SAAS,EACT,aAAa,EACb,eAAe,EACf,UAAU,EACV,UAAU,EACV,UAAU,EACV,WAAW,GACZ,MAAM,mBAAmB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAQA,OAAO,EAAE,cAAc,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AACrD,YAAY,EAAE,mBAAmB,EAAE,WAAW,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AACxF,YAAY,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAEzD,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AACjC,YAAY,EAAE,SAAS,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,MAAM,WAAW,CAAC;AAChF,YAAY,EAAE,QAAQ,EAAE,MAAM,WAAW,CAAC;AAE1C,OAAO,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC"}

package/dist/index.js

@@ -1,59 +1,10 @@
-import { Conversation as t, ConversationContent as r, ConversationScrollButton as s } from "./conversation.js";
-import { Message as n, MessageActions as p, MessageAvatar as m, MessageContent as i, MessageList as g } from "./message.js";
-import { MessageText as T } from "./message-text.js";
-import { PromptInput as x, PromptInputSubmit as C, PromptInputTextarea as f, PromptInputToolbar as M } from "./prompt-input.js";
-import { Reasoning as P, ReasoningContent as S, ReasoningTrigger as I } from "./reasoning.js";
-import { Tool as v, ToolContent as A, ToolHeader as c, ToolInput as L, ToolOutput as b } from "./tool.js";
-import { Task as G, TaskList as H, TaskStatus as d, TaskTitle as y } from "./task.js";
-import { CompleteError as E, CompleteGhost as K, CompleteHint as O, CompleteKeys as j, CompleteMark as q, CompleteRoot as w, CompleteTextarea as z } from "./complete.js";
-import { AiMark as F } from "./ai-mark.js";
-import { SuggestList as N, SuggestMark as Q, SuggestRoot as U } from "./suggest.js";
-import { cleanGhost as W, useAiStream as X, useInlineCompletion as Y, useSuggestions as Z } from "./use-ai.js";
-import { isReasoningPart as $, isTaskPart as oo, isTextPart as eo, isToolPart as to } from "./message-part.js";
+import { Assist as s, AssistProvider as t } from "./assist.js";
+import { Chat as f } from "./chat.js";
+import { useChat as m } from "@ai-sdk/react";
 export {
-  F as AiMark,
-  E as CompleteError,
-  K as CompleteGhost,
-  O as CompleteHint,
-  j as CompleteKeys,
-  q as CompleteMark,
-  w as CompleteRoot,
-  z as CompleteTextarea,
-  t as Conversation,
-  r as ConversationContent,
-  s as ConversationScrollButton,
-  n as Message,
-  p as MessageActions,
-  m as MessageAvatar,
-  i as MessageContent,
-  g as MessageList,
-  T as MessageText,
-  x as PromptInput,
-  C as PromptInputSubmit,
-  f as PromptInputTextarea,
-  M as PromptInputToolbar,
-  P as Reasoning,
-  S as ReasoningContent,
-  I as ReasoningTrigger,
-  N as SuggestList,
-  Q as SuggestMark,
-  U as SuggestRoot,
-  G as Task,
-  H as TaskList,
-  d as TaskStatus,
-  y as TaskTitle,
-  v as Tool,
-  A as ToolContent,
-  c as ToolHeader,
-  L as ToolInput,
-  b as ToolOutput,
-  W as cleanGhost,
-  $ as isReasoningPart,
-  oo as isTaskPart,
-  eo as isTextPart,
-  to as isToolPart,
-  X as useAiStream,
-  Y as useInlineCompletion,
-  Z as useSuggestions
+  s as Assist,
+  t as AssistProvider,
+  f as Chat,
+  m as useChat
 };
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;"}
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;"}