@slices.sh/ai-chat 0.1.0

package/dist/headless/root.js

@@ -0,0 +1,99 @@
+"use client";
+import { jsx } from "react/jsx-runtime";
+import { useChatSettings } from "../hooks/use-chat-settings.js";
+import { useBranches } from "../hooks/use-branches.js";
+import { useToolApprovalMemory } from "../hooks/use-tool-approval-memory.js";
+import { useRememberedApprovals } from "../hooks/use-remembered-approvals.js";
+import { MessageScroller } from "@shadcn/react/message-scroller";
+import { useChat } from "@ai-sdk/react";
+import { useCallback, useContext } from "react";
+import { SinkProvider } from "@slices.sh/composer";
+import { useChatInstance } from "../hooks/use-chat-instance.js";
+import { useComposer } from "../hooks/use-composer.js";
+import { useFollow } from "../hooks/use-follow.js";
+import { useReply } from "../hooks/use-reply.js";
+import { useTurnQueue } from "../hooks/use-turn-queue.js";
+import { Provide } from "@slices.sh/core/part";
+import { useChatSink } from "../hooks/use-chat-sink.js";
+import {
+  SettingsContext,
+  FeedbackOptionsContext,
+  BranchContext,
+  ApprovalMemoryContext,
+  ApprovalAutomationContext,
+  ChatContext,
+  ChatConfigContext,
+  ComposerContext,
+  ComposerStandaloneContext,
+  FollowContext,
+  QueueContext,
+  SourceContext
+} from "./contexts.js";
+function Root(props) {
+  const outer = useContext(ChatContext);
+  const outerConfig = useContext(ChatConfigContext);
+  if (outer && !props.chat && (props.config === void 0 || props.config === outerConfig)) {
+    return /* @__PURE__ */ jsx(ComposerStandaloneContext, { value: "embedded", children: props.children });
+  }
+  return /* @__PURE__ */ jsx(MessageScroller.Provider, { autoScroll: true, defaultScrollPosition: "last-anchor", scrollPreviousItemPeek: 64, children: /* @__PURE__ */ jsx(Session, { ...props }) });
+}
+function Session({
+  config,
+  enabled,
+  name = config ?? "default",
+  chat: given,
+  settings: givenSettings,
+  queue = true,
+  rememberApprovals = true,
+  onFeedback,
+  children
+}) {
+  const { chat, source, settings: ownSettings } = useChatInstance(name, given, { config, enabled });
+  const { status, messages } = useChat({ chat });
+  const waiting = useTurnQueue(chat);
+  const settings = useChatSettings(chat, given ? givenSettings ?? null : ownSettings, waiting.waiting);
+  const branches = useBranches(chat, source !== "missing" && waiting.waiting === 0);
+  const approvals = useToolApprovalMemory(chat, rememberApprovals);
+  const automation = useRememberedApprovals(chat, approvals);
+  const send = useReply(chat);
+  const stop = useCallback(() => {
+    if (chat.status !== "submitted" && chat.status !== "streaming") return false;
+    void chat.stop();
+    return true;
+  }, [chat]);
+  const composer = useComposer({
+    scope: chat,
+    onStop: stop,
+    onRemoveLast: settings.removeLast,
+    onSend: queue ? waiting.enqueue : send,
+    // Nothing answers a chat with no backend, and with no queue the composer is what refuses
+    // a second message: one turn at a time is a property of the chat, and the person should
+    // see which control is holding it.
+    disabled: source === "missing" || !queue && (status === "submitted" || status === "streaming")
+  });
+  const sink = useChatSink({ chat, source, config, queue, enqueue: waiting.enqueue, stop, removeLast: settings.removeLast });
+  const follow = useFollow(messages.findLast((message) => message.role === "user")?.id);
+  return /* @__PURE__ */ jsx(
+    Provide,
+    {
+      values: [
+        [ChatContext, chat],
+        [ChatConfigContext, config ?? "default"],
+        [ComposerStandaloneContext, "standalone"],
+        [SettingsContext, settings],
+        [FeedbackOptionsContext, { onFeedback }],
+        [BranchContext, branches],
+        [ApprovalMemoryContext, approvals],
+        [ApprovalAutomationContext, automation],
+        [SourceContext, source],
+        [ComposerContext, composer],
+        [FollowContext, follow],
+        [QueueContext, waiting]
+      ],
+      children: /* @__PURE__ */ jsx(SinkProvider, { value: sink, children })
+    }
+  );
+}
+export {
+  Root
+};

package/dist/headless/save-edit.d.ts

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

package/dist/headless/save-edit.js

@@ -0,0 +1,16 @@
+"use client";
+import { usePart, useRequired } from "@slices.sh/core/part";
+import { BranchContext, MessageScope, SentDraftContext } from "./contexts.js";
+function SaveEdit(props) {
+  const branches = useRequired(BranchContext, "Chat.SaveEdit requires Chat.Root.");
+  const message = useRequired(MessageScope, "Chat.SaveEdit requires Chat.Messages.");
+  const draft = useRequired(SentDraftContext, "Chat.SaveEdit requires Chat.MessageEditRoot.");
+  const empty = !draft.value?.trim() && !message.parts.some((part) => part.type === "file");
+  return usePart("button", props, {
+    defaults: { type: "submit" },
+    locked: { disabled: branches.blocked || draft.value === null || empty }
+  });
+}
+export {
+  SaveEdit
+};

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

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

package/dist/headless/save-queued.js

@@ -0,0 +1,15 @@
+"use client";
+import { usePart, useRequired } from "@slices.sh/core/part";
+import { QueueContext, QueueScope } from "./contexts.js";
+function SaveQueued(props) {
+  const queue = useRequired(QueueContext, "Chat.SaveQueued requires Chat.Root.");
+  const item = useRequired(QueueScope, "Chat.SaveQueued requires Chat.QueueItems.");
+  return usePart("button", props, {
+    defaults: { type: "button" },
+    locked: { disabled: item.draft === null || !item.draft.trim() && !item.files?.length },
+    behavior: { onClick: () => queue.change({ type: "save-edit", id: item.id }) }
+  });
+}
+export {
+  SaveQueued
+};

package/dist/headless/send-now.d.ts

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

package/dist/headless/send-now.js

@@ -0,0 +1,17 @@
+"use client";
+import { usePart, useRequired } from "@slices.sh/core/part";
+import { QueueContext, QueueScope } from "./contexts.js";
+function SendNow(props) {
+  const queue = useRequired(QueueContext, "Chat.SendNow requires Chat.Root.");
+  const item = useRequired(QueueScope, "Chat.SendNow requires Chat.QueueItems.");
+  return usePart("button", props, {
+    defaults: { type: "button" },
+    // An open question is no reason to wait: sending now skips it and sends this as the reply.
+    // A tool decision is one, and its buttons are in the transcript.
+    locked: { disabled: queue.blockedBy !== null && queue.blockedBy !== "question" || item.draft !== null },
+    behavior: { onClick: () => queue.change({ type: "send-now", id: item.id }) }
+  });
+}
+export {
+  SendNow
+};

package/dist/headless/settings.d.ts

@@ -0,0 +1,2 @@
+import { type GateProps } from "@slices.sh/core/part";
+export declare function Settings({ children }: GateProps): import("react").ReactNode;

package/dist/headless/settings.js

@@ -0,0 +1,10 @@
+"use client";
+import { useRequired } from "@slices.sh/core/part";
+import { SettingsContext } from "./contexts.js";
+function Settings({ children }) {
+  const { choices } = useRequired(SettingsContext, "Chat.Settings requires Chat.Root.");
+  return choices && (choices.models?.length || choices.tools?.length) ? children : null;
+}
+export {
+  Settings
+};

package/dist/headless/skip-questions.d.ts

@@ -0,0 +1,6 @@
+import { type PartProps } from "@slices.sh/core/part";
+/**
+ * Dismisses the open question without answering it. The queue decides what the model hears next:
+ * the message the person typed meanwhile, as their reply, or else a nudge to carry on.
+ */
+export declare function SkipQuestions(props: PartProps<"button">): import("react").ReactNode;

package/dist/headless/skip-questions.js

@@ -0,0 +1,18 @@
+"use client";
+import { isToolUIPart } from "ai";
+import { usePart, useRequired } from "@slices.sh/core/part";
+import { PartScope, QueueContext, QuestionWriteContext } from "./contexts.js";
+function SkipQuestions(props) {
+  const queue = useRequired(QueueContext, "Chat.SkipQuestions requires Chat.Root.");
+  const write = useRequired(QuestionWriteContext, "Chat.SkipQuestions requires Chat.PartQuestion.");
+  const part = useRequired(PartScope, "Chat.SkipQuestions requires Chat.Parts.");
+  const id = isToolUIPart(part) ? part.toolCallId : null;
+  return usePart("button", props, {
+    defaults: { type: "button" },
+    locked: { disabled: write.pending || id === null },
+    behavior: { onClick: () => id !== null && queue.change({ type: "skip-question", toolCallId: id }) }
+  });
+}
+export {
+  SkipQuestions
+};

package/dist/headless/source-context.d.ts

@@ -0,0 +1,5 @@
+import type { ChatSource } from "../services/types";
+import type { SourceDisclosure } from "../hooks/use-source-disclosure";
+export declare const SourceScope: import("react").Context<ChatSource | null>;
+export declare const CitationDisclosureContext: import("react").Context<SourceDisclosure | null>;
+export declare const SourceSheetContext: import("react").Context<SourceDisclosure | null>;

package/dist/headless/source-context.js

@@ -0,0 +1,9 @@
+import { createContext } from "react";
+const SourceScope = createContext(null);
+const CitationDisclosureContext = createContext(null);
+const SourceSheetContext = createContext(null);
+export {
+  CitationDisclosureContext,
+  SourceScope,
+  SourceSheetContext
+};

package/dist/headless/source-link.d.ts

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

package/dist/headless/source-link.js

@@ -0,0 +1,13 @@
+"use client";
+import { usePart, useRequired } from "@slices.sh/core/part";
+import { SourceScope } from "./source-context.js";
+function SourceLink(props) {
+  const source = useRequired(SourceScope, "Chat.SourceLink requires Chat.SourceRoot.");
+  const element = usePart("a", props, {
+    locked: { href: source.href ?? void 0, target: "_blank", rel: "noopener noreferrer" }
+  });
+  return source.href ? element : null;
+}
+export {
+  SourceLink
+};

package/dist/headless/source-primitives.d.ts

@@ -0,0 +1 @@
+export { Popover, Dialog, MotionPopover, MotionDialog } from "@slices.sh/core/motion-base-ui";

package/dist/headless/source-primitives.js

@@ -0,0 +1,7 @@
+import { Popover, Dialog, MotionPopover, MotionDialog } from "@slices.sh/core/motion-base-ui";
+export {
+  Dialog,
+  MotionDialog,
+  MotionPopover,
+  Popover
+};

package/dist/headless/source-root.d.ts

@@ -0,0 +1,5 @@
+import type { ChatSource } from "../services/types";
+import type { RootProps } from "@slices.sh/core/part";
+export declare function SourceRoot({ source, children }: RootProps & {
+    source: ChatSource;
+}): import("react").JSX.Element;

package/dist/headless/source-root.js

@@ -0,0 +1,9 @@
+"use client";
+import { jsx } from "react/jsx-runtime";
+import { SourceScope } from "./source-context.js";
+function SourceRoot({ source, children }) {
+  return /* @__PURE__ */ jsx(SourceScope, { value: source, children });
+}
+export {
+  SourceRoot
+};

package/dist/headless/source-sheet-close.d.ts

@@ -0,0 +1,2 @@
+import { type PartProps } from "@slices.sh/core/part";
+export declare function SourceSheetClose(props: PartProps<"button">): string | number | bigint | boolean | Iterable<import("react").ReactNode> | Promise<string | number | bigint | boolean | import("react").ReactPortal | import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>> | Iterable<import("react").ReactNode> | null | undefined> | import("react").JSX.Element | null | undefined;

package/dist/headless/source-sheet-close.js

@@ -0,0 +1,12 @@
+"use client";
+import { jsx } from "react/jsx-runtime";
+import { isValidElement } from "react";
+import { Dialog } from "./source-primitives.js";
+import { usePart } from "@slices.sh/core/part";
+function SourceSheetClose(props) {
+  const element = usePart("button", props);
+  return isValidElement(element) ? /* @__PURE__ */ jsx(Dialog.Close, { render: element }) : element;
+}
+export {
+  SourceSheetClose
+};

package/dist/headless/source-sheet-content.d.ts

@@ -0,0 +1,3 @@
+import { type PartProps } from "@slices.sh/core/part";
+/** The skin's surface preserves the corresponding Motion primitive adapter. */
+export declare function SourceSheetContent(props: PartProps<"div">): import("react").ReactNode;

package/dist/headless/source-sheet-content.js

@@ -0,0 +1,16 @@
+"use client";
+import { jsx } from "react/jsx-runtime";
+import { MotionDialog } from "./source-primitives.js";
+import { usePart, useRequired } from "@slices.sh/core/part";
+import { SourceSheetContext } from "./source-context.js";
+function SourceSheetContent(props) {
+  const disclosure = useRequired(SourceSheetContext, "Chat.SourceSheetContent requires Chat.SourceSheetRoot.");
+  return usePart(
+    "div",
+    { ...props, render: props.render ?? /* @__PURE__ */ jsx(MotionDialog, {}) },
+    { locked: { open: disclosure.open } }
+  );
+}
+export {
+  SourceSheetContent
+};

package/dist/headless/source-sheet-description.d.ts

@@ -0,0 +1,2 @@
+import { type PartProps } from "@slices.sh/core/part";
+export declare function SourceSheetDescription(props: PartProps<"p">): string | number | bigint | boolean | Iterable<import("react").ReactNode> | Promise<string | number | bigint | boolean | import("react").ReactPortal | import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>> | Iterable<import("react").ReactNode> | null | undefined> | import("react").JSX.Element | null | undefined;

package/dist/headless/source-sheet-description.js

@@ -0,0 +1,12 @@
+"use client";
+import { jsx } from "react/jsx-runtime";
+import { isValidElement } from "react";
+import { Dialog } from "./source-primitives.js";
+import { usePart } from "@slices.sh/core/part";
+function SourceSheetDescription(props) {
+  const element = usePart("p", props);
+  return isValidElement(element) ? /* @__PURE__ */ jsx(Dialog.Description, { render: element }) : element;
+}
+export {
+  SourceSheetDescription
+};

package/dist/headless/source-sheet-root.d.ts

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

package/dist/headless/source-sheet-root.js

@@ -0,0 +1,13 @@
+"use client";
+import { jsx } from "react/jsx-runtime";
+import { Dialog } from "./source-primitives.js";
+import { useSourceDisclosure } from "../hooks/use-source-disclosure.js";
+import { Provide } from "@slices.sh/core/part";
+import { SourceSheetContext } from "./source-context.js";
+function SourceSheetRoot({ children }) {
+  const disclosure = useSourceDisclosure();
+  return /* @__PURE__ */ jsx(Dialog.Root, { open: disclosure.open, onOpenChange: disclosure.setOpen, children: /* @__PURE__ */ jsx(Provide, { values: [[SourceSheetContext, disclosure]], children }) });
+}
+export {
+  SourceSheetRoot
+};

package/dist/headless/source-sheet-title.d.ts

@@ -0,0 +1,2 @@
+import { type PartProps } from "@slices.sh/core/part";
+export declare function SourceSheetTitle(props: PartProps<"h2">): string | number | bigint | boolean | Iterable<import("react").ReactNode> | Promise<string | number | bigint | boolean | import("react").ReactPortal | import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>> | Iterable<import("react").ReactNode> | null | undefined> | import("react").JSX.Element | null | undefined;

package/dist/headless/source-sheet-title.js

@@ -0,0 +1,12 @@
+"use client";
+import { jsx } from "react/jsx-runtime";
+import { isValidElement } from "react";
+import { Dialog } from "./source-primitives.js";
+import { usePart } from "@slices.sh/core/part";
+function SourceSheetTitle(props) {
+  const element = usePart("h2", props);
+  return isValidElement(element) ? /* @__PURE__ */ jsx(Dialog.Title, { render: element }) : element;
+}
+export {
+  SourceSheetTitle
+};

package/dist/headless/source-sheet-trigger.d.ts

@@ -0,0 +1,2 @@
+import { type PartProps } from "@slices.sh/core/part";
+export declare function SourceSheetTrigger(props: PartProps<"button">): string | number | bigint | boolean | Iterable<import("react").ReactNode> | Promise<string | number | bigint | boolean | import("react").ReactPortal | import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>> | Iterable<import("react").ReactNode> | null | undefined> | import("react").JSX.Element | null | undefined;

package/dist/headless/source-sheet-trigger.js

@@ -0,0 +1,12 @@
+"use client";
+import { jsx } from "react/jsx-runtime";
+import { isValidElement } from "react";
+import { Dialog } from "./source-primitives.js";
+import { usePart } from "@slices.sh/core/part";
+function SourceSheetTrigger(props) {
+  const element = usePart("button", props);
+  return isValidElement(element) ? /* @__PURE__ */ jsx(Dialog.Trigger, { render: element }) : element;
+}
+export {
+  SourceSheetTrigger
+};

package/dist/headless/source-unavailable.d.ts

@@ -0,0 +1,2 @@
+import { type GateProps } from "@slices.sh/core/part";
+export declare function SourceUnavailable({ children }: GateProps): import("react").ReactNode;

package/dist/headless/source-unavailable.js

@@ -0,0 +1,9 @@
+"use client";
+import { useRequired } from "@slices.sh/core/part";
+import { SourceScope } from "./source-context.js";
+function SourceUnavailable({ children }) {
+  return useRequired(SourceScope, "Chat.SourceUnavailable requires Chat.SourceRoot.").href ? null : children;
+}
+export {
+  SourceUnavailable
+};

package/dist/headless/sources.d.ts

@@ -0,0 +1,14 @@
+import type { SourceUrlUIPart } from "ai";
+import { type GateProps } from "@slices.sh/core/part";
+/**
+ * What the answer was drawn from, the SDK's `source-url` parts, collected.
+ *
+ * A footer rather than a part in the flow: citations arrive interleaved with the prose and
+ * read as an appendix, and a reader who wants them wants all of them at once. A document
+ * source has no URL to open, and a citation nobody can follow is a row that looks like a
+ * link and is not one. Nothing is rendered where the backend sent none, which is most
+ * backends.
+ */
+export declare function Sources({ children }: GateProps<{
+    sources: SourceUrlUIPart[];
+}>): import("react").ReactNode;

package/dist/headless/sources.js

@@ -0,0 +1,12 @@
+"use client";
+import { useRequired } from "@slices.sh/core/part";
+import { MessageScope } from "./contexts.js";
+import { gateContent } from "./gate-content.js";
+function Sources({ children }) {
+  const message = useRequired(MessageScope, "Chat.Sources must be inside <Chat.Messages>.");
+  const sources = message.parts.filter((part) => part.type === "source-url");
+  return sources.length > 0 ? gateContent(children, { sources }) : null;
+}
+export {
+  Sources
+};

package/dist/headless/speaker.d.ts

@@ -0,0 +1,13 @@
+import { type PartProps } from "@slices.sh/core/part";
+import type { AiChatMessage } from "../services/types";
+/**
+ * Who said it, in words.
+ *
+ * Colour and alignment are the only thing that told the two apart, which is nothing at all
+ * to a screen reader and very little on a low-contrast theme. The default skin hides this
+ * visually and leaves it in the accessibility tree, where it is the difference between a
+ * conversation and a run of anonymous paragraphs.
+ */
+export declare function Speaker(props: PartProps<"span", {
+    role: AiChatMessage["role"];
+}>): import("react").ReactNode;

package/dist/headless/speaker.js

@@ -0,0 +1,10 @@
+"use client";
+import { usePart, useRequired } from "@slices.sh/core/part";
+import { MessageScope } from "./contexts.js";
+function Speaker(props) {
+  const message = useRequired(MessageScope, "Chat.Speaker must be inside <Chat.Messages>.");
+  return usePart("span", props, { state: { role: message.role } });
+}
+export {
+  Speaker
+};

package/dist/headless/step-boundary.d.ts

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

package/dist/headless/step-boundary.js

@@ -0,0 +1,16 @@
+"use client";
+import { useRequired } from "@slices.sh/core/part";
+import { MessageScope, PartScope } from "./contexts.js";
+import { gateContent } from "./gate-content.js";
+function StepBoundary({ children }) {
+  const part = useRequired(PartScope, "Chat.StepBoundary requires Chat.Parts.");
+  const message = useRequired(MessageScope, "Chat.StepBoundary requires Chat.Messages.");
+  if (part.type !== "step-start") return null;
+  const index = message.parts.indexOf(part);
+  return gateContent(children, {
+    number: message.parts.slice(0, index + 1).filter((p) => p.type === "step-start").length
+  });
+}
+export {
+  StepBoundary
+};

package/dist/headless/stop.d.ts

@@ -0,0 +1,10 @@
+import { type PartProps } from "@slices.sh/core/part";
+/**
+ * Stops a reply that is streaming. Stopping is the chat's own behaviour, so it is not a mode
+ * of `Composer.Submit`: no generic part can express it.
+ *
+ * It is disabled while nothing streams, never unmounted: a button that came and went with
+ * every turn moved the controls beside it under a cursor already on its way, and dropped
+ * focus to the body when the turn ended with it focused.
+ */
+export declare function Stop(props: PartProps<"button">): import("react").ReactNode;

package/dist/headless/stop.js

@@ -0,0 +1,18 @@
+"use client";
+import { useChat } from "@ai-sdk/react";
+import { usePart, useRequired } from "@slices.sh/core/part";
+import { ChatContext } from "./contexts.js";
+function Stop(props) {
+  const chat = useRequired(ChatContext, "Chat.Stop must be inside <Chat.Root>.");
+  const { status, stop } = useChat({ chat });
+  const running = status === "submitted" || status === "streaming";
+  return usePart("button", props, {
+    defaults: { type: "button" },
+    behavior: { onClick: () => void stop() },
+    locked: { type: "button", disabled: !running },
+    attributes: { active: running }
+  });
+}
+export {
+  Stop
+};

package/dist/headless/stopped.d.ts

@@ -0,0 +1,11 @@
+import { type GateProps } from "@slices.sh/core/part";
+/**
+ * This reply was cut off, and somebody should be told in words.
+ *
+ * Fading the text was the whole account of it before, which is a contrast regression that
+ * says nothing: the reader could not tell whether they had stopped it, the model had, or
+ * the network went. → components/headless/ai-chat/writing.ts
+ */
+export declare function Stopped({ children }: GateProps<{
+    reason: "length" | "interrupted";
+}>): import("react").ReactNode;

package/dist/headless/stopped.js

@@ -0,0 +1,17 @@
+"use client";
+import { useChat } from "@ai-sdk/react";
+import { useRequired } from "@slices.sh/core/part";
+import { gateContent } from "./gate-content.js";
+import { ChatContext, MessageScope } from "./contexts.js";
+import { isCutOff, isWriting } from "./writing.js";
+function Stopped({ children }) {
+  const message = useRequired(MessageScope, "Chat.Stopped must be inside <Chat.Messages>.");
+  const chat = useRequired(ChatContext, "Chat.Stopped must be inside <Chat.Root>.");
+  const { messages, status } = useChat({ chat });
+  return isCutOff(message, isWriting(message, messages, status)) ? gateContent(children, {
+    reason: message.metadata?.finishReason === "length" ? "length" : "interrupted"
+  }) : null;
+}
+export {
+  Stopped
+};

package/dist/headless/submit-answers.d.ts

@@ -0,0 +1,3 @@
+import { type PartProps } from "@slices.sh/core/part";
+/** On the last question only: before it, Next is the way on. */
+export declare function SubmitAnswers(props: PartProps<"button">): import("react").ReactNode;

package/dist/headless/submit-answers.js

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

package/dist/headless/submit.d.ts

@@ -0,0 +1,23 @@
+import { type PartProps } from "@slices.sh/core/part";
+/**
+ * One control that sends, and stops what it sent with the SDK's `stop`.
+ *
+ * The composer's only submit, and the only button that ever occupies this spot. A separate
+ * stop button had to appear between send and its neighbour mid-turn, which moved the most
+ * used control in the component under a cursor already on its way down; it also unmounted
+ * itself the instant the turn ended, dropping focus to the body if anyone had tabbed to it.
+ * Morphing solves both: the element is the same element, and it is `type="submit"` only
+ * while submitting is what it does. → docs/rules/one-submit-per-form.md
+ *
+ * It stops an answer while there is nothing to send, and sends while there is — which is
+ * the only reading that leaves the queue reachable by touch. Otherwise the one button
+ * beside the box said "stop" the whole time an answer was arriving, so a follow-up typed
+ * on a phone could be sent only from the software keyboard's own return key, and the
+ * control right next to it did something else. Where the composer refuses a second message
+ * outright (`queue` off) there is nothing to send by definition, so this is stop again.
+ *
+ * @deprecated Chat.Submit becomes Composer.Submit, and its stopping half is Chat.Stop.
+ */
+export declare function Submit(props: PartProps<"button", {
+    stopping: boolean;
+}>): import("react").ReactNode;

package/dist/headless/submit.js

@@ -0,0 +1,24 @@
+"use client";
+import { useContext } from "react";
+import { useChat } from "@ai-sdk/react";
+import { usePart, useRequired } from "@slices.sh/core/part";
+import { ChatContext, ComposerContext, ComposerAttachmentsContext } from "./contexts.js";
+function Submit(props) {
+  const chat = useRequired(ChatContext, "Chat.Submit must be inside <Chat.Root>.");
+  const composer = useRequired(ComposerContext, "Chat.Submit must be inside <Chat.Root>.");
+  const { status, stop } = useChat({ chat });
+  const running = status === "submitted" || status === "streaming";
+  const attachments = useContext(ComposerAttachmentsContext);
+  const sendable = (composer.draft.trim().length > 0 || (attachments?.count ?? 0) > 0) && !composer.disabled && !attachments?.blocked;
+  const stopping = running && !sendable;
+  return usePart("button", props, {
+    state: { stopping },
+    defaults: { type: "submit" },
+    behavior: { onClick: stopping ? () => void stop() : void 0 },
+    locked: { type: stopping ? "button" : "submit", disabled: !stopping && !sendable },
+    attributes: { active: stopping }
+  });
+}
+export {
+  Submit
+};

package/dist/headless/suggestion.d.ts

@@ -0,0 +1,10 @@
+import { type PartProps } from "@slices.sh/core/part";
+type SuggestionProps = PartProps<"button"> & {
+    text: string;
+};
+/**
+ * Sends its own text. It goes through the composer rather than the chat, so a suggestion
+ * queued behind a running turn waits exactly as a typed message does.
+ */
+export declare function Suggestion({ text, ...props }: SuggestionProps): import("react").ReactNode;
+export {};