@slices.sh/ai-chat 0.1.0

package/dist/headless/question-back.d.ts

@@ -0,0 +1,2 @@
+import { type PartProps } from "@slices.sh/core/part";
+export declare function QuestionBack(props: PartProps<"button">): import("react").ReactNode;

package/dist/headless/question-back.js

@@ -0,0 +1,16 @@
+"use client";
+import { usePart, useRequired } from "@slices.sh/core/part";
+import { QuestionStepsContext, QuestionWriteContext } from "./contexts.js";
+function QuestionBack(props) {
+  const steps = useRequired(QuestionStepsContext, "Chat.QuestionBack requires Chat.PartQuestion.");
+  const write = useRequired(QuestionWriteContext, "Chat.QuestionBack requires Chat.PartQuestion.");
+  const element = usePart("button", props, {
+    defaults: { type: "button" },
+    locked: { disabled: write.pending },
+    behavior: { onClick: () => steps.move("back") }
+  });
+  return steps.index === 0 ? null : element;
+}
+export {
+  QuestionBack
+};

package/dist/headless/question-error.d.ts

@@ -0,0 +1,2 @@
+import { type PartProps } from "@slices.sh/core/part";
+export declare function QuestionError(props: PartProps<"p">): import("react").ReactNode;

package/dist/headless/question-error.js

@@ -0,0 +1,14 @@
+"use client";
+import { usePart, useRequired } from "@slices.sh/core/part";
+import { QuestionWriteContext } from "./contexts.js";
+function QuestionError(props) {
+  const write = useRequired(QuestionWriteContext, "Chat.QuestionError requires Chat.PartQuestion.");
+  return usePart(
+    "p",
+    { ...props, children: write.error ? props.children : null },
+    { locked: { role: "alert" } }
+  );
+}
+export {
+  QuestionError
+};

package/dist/headless/question-invalid.d.ts

@@ -0,0 +1,8 @@
+import type { QuestionProblem } from "../services/types";
+import { type PartProps } from "@slices.sh/core/part";
+/** What is missing from one question's answer, once the person tried to go on without it. */
+export declare function QuestionInvalid({ name, ...props }: PartProps<"p", {
+    problem: QuestionProblem;
+}> & {
+    name: string;
+}): import("react").ReactNode;

package/dist/headless/question-invalid.js

@@ -0,0 +1,18 @@
+"use client";
+import { usePart, useRequired } from "@slices.sh/core/part";
+import { QuestionCheckContext } from "./contexts.js";
+function QuestionInvalid({
+  name,
+  ...props
+}) {
+  const check = useRequired(QuestionCheckContext, "Chat.QuestionInvalid requires Chat.PartQuestion.");
+  const problem = check.shown(name);
+  const element = usePart("p", props, {
+    state: { problem: problem ?? "required" },
+    locked: { role: "alert" }
+  });
+  return problem ? element : null;
+}
+export {
+  QuestionInvalid
+};

package/dist/headless/question-item.d.ts

@@ -0,0 +1,8 @@
+import { type PartProps } from "@slices.sh/core/part";
+/**
+ * One question: a radiogroup when the answer is one choice, a group when it is several. Only the
+ * question of the current step is drawn. Number shortcuts stay inside it and never intercept typing.
+ */
+export declare function QuestionItem({ name, ref, ...props }: PartProps<"fieldset"> & {
+    name: string;
+}): import("react").ReactNode;

package/dist/headless/question-item.js

@@ -0,0 +1,51 @@
+"use client";
+import { useCallback } from "react";
+import { usePart, useRequired } from "@slices.sh/core/part";
+import { QuestionCheckContext, QuestionStepsContext } from "./contexts.js";
+import { useMergedRef } from "./use-merged-ref.js";
+import { useQuestion } from "./use-question.js";
+function QuestionItem({ name, ref, ...props }) {
+  const question = useQuestion(name, "QuestionItem");
+  const check = useRequired(QuestionCheckContext, "Chat.QuestionItem requires Chat.PartQuestion.");
+  const steps = useRequired(QuestionStepsContext, "Chat.QuestionItem requires Chat.PartQuestion.");
+  const multiple = Boolean(question?.multiple);
+  const invalid = check.shown(name) !== null;
+  const arrive = useCallback(
+    (node) => {
+      if (node && steps.moved) node.focus();
+    },
+    [steps.moved]
+  );
+  const merged = useMergedRef(arrive, ref);
+  const element = usePart(
+    "fieldset",
+    { ...props, ref: merged },
+    {
+      defaults: { tabIndex: -1 },
+      attributes: { invalid },
+      locked: {
+        role: multiple ? void 0 : "radiogroup",
+        "aria-invalid": !multiple && invalid ? true : void 0
+      },
+      behavior: {
+        onKeyDown: (event) => {
+          if (event.defaultPrevented || event.ctrlKey || event.metaKey || event.altKey || !/^[1-9]$/.test(event.key))
+            return;
+          const target = event.target;
+          if (target.closest("textarea,[contenteditable=true],input:not([type=radio]):not([type=checkbox])"))
+            return;
+          const choice = event.currentTarget.querySelectorAll("input[aria-keyshortcuts]")[Number(event.key) - 1];
+          if (choice && !choice.disabled) {
+            event.preventDefault();
+            choice.focus();
+            choice.click();
+          }
+        }
+      }
+    }
+  );
+  return question && steps.active(name) ? element : null;
+}
+export {
+  QuestionItem
+};

package/dist/headless/question-next.d.ts

@@ -0,0 +1,3 @@
+import { type PartProps } from "@slices.sh/core/part";
+/** Goes on once this question's answer is good; the last question has Send answers instead. */
+export declare function QuestionNext(props: PartProps<"button">): import("react").ReactNode;

package/dist/headless/question-next.js

@@ -0,0 +1,16 @@
+"use client";
+import { usePart, useRequired } from "@slices.sh/core/part";
+import { QuestionStepsContext, QuestionWriteContext } from "./contexts.js";
+function QuestionNext(props) {
+  const steps = useRequired(QuestionStepsContext, "Chat.QuestionNext requires Chat.PartQuestion.");
+  const write = useRequired(QuestionWriteContext, "Chat.QuestionNext requires Chat.PartQuestion.");
+  const element = usePart("button", props, {
+    defaults: { type: "button" },
+    locked: { disabled: write.pending },
+    behavior: { onClick: () => steps.move("next") }
+  });
+  return steps.index === steps.count - 1 ? null : element;
+}
+export {
+  QuestionNext
+};

package/dist/headless/question-other.d.ts

@@ -0,0 +1,5 @@
+import { type PartProps } from "@slices.sh/core/part";
+/** The field of the "Other" row, inline with its control. */
+export declare function QuestionOther({ name, ...props }: PartProps<"input"> & {
+    name: string;
+}): import("react").ReactNode;

package/dist/headless/question-other.js

@@ -0,0 +1,22 @@
+"use client";
+import { usePart, useRequired } from "@slices.sh/core/part";
+import { QuestionDraftContext, QuestionWriteContext } from "./contexts.js";
+import { useQuestion } from "./use-question.js";
+function QuestionOther({ name, ...props }) {
+  const question = useQuestion(name, "QuestionOther");
+  const draft = useRequired(QuestionDraftContext, "Chat.QuestionOther requires Chat.PartQuestion.");
+  const write = useRequired(QuestionWriteContext, "Chat.QuestionOther requires Chat.PartQuestion.");
+  const element = usePart("input", props, {
+    defaults: { type: "text" },
+    behavior: {
+      // A pointer, not focus: tabbing past the field must not replace a choice the person made.
+      onPointerDown: () => draft.change(name, { type: "select-other" }),
+      onChange: (event) => draft.change(name, { type: "write-other", text: event.currentTarget.value })
+    },
+    locked: { disabled: write.pending, value: draft.other(name).text, "aria-label": question?.other }
+  });
+  return question?.other ? element : null;
+}
+export {
+  QuestionOther
+};

package/dist/headless/question-progress.d.ts

@@ -0,0 +1,8 @@
+import { type PartProps } from "@slices.sh/core/part";
+type Progress = {
+    position: number;
+    count: number;
+};
+/** "2 of 3": the place in a form of several questions, and nothing in a form of one. */
+export declare function QuestionProgress(props: PartProps<"p", Progress>): import("react").ReactNode;
+export {};

package/dist/headless/question-progress.js

@@ -0,0 +1,14 @@
+"use client";
+import { usePart, useRequired } from "@slices.sh/core/part";
+import { QuestionStepsContext } from "./contexts.js";
+function QuestionProgress(props) {
+  const steps = useRequired(QuestionStepsContext, "Chat.QuestionProgress requires Chat.PartQuestion.");
+  const element = usePart("p", props, {
+    state: { position: steps.index + 1, count: steps.count },
+    locked: { "aria-live": "polite" }
+  });
+  return steps.count > 1 ? element : null;
+}
+export {
+  QuestionProgress
+};

package/dist/headless/question-receipt.d.ts

@@ -0,0 +1,11 @@
+import { type GateProps } from "@slices.sh/core/part";
+type Receipt = {
+    title: string;
+    answers: {
+        name: string;
+        title: string;
+        values: string[];
+    }[];
+};
+export declare function QuestionReceipt({ children }: GateProps<Receipt>): import("react").ReactNode;
+export {};

package/dist/headless/question-receipt.js

@@ -0,0 +1,29 @@
+"use client";
+import { isToolUIPart } from "ai";
+import { isSkippedQuestion, questionInput } from "../hooks/use-question-draft.js";
+import { useRequired } from "@slices.sh/core/part";
+import { PartScope } from "./contexts.js";
+import { gateContent } from "./gate-content.js";
+function QuestionReceipt({ children }) {
+  const part = useRequired(PartScope, "Chat.QuestionReceipt requires Chat.Parts.");
+  const input = questionInput(part);
+  if (!input || !isToolUIPart(part) || part.state !== "output-available" || !part.output || typeof part.output !== "object")
+    return null;
+  const output = part.output;
+  const skipped = isSkippedQuestion(part);
+  const answers = input.questions.map((q) => {
+    const value = skipped ? void 0 : output[q.name];
+    const values = (Array.isArray(value) ? value : typeof value === "string" ? [value] : []).filter(
+      (value2) => typeof value2 === "string" && Boolean(value2.trim())
+    );
+    return {
+      name: q.name,
+      title: q.title,
+      values: values.map((value2) => q.choices.find((c) => c.value === value2)?.label ?? value2)
+    };
+  });
+  return gateContent(children, { title: input.title, answers });
+}
+export {
+  QuestionReceipt
+};

package/dist/headless/questions.d.ts

@@ -0,0 +1,3 @@
+import { type GateProps } from "@slices.sh/core/part";
+import type { Questionnaire } from "../services/types";
+export declare function Questions({ children }: GateProps<Questionnaire>): import("react").ReactNode;

package/dist/headless/questions.js

@@ -0,0 +1,13 @@
+"use client";
+import { useRequired } from "@slices.sh/core/part";
+import { QuestionInputContext } from "./contexts.js";
+import { gateContent } from "./gate-content.js";
+function Questions({ children }) {
+  return gateContent(
+    children,
+    useRequired(QuestionInputContext, "Chat.Questions requires Chat.PartQuestion.")
+  );
+}
+export {
+  Questions
+};

package/dist/headless/queue-editing.d.ts

@@ -0,0 +1,4 @@
+import { type GateProps } from "@slices.sh/core/part";
+export declare function QueueEditing({ children }: GateProps<{
+    text: string;
+}>): import("react").ReactNode;

package/dist/headless/queue-editing.js

@@ -0,0 +1,11 @@
+"use client";
+import { useRequired } from "@slices.sh/core/part";
+import { QueueScope } from "./contexts.js";
+import { gateContent } from "./gate-content.js";
+function QueueEditing({ children }) {
+  const item = useRequired(QueueScope, "Chat.QueueEditing requires Chat.QueueItems.");
+  return item.draft !== null ? gateContent(children, { text: item.text }) : null;
+}
+export {
+  QueueEditing
+};

package/dist/headless/queue-item.d.ts

@@ -0,0 +1,2 @@
+import { type PartProps } from "@slices.sh/core/part";
+export declare function QueueItem(props: PartProps<"div">): import("react").ReactNode;

package/dist/headless/queue-item.js

@@ -0,0 +1,10 @@
+"use client";
+import { usePart, useRequired } from "@slices.sh/core/part";
+import { QueueScope } from "./contexts.js";
+function QueueItem(props) {
+  const item = useRequired(QueueScope, "Chat.QueueItem requires Chat.QueueItems.");
+  return usePart("div", props, { defaults: { role: "group" }, locked: { "aria-label": item.text } });
+}
+export {
+  QueueItem
+};

package/dist/headless/queue-items.d.ts

@@ -0,0 +1,2 @@
+import { type RootProps } from "@slices.sh/core/part";
+export declare function QueueItems({ children }: RootProps): import("react").JSX.Element[];

package/dist/headless/queue-items.js

@@ -0,0 +1,11 @@
+"use client";
+import { jsx } from "react/jsx-runtime";
+import { useRequired } from "@slices.sh/core/part";
+import { QueueContext, QueueScope } from "./contexts.js";
+function QueueItems({ children }) {
+  const queue = useRequired(QueueContext, "Chat.QueueItems requires Chat.Root.");
+  return queue.items.map((item) => /* @__PURE__ */ jsx(QueueScope, { value: item, children }, item.id));
+}
+export {
+  QueueItems
+};

package/dist/headless/queue-preview.d.ts

@@ -0,0 +1,6 @@
+import type { FileUIPart } from "ai";
+import { type GateProps } from "@slices.sh/core/part";
+export declare function QueuePreview({ children }: GateProps<{
+    text: string;
+    files: readonly FileUIPart[];
+}>): import("react").ReactNode;

package/dist/headless/queue-preview.js

@@ -0,0 +1,11 @@
+"use client";
+import { useRequired } from "@slices.sh/core/part";
+import { QueueScope } from "./contexts.js";
+import { gateContent } from "./gate-content.js";
+function QueuePreview({ children }) {
+  const item = useRequired(QueueScope, "Chat.QueuePreview requires Chat.QueueItems.");
+  return item.draft === null ? gateContent(children, { text: item.text, files: item.files ?? [] }) : null;
+}
+export {
+  QueuePreview
+};

package/dist/headless/queued-input.d.ts

@@ -0,0 +1,2 @@
+import { type PartProps } from "@slices.sh/core/part";
+export declare function QueuedInput(props: PartProps<"textarea">): import("react").ReactNode;

package/dist/headless/queued-input.js

@@ -0,0 +1,27 @@
+"use client";
+import { usePart, useRequired } from "@slices.sh/core/part";
+import { QueueContext, QueueScope } from "./contexts.js";
+function QueuedInput(props) {
+  const queue = useRequired(QueueContext, "Chat.QueuedInput requires Chat.Root.");
+  const item = useRequired(QueueScope, "Chat.QueuedInput requires Chat.QueueItems.");
+  return usePart("textarea", props, {
+    locked: { value: item.draft ?? item.text },
+    behavior: {
+      onChange: (event) => queue.change({ type: "edit", id: item.id, text: event.currentTarget.value }),
+      onKeyDown: (event) => {
+        if (event.nativeEvent.isComposing) return;
+        if (event.key === "Escape") {
+          event.preventDefault();
+          queue.change({ type: "cancel-edit", id: item.id });
+        }
+        if (event.key === "Enter" && (event.ctrlKey || event.metaKey)) {
+          event.preventDefault();
+          queue.change({ type: "save-edit", id: item.id });
+        }
+      }
+    }
+  });
+}
+export {
+  QueuedInput
+};

package/dist/headless/queued.d.ts

@@ -0,0 +1,17 @@
+import { type GateProps } from "@slices.sh/core/part";
+/**
+ * How many messages are waiting, and for what: the running turn, an open question or a tool
+ * decision. A reason is always given, because a queue that holds without saying why looks broken.
+ *
+ * The queue was computed, returned and thrown away, so typing during an answer cleared the
+ * box and showed nothing: three follow-ups looked like three sends that did not work, and
+ * then arrived minutes later in an order nobody could predict.
+ *
+ * This is a gate and not a live region, and the difference matters: a region announces what
+ * appears *inside* it, so one that arrives already holding its sentence announces nothing.
+ * The region is the composer's, mounted from the first render; this puts a sentence into it.
+ */
+export declare function Queued({ children, }: GateProps<{
+    count: number;
+    waitingFor: "turn" | "question" | "approval";
+}>): import("react").ReactNode;

package/dist/headless/queued.js

@@ -0,0 +1,16 @@
+"use client";
+import { useRequired } from "@slices.sh/core/part";
+import { QueueContext } from "./contexts.js";
+import { gateContent } from "./gate-content.js";
+function Queued({
+  children
+}) {
+  const queue = useRequired(QueueContext, "Chat.Queued must be inside <Chat.Root>.");
+  return queue.waiting > 0 ? gateContent(children, {
+    count: queue.waiting,
+    waitingFor: queue.blockedBy === "question" || queue.blockedBy === "approval" ? queue.blockedBy : "turn"
+  }) : null;
+}
+export {
+  Queued
+};

package/dist/headless/read-aloud.d.ts

@@ -0,0 +1,5 @@
+import { type PartProps } from "@slices.sh/core/part";
+export declare function ReadAloud(props: PartProps<"button", {
+    playing: boolean;
+    failed: boolean;
+}>): import("react").ReactNode;

package/dist/headless/read-aloud.js

@@ -0,0 +1,19 @@
+"use client";
+import { useReadAloud } from "../hooks/use-read-aloud.js";
+import { usePart, useRequired } from "@slices.sh/core/part";
+import { MessageScope } from "./contexts.js";
+function ReadAloud(props) {
+  const message = useRequired(MessageScope, "Chat.ReadAloud requires Chat.Messages.");
+  const text = message.parts.flatMap((part) => part.type === "text" ? [part.text] : []).join("\n\n");
+  const speech = useReadAloud(text);
+  const element = usePart("button", props, {
+    defaults: { type: "button" },
+    state: { playing: speech.playing, failed: speech.failed },
+    locked: { "aria-pressed": speech.playing },
+    behavior: { onClick: speech.toggle }
+  });
+  return speech.available && message.role === "assistant" && text.trim() ? element : null;
+}
+export {
+  ReadAloud
+};

package/dist/headless/reasoning-disclosure.d.ts

@@ -0,0 +1,3 @@
+import { type PartProps } from "@slices.sh/core/part";
+/** Native details stays searchable and lets the browser reveal a found match. */
+export declare function ReasoningDisclosure(props: PartProps<"details">): import("react").ReactNode;

package/dist/headless/reasoning-disclosure.js

@@ -0,0 +1,17 @@
+"use client";
+import { usePart, useRequired } from "@slices.sh/core/part";
+import { ReasoningContext } from "./contexts.js";
+function ReasoningDisclosure(props) {
+  const value = useRequired(ReasoningContext, "Chat.ReasoningDisclosure requires Chat.PartReasoning.");
+  return usePart("details", props, {
+    locked: { open: value.open },
+    behavior: {
+      onToggle: (event) => {
+        if (event.currentTarget.open !== value.open) value.setOpen(event.currentTarget.open);
+      }
+    }
+  });
+}
+export {
+  ReasoningDisclosure
+};

package/dist/headless/reasoning-timer.d.ts

@@ -0,0 +1,5 @@
+import { type PartProps } from "@slices.sh/core/part";
+export declare function ReasoningTimer(props: PartProps<"span", {
+    seconds: number | null;
+    streaming: boolean;
+}>): import("react").ReactNode;

package/dist/headless/reasoning-timer.js

@@ -0,0 +1,13 @@
+"use client";
+import { usePart, useRequired } from "@slices.sh/core/part";
+import { ReasoningContext } from "./contexts.js";
+function ReasoningTimer(props) {
+  const { seconds, streaming } = useRequired(
+    ReasoningContext,
+    "Chat.ReasoningTimer requires Chat.PartReasoning."
+  );
+  return usePart("span", props, { state: { seconds, streaming } });
+}
+export {
+  ReasoningTimer
+};

package/dist/headless/references.d.ts

@@ -0,0 +1,6 @@
+import { type GateProps } from "@slices.sh/core/part";
+import type { ChatSource } from "../services/types";
+/** URL and document references in native transcript order, deduplicated by source identity. */
+export declare function References({ children }: GateProps<{
+    sources: readonly ChatSource[];
+}>): import("react").ReactNode;

package/dist/headless/references.js

@@ -0,0 +1,13 @@
+"use client";
+import { useSources } from "../hooks/use-sources.js";
+import { useRequired } from "@slices.sh/core/part";
+import { MessageScope } from "./contexts.js";
+import { gateContent } from "./gate-content.js";
+function References({ children }) {
+  const message = useRequired(MessageScope, "Chat.References requires Chat.Messages.");
+  const sources = useSources(message);
+  return sources.length ? gateContent(children, { sources }) : null;
+}
+export {
+  References
+};

package/dist/headless/regenerate.d.ts

@@ -0,0 +1,3 @@
+import { type PartProps } from "@slices.sh/core/part";
+/** An older answer is safe to regenerate once its entire tail is preserved as a branch. */
+export declare function Regenerate(props: PartProps<"button">): import("react").ReactNode;

package/dist/headless/regenerate.js

@@ -0,0 +1,22 @@
+"use client";
+import { useChat } from "@ai-sdk/react";
+import { usePart, useRequired } from "@slices.sh/core/part";
+import { BranchContext, MessageScope, ChatContext } from "./contexts.js";
+function Regenerate(props) {
+  const chat = useRequired(ChatContext, "Chat.Regenerate requires Chat.Root.");
+  const { messages } = useChat({ chat });
+  const branches = useRequired(BranchContext, "Chat.Regenerate requires Chat.Root.");
+  const message = useRequired(MessageScope, "Chat.Regenerate requires Chat.Messages.");
+  const element = usePart("button", props, {
+    defaults: { type: "button" },
+    locked: { disabled: branches.blocked },
+    behavior: { onClick: () => branches.regenerate(message.id) }
+  });
+  return message.role === "assistant" && messages.slice(
+    0,
+    messages.findIndex((item) => item.id === message.id)
+  ).some((item) => item.role === "user") ? element : null;
+}
+export {
+  Regenerate
+};

package/dist/headless/remembered-approval.d.ts

@@ -0,0 +1,2 @@
+import { type PartProps } from "@slices.sh/core/part";
+export declare function RememberedApproval(props: PartProps<"span">): import("react").ReactNode;

package/dist/headless/remembered-approval.js

@@ -0,0 +1,14 @@
+"use client";
+import { getToolName, isToolUIPart } from "ai";
+import { usePart, useRequired } from "@slices.sh/core/part";
+import { ApprovalMemoryContext, PartScope } from "./contexts.js";
+function RememberedApproval(props) {
+  const memory = useRequired(ApprovalMemoryContext, "Chat.RememberedApproval requires Chat.Root.");
+  const part = useRequired(PartScope, "Chat.RememberedApproval requires Chat.Parts.");
+  const name = isToolUIPart(part) ? getToolName(part) : null;
+  const element = usePart("span", props, {});
+  return memory.enabled && name && memory.tools.includes(name) ? element : null;
+}
+export {
+  RememberedApproval
+};

package/dist/headless/root.d.ts

@@ -0,0 +1,30 @@
+import type { ChatSettings, ChatFeedbackOptions } from "../services/types";
+import { type AiChat } from "../hooks/use-chat-instance";
+import type { Enabled } from "@slices.sh/core";
+import { type RootProps } from "@slices.sh/core/part";
+type ChatRootProps = RootProps & ChatFeedbackOptions & {
+    /** The key in `services/ai-chat/config.ts`: the route the chat talks to when it is handed none. Left out, the config's slug. */
+    name?: string;
+    /** The config to talk to, `"default"` when left out. */
+    config?: string;
+    /**
+     * Left out or `true`: required, and a missing service or config throws. `"optional"`: renders
+     * its children, and a Composer under it renders nothing. `false`: off. A capability name
+     * requires the service and that capability.
+     */
+    enabled?: Enabled;
+    /**
+     * An AI SDK `Chat` the app made — its id, the messages it opens on, a transport with your
+     * headers — which every part reads with `useChat({ chat })`. Without one, a chat over the
+     * installed backend's route.
+     */
+    chat?: AiChat;
+    /** From chatSession(client, name), bound to the supplied Chat transport. */
+    settings?: ChatSettings | null;
+    /** The sink's `whenBusy`: on, a message sent mid-answer is accepted and queued; off, Composer holds it until the chat is free. */
+    queue?: boolean;
+    /** Enable explicit per-tool consent remembered only for this Chat instance. */
+    rememberApprovals?: boolean;
+};
+export declare function Root(props: ChatRootProps): import("react").JSX.Element;
+export {};