@slices.sh/ai-chat 0.1.0

package/dist/headless/input.js

@@ -0,0 +1,18 @@
+"use client";
+import { usePart, useRequired } from "@slices.sh/core/part";
+import { ComposerContext } from "./contexts.js";
+function Input(props) {
+  const composer = useRequired(ComposerContext, "Chat.Input must be inside <Chat.Root>.");
+  return usePart("textarea", props, {
+    attributes: { "chat-composer": true },
+    defaults: { autoComplete: "off", enterKeyHint: "send" },
+    behavior: {
+      onChange: (event) => composer.set(event.currentTarget.value),
+      onKeyDown: composer.keyDown
+    },
+    locked: { value: composer.draft, disabled: composer.disabled }
+  });
+}
+export {
+  Input
+};

package/dist/headless/jump-to-latest.d.ts

@@ -0,0 +1,3 @@
+import { type PartProps } from "@slices.sh/core/part";
+/** Rendered only once the reader has scrolled the transcript away from its end. */
+export declare function JumpToLatest(props: PartProps<"button">): import("react").ReactNode;

package/dist/headless/jump-to-latest.js

@@ -0,0 +1,14 @@
+"use client";
+import { usePart, useRequired } from "@slices.sh/core/part";
+import { FollowContext } from "./contexts.js";
+function JumpToLatest(props) {
+  const follow = useRequired(FollowContext, "Chat.JumpToLatest must be inside <Chat.Root>.");
+  const element = usePart("button", props, {
+    defaults: { type: "button" },
+    behavior: { onClick: () => follow.jump() }
+  });
+  return follow.following ? null : element;
+}
+export {
+  JumpToLatest
+};

package/dist/headless/message-edit-root.d.ts

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

package/dist/headless/message-edit-root.js

@@ -0,0 +1,13 @@
+"use client";
+import { jsx } from "react/jsx-runtime";
+import { useSentDraft } from "../hooks/use-sent-draft.js";
+import { useRequired } from "@slices.sh/core/part";
+import { MessageScope, SentDraftContext } from "./contexts.js";
+function MessageEditRoot({ children }) {
+  const message = useRequired(MessageScope, "Chat.MessageEditRoot requires Chat.Messages.");
+  const draft = useSentDraft(message);
+  return /* @__PURE__ */ jsx(SentDraftContext, { value: draft, children });
+}
+export {
+  MessageEditRoot
+};

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

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

package/dist/headless/message-editing.js

@@ -0,0 +1,10 @@
+"use client";
+import { useRequired } from "@slices.sh/core/part";
+import { SentDraftContext } from "./contexts.js";
+function MessageEditing({ children }) {
+  const draft = useRequired(SentDraftContext, "Chat.MessageEditing requires Chat.MessageEditRoot.");
+  return draft.value !== null ? children : null;
+}
+export {
+  MessageEditing
+};

package/dist/headless/message-editor.d.ts

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

package/dist/headless/message-editor.js

@@ -0,0 +1,19 @@
+"use client";
+import { usePart, useRequired } from "@slices.sh/core/part";
+import { BranchContext, MessageScope, SentDraftContext } from "./contexts.js";
+function MessageEditor(props) {
+  const branches = useRequired(BranchContext, "Chat.MessageEditor requires Chat.Root.");
+  const message = useRequired(MessageScope, "Chat.MessageEditor requires Chat.Messages.");
+  const draft = useRequired(SentDraftContext, "Chat.MessageEditor requires Chat.MessageEditRoot.");
+  return usePart("form", props, {
+    behavior: {
+      onSubmit: (event) => {
+        event.preventDefault();
+        if (draft.value !== null && branches.edit(message.id, draft.value)) draft.cancel();
+      }
+    }
+  });
+}
+export {
+  MessageEditor
+};

package/dist/headless/message-footer.d.ts

@@ -0,0 +1,3 @@
+import { type PartProps } from "@slices.sh/core/part";
+/** Completed-turn actions stay available on the latest answer and to keyboard/touch readers. */
+export declare function MessageFooter(props: PartProps<"div">): import("react").ReactNode;

package/dist/headless/message-footer.js

@@ -0,0 +1,15 @@
+"use client";
+import { useChat } from "@ai-sdk/react";
+import { usePart, useRequired } from "@slices.sh/core/part";
+import { ChatContext, MessageScope } from "./contexts.js";
+import { isWriting } from "./writing.js";
+function MessageFooter(props) {
+  const message = useRequired(MessageScope, "Chat.MessageFooter must be inside <Chat.Messages>.");
+  const chat = useRequired(ChatContext, "Chat.MessageFooter must be inside <Chat.Root>.");
+  const { messages, status } = useChat({ chat });
+  const element = usePart("div", props, { attributes: { active: messages.at(-1)?.id === message.id } });
+  return isWriting(message, messages, status) ? null : element;
+}
+export {
+  MessageFooter
+};

package/dist/headless/message-reading.d.ts

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

package/dist/headless/message-reading.js

@@ -0,0 +1,10 @@
+"use client";
+import { useRequired } from "@slices.sh/core/part";
+import { SentDraftContext } from "./contexts.js";
+function MessageReading({ children }) {
+  const draft = useRequired(SentDraftContext, "Chat.MessageReading requires Chat.MessageEditRoot.");
+  return draft.value === null ? children : null;
+}
+export {
+  MessageReading
+};

package/dist/headless/message.d.ts

@@ -0,0 +1,11 @@
+import { type PartProps } from "@slices.sh/core/part";
+import type { AiChatMessage } from "../services/types";
+type MessageState = {
+    role: AiChatMessage["role"];
+    interrupted: boolean;
+    streaming: boolean;
+};
+export declare function Message({ optimizeHistory, ...props }: PartProps<"div", MessageState> & {
+    optimizeHistory?: boolean;
+}): import("react").ReactNode;
+export {};

package/dist/headless/message.js

@@ -0,0 +1,34 @@
+"use client";
+import { jsx } from "react/jsx-runtime";
+import { MessageScroller } from "@shadcn/react/message-scroller";
+import { useChat } from "@ai-sdk/react";
+import { usePart, useRequired } from "@slices.sh/core/part";
+import { ChatContext, MessageScope } from "./contexts.js";
+import { isCutOff, isWriting } from "./writing.js";
+function Message({ optimizeHistory = true, ...props }) {
+  const message = useRequired(MessageScope, "Chat.Message must be inside <Chat.Messages>.");
+  const chat = useRequired(ChatContext, "Chat.Message must be inside <Chat.Root>.");
+  const { messages, status } = useChat({ chat });
+  const streaming = isWriting(message, messages, status);
+  const interrupted = isCutOff(message, streaming);
+  const anchor = message.role === "user" && messages.findLast((item) => item.role === "user")?.id === message.id;
+  const historical = optimizeHistory && messages.length > 40 && !anchor && !streaming && !messages.slice(-6).some((item) => item.id === message.id);
+  return usePart(
+    "div",
+    { ...props, render: props.render ?? /* @__PURE__ */ jsx(MessageScroller.Item, {}) },
+    {
+      state: { role: message.role, interrupted, streaming },
+      defaults: { style: historical ? { contentVisibility: "auto", containIntrinsicSize: "auto 20rem" } : void 0 },
+      // `state` carries the role so one rule can style a side; `interrupted` is its own
+      // attribute because it is a fact about the message rather than whose it is.
+      //
+      // `aria-busy` is why the answer being written is told apart: without it a polite log
+      // reads a reply a word at a time, and with it the reply is read once, when it is a reply.
+      attributes: { state: message.role, invalid: interrupted, pending: streaming },
+      locked: { "aria-busy": streaming || void 0, messageId: message.id, scrollAnchor: anchor }
+    }
+  );
+}
+export {
+  Message
+};

package/dist/headless/messages.d.ts

@@ -0,0 +1,9 @@
+import { type RootProps } from "@slices.sh/core/part";
+/**
+ * The transcript's messages, each in its own scope, exactly as the AI SDK holds them.
+ *
+ * The repeat is a part rather than a `map` in the pattern, because a message is where the
+ * looks change most and the iteration never does: a skin decides what a row is, and this
+ * decides what the rows are.
+ */
+export declare function Messages({ children }: RootProps): import("react").JSX.Element[];

package/dist/headless/messages.js

@@ -0,0 +1,19 @@
+"use client";
+import { jsx } from "react/jsx-runtime";
+import { useContext } from "react";
+import { useChat } from "@ai-sdk/react";
+import { useRequired } from "@slices.sh/core/part";
+import { ChatContext, MessageScope, BranchContext } from "./contexts.js";
+function Messages({ children }) {
+  const chat = useRequired(ChatContext, "Chat.Messages must be inside <Chat.Root>.");
+  const branches = useContext(BranchContext);
+  const { messages } = useChat({ chat });
+  return messages.map((message) => {
+    const page = branches?.page(message.id);
+    const key = page?.anchored ? `branch:${page.id}` : `message:${message.id}`;
+    return /* @__PURE__ */ jsx(MessageScope, { value: message, children }, key);
+  });
+}
+export {
+  Messages
+};

package/dist/headless/model-picker.d.ts

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

package/dist/headless/model-picker.js

@@ -0,0 +1,14 @@
+"use client";
+import { usePart, useRequired } from "@slices.sh/core/part";
+import { SettingsContext } from "./contexts.js";
+function ModelPicker(props) {
+  const settings = useRequired(SettingsContext, "Chat.ModelPicker requires Chat.Root.");
+  const part = usePart("select", props, {
+    locked: { value: settings.selection.model ?? "", disabled: settings.blocked },
+    behavior: { onChange: (event) => settings.model(event.currentTarget.value) }
+  });
+  return settings.choices?.models?.length ? part : null;
+}
+export {
+  ModelPicker
+};

package/dist/headless/model.d.ts

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

package/dist/headless/model.js

@@ -0,0 +1,13 @@
+"use client";
+import { useRequired } from "@slices.sh/core/part";
+import { MessageScope } from "./contexts.js";
+import { gateContent } from "./gate-content.js";
+function Model({ children }) {
+  const message = useRequired(MessageScope, "Chat.Model must be inside <Chat.Messages>.");
+  const model = message.metadata?.model;
+  if (!model) return null;
+  return gateContent(children, { model });
+}
+export {
+  Model
+};

package/dist/headless/models.d.ts

@@ -0,0 +1,5 @@
+import { type GateProps } from "@slices.sh/core/part";
+import type { ChatChoices } from "../services/types";
+export declare function Models({ children }: GateProps<{
+    models: NonNullable<ChatChoices["models"]>;
+}>): import("react").ReactNode;

package/dist/headless/models.js

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

package/dist/headless/optional-tools.d.ts

@@ -0,0 +1,7 @@
+import { type GateProps } from "@slices.sh/core/part";
+import type { ChatChoices } from "../services/types";
+export declare function OptionalTools({ selected, children }: GateProps<{
+    tools: NonNullable<ChatChoices["tools"]>;
+}> & {
+    selected?: boolean;
+}): import("react").ReactNode;

package/dist/headless/optional-tools.js

@@ -0,0 +1,12 @@
+"use client";
+import { useRequired } from "@slices.sh/core/part";
+import { SettingsContext } from "./contexts.js";
+import { gateContent } from "./gate-content.js";
+function OptionalTools({ selected = false, children }) {
+  const state = useRequired(SettingsContext, "Chat.OptionalTools requires Chat.Root.");
+  const tools = state.choices?.tools?.filter((tool) => !selected || state.selection.tools?.includes(tool.id));
+  return tools?.length ? gateContent(children, { tools }) : null;
+}
+export {
+  OptionalTools
+};

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

@@ -0,0 +1,5 @@
+import { type PartProps } from "@slices.sh/core/part";
+/** The control of the "Other" row, last in the same group as the choices: it replaces the pick of a single question and adds to a multiple one. */
+export declare function OtherAnswer({ name, ...props }: PartProps<"input"> & {
+    name: string;
+}): import("react").ReactNode;

package/dist/headless/other-answer.js

@@ -0,0 +1,32 @@
+"use client";
+import { usePart, useRequired } from "@slices.sh/core/part";
+import { QuestionCheckContext, QuestionDraftContext, QuestionWriteContext } from "./contexts.js";
+import { useQuestion } from "./use-question.js";
+function OtherAnswer({ name, ...props }) {
+  const question = useQuestion(name, "OtherAnswer");
+  const draft = useRequired(QuestionDraftContext, "Chat.OtherAnswer requires Chat.PartQuestion.");
+  const check = useRequired(QuestionCheckContext, "Chat.OtherAnswer requires Chat.PartQuestion.");
+  const write = useRequired(QuestionWriteContext, "Chat.OtherAnswer requires Chat.PartQuestion.");
+  const multiple = Boolean(question?.multiple);
+  const element = usePart("input", props, {
+    behavior: {
+      onChange: () => draft.change(name, { type: "toggle-other" }),
+      onClick: (event) => {
+        if (event.currentTarget.checked)
+          event.currentTarget.closest("fieldset")?.querySelector("input[type=text]")?.focus();
+      }
+    },
+    locked: {
+      type: multiple ? "checkbox" : "radio",
+      name,
+      value: "",
+      checked: draft.other(name).on,
+      disabled: write.pending,
+      "aria-invalid": multiple && check.shown(name) ? true : void 0
+    }
+  });
+  return question?.other ? element : null;
+}
+export {
+  OtherAnswer
+};

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

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

package/dist/headless/part-approval.js

@@ -0,0 +1,33 @@
+"use client";
+import { jsx } from "react/jsx-runtime";
+import { isToolUIPart } from "ai";
+import { useToolApproval } from "../hooks/use-tool-approval.js";
+import { usePart, useRequired } from "@slices.sh/core/part";
+import { ApprovalContext, ChatContext, PartScope } from "./contexts.js";
+function PartApproval(props) {
+  const part = useRequired(PartScope, "Chat.PartApproval requires Chat.Parts.");
+  if (!isToolUIPart(part) || part.state !== "approval-requested") return null;
+  return /* @__PURE__ */ jsx(Request, { id: part.approval.id, props }, part.approval.id);
+}
+function Request({ id, props }) {
+  const chat = useRequired(ChatContext, "Chat.PartApproval requires Chat.Root.");
+  const write = useToolApproval(chat, id);
+  const element = usePart("div", props, {
+    defaults: { role: "group" },
+    locked: { "aria-busy": write.pending || void 0 },
+    behavior: {
+      onKeyDown: (event) => {
+        if (event.defaultPrevented || write.pending) return;
+        if (event.key === "Escape" || event.key === "Enter" && (event.metaKey || event.ctrlKey)) {
+          event.preventDefault();
+          event.stopPropagation();
+          void write.run({ approved: event.key !== "Escape" });
+        }
+      }
+    }
+  });
+  return /* @__PURE__ */ jsx(ApprovalContext, { value: write, children: element });
+}
+export {
+  PartApproval
+};

package/dist/headless/part-file.d.ts

@@ -0,0 +1,6 @@
+import type { FileUIPart } from "ai";
+import { type GateProps } from "@slices.sh/core/part";
+/** A native file stays visible in history even when the rich media viewer is not installed. */
+export declare function PartFile({ children }: GateProps<{
+    file: FileUIPart;
+}>): import("react").ReactNode;

package/dist/headless/part-file.js

@@ -0,0 +1,11 @@
+"use client";
+import { useRequired } from "@slices.sh/core/part";
+import { PartScope } from "./contexts.js";
+import { gateContent } from "./gate-content.js";
+function PartFile({ children }) {
+  const part = useRequired(PartScope, "Chat.PartFile requires Chat.Parts.");
+  return part.type === "file" ? gateContent(children, { file: part }) : null;
+}
+export {
+  PartFile
+};

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

@@ -0,0 +1,2 @@
+import { type PartProps } from "@slices.sh/core/part";
+export declare function PartQuestion(props: PartProps<"form">): import("react").JSX.Element | null;

package/dist/headless/part-question.js

@@ -0,0 +1,57 @@
+"use client";
+import { jsx } from "react/jsx-runtime";
+import { isToolUIPart } from "ai";
+import { questionInput, useQuestionDraft } from "../hooks/use-question-draft.js";
+import { useQuestionCheck } from "../hooks/use-question-check.js";
+import { useQuestionSteps } from "../hooks/use-question-steps.js";
+import { useQuestionWrite } from "../hooks/use-question-write.js";
+import { Provide, usePart, useRequired } from "@slices.sh/core/part";
+import {
+  ChatContext,
+  PartScope,
+  QuestionInputContext,
+  QuestionDraftContext,
+  QuestionCheckContext,
+  QuestionStepsContext,
+  QuestionWriteContext
+} from "./contexts.js";
+function PartQuestion(props) {
+  const part = useRequired(PartScope, "Chat.PartQuestion requires Chat.Parts.");
+  const input = questionInput(part);
+  if (!input || !isToolUIPart(part) || part.state !== "input-available") return null;
+  return /* @__PURE__ */ jsx(Request, { id: part.toolCallId, input, props }, part.toolCallId);
+}
+function Request({ id, input, props }) {
+  const chat = useRequired(ChatContext, "Chat.PartQuestion requires Chat.Root.");
+  const draft = useQuestionDraft(input);
+  const check = useQuestionCheck(input, draft);
+  const steps = useQuestionSteps(input, check);
+  const write = useQuestionWrite(chat, id);
+  const element = usePart("form", props, {
+    locked: { "aria-label": input.title, "aria-busy": write.pending || void 0 },
+    behavior: {
+      onSubmit: (event) => {
+        event.preventDefault();
+        if (write.pending) return;
+        if (steps.index < steps.count - 1) steps.move("next");
+        else if (steps.move("finish")) void write.run(draft.answers);
+      }
+    }
+  });
+  return /* @__PURE__ */ jsx(
+    Provide,
+    {
+      values: [
+        [QuestionInputContext, input],
+        [QuestionDraftContext, draft],
+        [QuestionCheckContext, check],
+        [QuestionStepsContext, steps],
+        [QuestionWriteContext, write]
+      ],
+      children: element
+    }
+  );
+}
+export {
+  PartQuestion
+};

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

@@ -0,0 +1,15 @@
+import type { ReasoningUIPart } from "ai";
+import { type GateProps } from "@slices.sh/core/part";
+type PartReasoningState = ReasoningUIPart & {
+    streaming: boolean;
+};
+/**
+ * A model thinking out loud, the SDK's `reasoning` part, and whether it has stopped.
+ *
+ * `streaming` is what lets one block be open while it fills and closed once the answer
+ * starts, which is the convention every product settled on: the trace is interesting while
+ * it is the only thing happening and noise the moment it is not. A trace the SDK still
+ * holds as `streaming` on an answer nobody is writing was cut off, and is over too.
+ */
+export declare function PartReasoning({ children }: GateProps<PartReasoningState>): import("react").JSX.Element | null;
+export {};

package/dist/headless/part-reasoning.js

@@ -0,0 +1,26 @@
+"use client";
+import { jsx } from "react/jsx-runtime";
+import { useChat } from "@ai-sdk/react";
+import { useRequired } from "@slices.sh/core/part";
+import { useReasoning } from "../hooks/use-reasoning.js";
+import { ChatContext, MessageScope, PartScope, ReasoningContext } from "./contexts.js";
+import { gateContent } from "./gate-content.js";
+import { isWriting } from "./writing.js";
+function PartReasoning({ children }) {
+  const part = useRequired(PartScope, "Chat.PartReasoning must be inside <Chat.Parts>.");
+  return part.type === "reasoning" ? /* @__PURE__ */ jsx(Trace, { part, children }) : null;
+}
+function Trace({
+  part,
+  children
+}) {
+  const message = useRequired(MessageScope, "Chat.PartReasoning must be inside <Chat.Messages>.");
+  const chat = useRequired(ChatContext, "Chat.PartReasoning must be inside <Chat.Root>.");
+  const { messages, status } = useChat({ chat });
+  const streaming = part.state === "streaming" && isWriting(message, messages, status);
+  const reasoning = useReasoning(streaming);
+  return /* @__PURE__ */ jsx(ReasoningContext, { value: reasoning, children: gateContent(children, { ...part, streaming }) });
+}
+export {
+  PartReasoning
+};

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

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

package/dist/headless/part-source.js

@@ -0,0 +1,20 @@
+"use client";
+import { useSources } from "../hooks/use-sources.js";
+import { useRequired } from "@slices.sh/core/part";
+import { MessageScope, PartScope } from "./contexts.js";
+import { gateContent } from "./gate-content.js";
+function PartSource({ children }) {
+  const message = useRequired(MessageScope, "Chat.PartSource requires Chat.Messages.");
+  const part = useRequired(PartScope, "Chat.PartSource requires Chat.Parts.");
+  const sources = useSources(message);
+  if (part.type !== "source-url" && part.type !== "source-document") return null;
+  const first = message.parts.find(
+    (p) => p.type === part.type && "sourceId" in p && p.sourceId === part.sourceId
+  );
+  if (first !== part) return null;
+  const source = sources.find((s) => s.key === `${part.type}:${part.sourceId}`);
+  return source ? gateContent(children, { source }) : null;
+}
+export {
+  PartSource
+};

package/dist/headless/part-text.d.ts

@@ -0,0 +1,16 @@
+import type { TextUIPart } from "ai";
+import { type GateProps } from "@slices.sh/core/part";
+import type { AiChatMessage } from "../services/types";
+type PartTextState = TextUIPart & {
+    role: AiChatMessage["role"];
+    streaming: boolean;
+};
+/**
+ * One run of prose, the SDK's `text` part. A message has several when something happened
+ * between them.
+ *
+ * The role comes with it because whose text this is decides whether it is markup: a model
+ * writes markdown and means it, and a person who types `2 * 3 * 4` means three numbers.
+ */
+export declare function PartText({ children }: GateProps<PartTextState>): import("react").JSX.Element | null;
+export {};

package/dist/headless/part-text.js

@@ -0,0 +1,29 @@
+"use client";
+import { jsx } from "react/jsx-runtime";
+import { useChat } from "@ai-sdk/react";
+import { useRequired } from "@slices.sh/core/part";
+import { ChatContext, MessageScope, PartScope } from "./contexts.js";
+import { isWriting } from "./writing.js";
+import { gateContent } from "./gate-content.js";
+function PartText({ children }) {
+  const part = useRequired(PartScope, "Chat.PartText must be inside <Chat.Parts>.");
+  const message = useRequired(MessageScope, "Chat.PartText must be inside <Chat.Messages>.");
+  if (part.type !== "text") return null;
+  return /* @__PURE__ */ jsx(Text, { part, message, children });
+}
+function Text({
+  part,
+  message,
+  children
+}) {
+  const chat = useRequired(ChatContext, "Chat.PartText requires Chat.Root.");
+  const { messages, status } = useChat({ chat });
+  return gateContent(children, {
+    ...part,
+    role: message.role,
+    streaming: part.state === "streaming" && isWriting(message, messages, status)
+  });
+}
+export {
+  PartText
+};

package/dist/headless/part-tool.d.ts

@@ -0,0 +1,16 @@
+import { type DynamicToolUIPart, type ToolUIPart } from "ai";
+import { type GateProps } from "@slices.sh/core/part";
+type PartToolState = (ToolUIPart | DynamicToolUIPart) & {
+    toolName: string;
+};
+/**
+ * One tool call, the SDK's `tool-<name>` or `dynamic-tool` part, wherever it has got to.
+ *
+ * The state reaches the screen because the seven of them want different things: an input
+ * still arriving is a shimmer, an output is a disclosure, a denial is a sentence and an
+ * error is a different sentence. One "called a tool" card for all seven would be six lies.
+ * `toolName` is the SDK's own reading of the part's type, beside everything the part holds.
+ * → docs/rules/capability-honesty.md
+ */
+export declare function PartTool({ children }: GateProps<PartToolState>): import("react").ReactNode;
+export {};

package/dist/headless/part-tool.js

@@ -0,0 +1,14 @@
+"use client";
+import { getToolName, isToolUIPart } from "ai";
+import { useRequired } from "@slices.sh/core/part";
+import { questionInput } from "../hooks/use-question-draft.js";
+import { PartScope } from "./contexts.js";
+import { gateContent } from "./gate-content.js";
+function PartTool({ children }) {
+  const part = useRequired(PartScope, "Chat.PartTool must be inside <Chat.Parts>.");
+  if (!isToolUIPart(part) || questionInput(part)) return null;
+  return gateContent(children, { ...part, toolName: getToolName(part) });
+}
+export {
+  PartTool
+};

package/dist/headless/parts.d.ts

@@ -0,0 +1,11 @@
+import { type RootProps } from "@slices.sh/core/part";
+/**
+ * A message's parts, in the order the model produced them, exactly as the AI SDK holds them.
+ *
+ * The order is the content. Reasoning before an answer, a tool call between two halves of
+ * one, a citation after both — a transcript that grouped by kind would say the model did
+ * things in an order it did not. Each kind gates itself inside here, and a kind no gate
+ * draws — a step boundary, an app's own `data-*` part — draws nothing.
+ * → docs/rules/states-gate-themselves.md
+ */
+export declare function Parts({ children }: RootProps): import("react").JSX.Element[];

package/dist/headless/parts.js

@@ -0,0 +1,11 @@
+"use client";
+import { jsx } from "react/jsx-runtime";
+import { useRequired } from "@slices.sh/core/part";
+import { MessageScope, PartScope } from "./contexts.js";
+function Parts({ children }) {
+  const message = useRequired(MessageScope, "Chat.Parts must be inside <Chat.Messages>.");
+  return message.parts.map((part, index) => /* @__PURE__ */ jsx(PartScope, { value: part, children }, `${index}:${part.type}`));
+}
+export {
+  Parts
+};