Conversation

Messages repeats once per UIMessage and Message is its element: data-state user or assistant, aria-busy while it is the answer being written, data-invalid when it was cut off. Speaker says who spoke, for screen readers. Parts repeats once per SDK part in the order the model produced them, and each kind has its own gate: PartText is one run of prose, StepBoundary marks a new model step. Stopped renders only for a reply that was cut off, and Continue sends a follow-up prompt that resumes it.

Source: @slices.sh/ai-chat/src/headless/step-boundary.tsx

Messages repeats once per UIMessage and Message is its element: data-state user or assistant, aria-busy while it is the answer being written, data-invalid when it was cut off. Speaker says who spoke, for screen readers. Parts repeats once per SDK part in the order the model produced them, and each kind has its own gate: PartText is one run of prose, StepBoundary marks a new model step. Stopped renders only for a reply that was cut off, and Continue sends a follow-up prompt that resumes it.

Source: @slices.sh/ai-chat/src/headless/continue.tsx

PartReasoning gates a reasoning part and hands its children { text, streaming }. ReasoningDisclosure is a native details element, so a find in page can reveal a match. ReasoningTimer gives { seconds, streaming } for "Thought for 4s". Without the reasoning capability the model sends no reasoning parts, and the group renders nothing.

Capability: reasoning

Source: @slices.sh/ai-chat/src/headless/reasoning-timer.tsx

Native details stays searchable and lets the browser reveal a found match.

Capability: reasoning

Source: @slices.sh/ai-chat/src/headless/reasoning-disclosure.tsx

Reuses the containing chat, so embedding a composer never starts a second conversation.

Source: @slices.sh/ai-chat/src/headless/composer-root.tsx

Today's chat composer parts. In v2 Chat.Root is a sink (whenBusy "queue") and the generic Composer from @slices.sh/composer writes into it. Chat.Composer becomes Composer.Root. Chat.Input becomes Composer.Input, a field named text, wrapped by Dictation.Field when dictation is wanted. Chat.Submit's sending half becomes Composer.Submit. Its stopping half is chat behaviour no generic part can express, so it stays a chat part, Chat.Stop (new in v2): it calls the SDK's stop, is disabled while nothing streams and never unmounts, so focus and layout stay put when a turn ends. Chat.ComposerRoot becomes a nested Chat.Root, which shares the outer conversation for the same config. Chat.ComposerStandalone has no replacement: a pattern that draws Chat.Settings only when it stands alone takes a prop for it.

Source: @slices.sh/ai-chat/src/headless/composer-standalone.tsx

Chat.Root publishes the SDK Chat itself, never a copy of its state, and provides a sink for Composer. submit(message) calls sendMessage with message.text and message.attachments as file parts. busy is true while a reply streams or a question or tool decision waits. whenBusy is "queue" unless queue={false}. accept.attachments follows the config's files capability: false for a config without files, so the attachment picker inside Composer renders nothing. A Chat.Root nested in another one with the same config and no chat shares the outer conversation.

Source: @slices.sh/ai-chat/src/headless/root.tsx

The scroller, and the only one. A second scroller inside it produces a transcript that follows an end nobody can see: the outer one is already at its bottom, and the words arrive somewhere off screen. `role="log"` with `tabIndex` is the pair the APG asks for and the pair this was missing: the role makes arriving messages announce themselves, and the tab stop is the only way a keyboard reaches a scrolling region whose contents — bubbles, avatars — are not focusable. The busy flag belongs on the message being written and not here. On the region it held back everything the region was for: a polite log defers what arrives inside a busy node, so the question the person just sent and the note saying an answer is coming were both announced late or not at all — the two announcements that matter most, suppressed to defer the one that already defers itself. → components/headless/ai-chat/message.tsx The reader's own wheel, touch, keys and scrollbar are what take the transcript away from where the scroller put it; the scroller's own moves never do. → hooks/ai-chat/use-follow.ts

Source: @slices.sh/ai-chat/src/headless/transcript.tsx

Custom renderers retain MessageScroller.Content so anchor children and resizing stay registered.

Source: @slices.sh/ai-chat/src/headless/thread.tsx

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.

Source: @slices.sh/ai-chat/src/headless/messages.tsx

Messages repeats once per UIMessage and Message is its element: data-state user or assistant, aria-busy while it is the answer being written, data-invalid when it was cut off. Speaker says who spoke, for screen readers. Parts repeats once per SDK part in the order the model produced them, and each kind has its own gate: PartText is one run of prose, StepBoundary marks a new model step. Stopped renders only for a reply that was cut off, and Continue sends a follow-up prompt that resumes it.

Source: @slices.sh/ai-chat/src/headless/message.tsx

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.

Source: @slices.sh/ai-chat/src/headless/speaker.tsx

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

Source: @slices.sh/ai-chat/src/headless/parts.tsx

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.

Source: @slices.sh/ai-chat/src/headless/part-text.tsx

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.

Capability: reasoning

Source: @slices.sh/ai-chat/src/headless/part-reasoning.tsx

What the turn cost, where the provider said: the SDK's usage, as the route put it on the message's metadata when the turn finished. Nothing at all where it did not: this field went years declared and never written, and the website that needed it estimated from the length of the text. An estimate on screen is a number people plan against. → docs/rules/capability-honesty.md

Capability: usage

Source: @slices.sh/ai-chat/src/headless/usage.tsx

Model, Timing and Usage read what the route wrote into the message metadata: which model answered, how long it took, the SDK's LanguageModelUsage. ContextUsage gives { tokens, capacity, percent } for the last request while the chat is idle. Each one is null, and renders nothing, when the provider did not report the value.

Capability: usage

Source: @slices.sh/ai-chat/src/headless/context-usage.tsx

Model, Timing and Usage read what the route wrote into the message metadata: which model answered, how long it took, the SDK's LanguageModelUsage. ContextUsage gives { tokens, capacity, percent } for the last request while the chat is idle. Each one is null, and renders nothing, when the provider did not report the value.

Capability: usage

Source: @slices.sh/ai-chat/src/headless/model.tsx

Model, Timing and Usage read what the route wrote into the message metadata: which model answered, how long it took, the SDK's LanguageModelUsage. ContextUsage gives { tokens, capacity, percent } for the last request while the chat is idle. Each one is null, and renders nothing, when the provider did not report the value.

Capability: usage

Source: @slices.sh/ai-chat/src/headless/timing.tsx

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

Source: @slices.sh/ai-chat/src/headless/stopped.tsx

Today's chat composer parts. In v2 Chat.Root is a sink (whenBusy "queue") and the generic Composer from @slices.sh/composer writes into it. Chat.Composer becomes Composer.Root. Chat.Input becomes Composer.Input, a field named text, wrapped by Dictation.Field when dictation is wanted. Chat.Submit's sending half becomes Composer.Submit. Its stopping half is chat behaviour no generic part can express, so it stays a chat part, Chat.Stop (new in v2): it calls the SDK's stop, is disabled while nothing streams and never unmounts, so focus and layout stay put when a turn ends. Chat.ComposerRoot becomes a nested Chat.Root, which shares the outer conversation for the same config. Chat.ComposerStandalone has no replacement: a pattern that draws Chat.Settings only when it stands alone takes a prop for it.

Source: @slices.sh/ai-chat/src/headless/composer.tsx

A textarea rather than an input, because Shift+Enter has to mean something. No `rows`: the skin sizes it with `field-sizing: content`, so it grows with the message and stops at a maximum. A fixed row locked every paragraph anyone ever wrote into a thirty-six pixel slit, with the browser's own resize handle taken away.

Source: @slices.sh/ai-chat/src/headless/input.tsx

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.

Source: @slices.sh/ai-chat/src/headless/submit.tsx

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.

Source: @slices.sh/ai-chat/src/headless/stop.tsx

Starters, and only on an empty transcript. Once there is a conversation they are no longer suggestions, they are a row of buttons competing with what the person was about to type.

Source: @slices.sh/ai-chat/src/headless/suggestions.tsx

Only the last completed answer can suggest what comes next in the active branch.

Source: @slices.sh/ai-chat/src/headless/follow-ups.tsx

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.

Source: @slices.sh/ai-chat/src/headless/suggestion.tsx

Rendered only once the reader has scrolled the transcript away from its end.

Source: @slices.sh/ai-chat/src/headless/jump-to-latest.tsx

Nothing has been said yet. Where a greeting and the starters go.

Source: @slices.sh/ai-chat/src/headless/empty.tsx

Sent, and nothing back yet: the SDK's `submitted`. Its own gate rather than a flag on a wider one, so the condition lives where the rule wants it and the pattern never writes `waiting ? … : null`. Once the words start arriving they are the answer to "is anything happening", and this renders nothing. → docs/rules/states-gate-themselves.md It belongs inside `Chat.Transcript`, whose `role="log"` announces what arrives in it. A second live region around this note would have a screen reader say it twice.

Source: @slices.sh/ai-chat/src/headless/waiting.tsx

The turn was refused — the SDK's `error` status — and the child is told which refusal it was. The slug reaches the screen because the common ones want different things: a quota refusal wants an upgrade link, an outage wants the retry button, and an unknown chat wants a developer to open `services/ai-chat/config.ts`. One banner for all three would be three lies. → docs/rules/capability-honesty.md

Source: @slices.sh/ai-chat/src/headless/failed.tsx

One gate per state of the conversation, so pattern code never branches on status. Empty: nothing has been said. Waiting: the SDK's submitted, sent with nothing back yet; it belongs inside Chat.Transcript, whose log announces it. Failed: the SDK's error status with the refusal slug (unauthorized, quota-exceeded, unknown-chat…); it belongs outside the scroller so a refusal never renders below the fold. TryAgain: regenerate() from inside Failed. Unavailable: the one part that renders when Chat.Root is enabled="optional" and ai-chat is not configured, for a sentence saying so.

Source: @slices.sh/ai-chat/src/headless/try-again.tsx

No chat backend is installed at all, and the screen was handed no chat. Distinct from a refused turn, because nothing the person does will help: the app is missing an implementation, and the only useful sentence names the command that adds one.

Source: @slices.sh/ai-chat/src/headless/unavailable.tsx

PartTool gates one tool-<name> or dynamic-tool part over the SDK's seven states and hands { toolName, state }. ToolRenderer lets the app draw a tool's body from a renderers map; approval controls stay outside it. ToolInput, ToolOutput and ToolError gate the input, the output and the error text. A config without tools never produces these parts.

Capability: tools

Source: @slices.sh/ai-chat/src/headless/tool-error.tsx

PartTool gates one tool-<name> or dynamic-tool part over the SDK's seven states and hands { toolName, state }. ToolRenderer lets the app draw a tool's body from a renderers map; approval controls stay outside it. ToolInput, ToolOutput and ToolError gate the input, the output and the error text. A config without tools never produces these parts.

Capability: tools

Source: @slices.sh/ai-chat/src/headless/tool-output.tsx

PartTool gates one tool-<name> or dynamic-tool part over the SDK's seven states and hands { toolName, state }. ToolRenderer lets the app draw a tool's body from a renderers map; approval controls stay outside it. ToolInput, ToolOutput and ToolError gate the input, the output and the error text. A config without tools never produces these parts.

Capability: tools

Source: @slices.sh/ai-chat/src/headless/tool-input.tsx

Render only the tool body; approval controls stay outside the app's renderer.

Capability: tools

Source: @slices.sh/ai-chat/src/headless/tool-renderer.tsx

For a tool declared with needsApproval. PartApproval is the request, with ApprovalReason, Approve, Deny and AlwaysAllow (only with rememberApprovals). Answering calls the SDK's addToolApprovalResponse. ApprovalError says the answer did not reach the server. ApprovalReceipt replaces the controls once answered, RememberedApproval marks a call allowed by a remembered consent, and ForgetApproval takes that consent back. While a decision is pending the queue waits for it.

Capability: toolApproval

Source: @slices.sh/ai-chat/src/headless/forget-approval.tsx

For a tool declared with needsApproval. PartApproval is the request, with ApprovalReason, Approve, Deny and AlwaysAllow (only with rememberApprovals). Answering calls the SDK's addToolApprovalResponse. ApprovalError says the answer did not reach the server. ApprovalReceipt replaces the controls once answered, RememberedApproval marks a call allowed by a remembered consent, and ForgetApproval takes that consent back. While a decision is pending the queue waits for it.

Capability: toolApproval

Source: @slices.sh/ai-chat/src/headless/remembered-approval.tsx

For a tool declared with needsApproval. PartApproval is the request, with ApprovalReason, Approve, Deny and AlwaysAllow (only with rememberApprovals). Answering calls the SDK's addToolApprovalResponse. ApprovalError says the answer did not reach the server. ApprovalReceipt replaces the controls once answered, RememberedApproval marks a call allowed by a remembered consent, and ForgetApproval takes that consent back. While a decision is pending the queue waits for it.

Capability: toolApproval

Source: @slices.sh/ai-chat/src/headless/always-allow.tsx

For a tool declared with needsApproval. PartApproval is the request, with ApprovalReason, Approve, Deny and AlwaysAllow (only with rememberApprovals). Answering calls the SDK's addToolApprovalResponse. ApprovalError says the answer did not reach the server. ApprovalReceipt replaces the controls once answered, RememberedApproval marks a call allowed by a remembered consent, and ForgetApproval takes that consent back. While a decision is pending the queue waits for it.

Capability: toolApproval

Source: @slices.sh/ai-chat/src/headless/approval-receipt.tsx

For a tool declared with needsApproval. PartApproval is the request, with ApprovalReason, Approve, Deny and AlwaysAllow (only with rememberApprovals). Answering calls the SDK's addToolApprovalResponse. ApprovalError says the answer did not reach the server. ApprovalReceipt replaces the controls once answered, RememberedApproval marks a call allowed by a remembered consent, and ForgetApproval takes that consent back. While a decision is pending the queue waits for it.

Capability: toolApproval

Source: @slices.sh/ai-chat/src/headless/approval-error.tsx

For a tool declared with needsApproval. PartApproval is the request, with ApprovalReason, Approve, Deny and AlwaysAllow (only with rememberApprovals). Answering calls the SDK's addToolApprovalResponse. ApprovalError says the answer did not reach the server. ApprovalReceipt replaces the controls once answered, RememberedApproval marks a call allowed by a remembered consent, and ForgetApproval takes that consent back. While a decision is pending the queue waits for it.

Capability: toolApproval

Source: @slices.sh/ai-chat/src/headless/approval-reason.tsx

For a tool declared with needsApproval. PartApproval is the request, with ApprovalReason, Approve, Deny and AlwaysAllow (only with rememberApprovals). Answering calls the SDK's addToolApprovalResponse. ApprovalError says the answer did not reach the server. ApprovalReceipt replaces the controls once answered, RememberedApproval marks a call allowed by a remembered consent, and ForgetApproval takes that consent back. While a decision is pending the queue waits for it.

Capability: toolApproval

Source: @slices.sh/ai-chat/src/headless/deny.tsx

For a tool declared with needsApproval. PartApproval is the request, with ApprovalReason, Approve, Deny and AlwaysAllow (only with rememberApprovals). Answering calls the SDK's addToolApprovalResponse. ApprovalError says the answer did not reach the server. ApprovalReceipt replaces the controls once answered, RememberedApproval marks a call allowed by a remembered consent, and ForgetApproval takes that consent back. While a decision is pending the queue waits for it.

Capability: toolApproval

Source: @slices.sh/ai-chat/src/headless/approve.tsx

For a tool declared with needsApproval. PartApproval is the request, with ApprovalReason, Approve, Deny and AlwaysAllow (only with rememberApprovals). Answering calls the SDK's addToolApprovalResponse. ApprovalError says the answer did not reach the server. ApprovalReceipt replaces the controls once answered, RememberedApproval marks a call allowed by a remembered consent, and ForgetApproval takes that consent back. While a decision is pending the queue waits for it.

Capability: toolApproval

Source: @slices.sh/ai-chat/src/headless/part-approval.tsx

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

Capability: tools

Source: @slices.sh/ai-chat/src/headless/part-tool.tsx

The askQuestions tool: a form the model asks the person to fill in. PartQuestion is the form, Questions hands the questionnaire, QuestionItem is one fieldset with Answer per choice and OtherAnswer plus QuestionOther for a free answer. ClearAnswer takes an optional pick back. QuestionProgress, QuestionBack and QuestionNext step through several questions, and QuestionInvalid says why Next is refused. SubmitAnswers sends, SkipQuestions writes a skipped output the model reads, QuestionError reports a failed write, and QuestionReceipt takes the form's place once answered.

Capability: tools

Source: @slices.sh/ai-chat/src/headless/question-receipt.tsx

The askQuestions tool: a form the model asks the person to fill in. PartQuestion is the form, Questions hands the questionnaire, QuestionItem is one fieldset with Answer per choice and OtherAnswer plus QuestionOther for a free answer. ClearAnswer takes an optional pick back. QuestionProgress, QuestionBack and QuestionNext step through several questions, and QuestionInvalid says why Next is refused. SubmitAnswers sends, SkipQuestions writes a skipped output the model reads, QuestionError reports a failed write, and QuestionReceipt takes the form's place once answered.

Capability: tools

Source: @slices.sh/ai-chat/src/headless/question-error.tsx

On the last question only: before it, Next is the way on.

Capability: tools

Source: @slices.sh/ai-chat/src/headless/submit-answers.tsx

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.

Capability: tools

Source: @slices.sh/ai-chat/src/headless/skip-questions.tsx

The field of the "Other" row, inline with its control.

Capability: tools

Source: @slices.sh/ai-chat/src/headless/question-other.tsx

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.

Capability: tools

Source: @slices.sh/ai-chat/src/headless/other-answer.tsx

Takes a pick back, which a radio cannot do by itself. An optional question only: a required one is changed, not emptied.

Capability: tools

Source: @slices.sh/ai-chat/src/headless/clear-answer.tsx

"2 of 3": the place in a form of several questions, and nothing in a form of one.

Capability: tools

Source: @slices.sh/ai-chat/src/headless/question-progress.tsx

The askQuestions tool: a form the model asks the person to fill in. PartQuestion is the form, Questions hands the questionnaire, QuestionItem is one fieldset with Answer per choice and OtherAnswer plus QuestionOther for a free answer. ClearAnswer takes an optional pick back. QuestionProgress, QuestionBack and QuestionNext step through several questions, and QuestionInvalid says why Next is refused. SubmitAnswers sends, SkipQuestions writes a skipped output the model reads, QuestionError reports a failed write, and QuestionReceipt takes the form's place once answered.

Capability: tools

Source: @slices.sh/ai-chat/src/headless/question-back.tsx

Goes on once this question's answer is good; the last question has Send answers instead.

Capability: tools

Source: @slices.sh/ai-chat/src/headless/question-next.tsx

What is missing from one question's answer, once the person tried to go on without it.

Capability: tools

Source: @slices.sh/ai-chat/src/headless/question-invalid.tsx

One choice: a radio in a single question and a checkbox in a multiple one, so the kind is plain before anything is touched.

Capability: tools

Source: @slices.sh/ai-chat/src/headless/answer.tsx

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.

Capability: tools

Source: @slices.sh/ai-chat/src/headless/question-item.tsx

The askQuestions tool: a form the model asks the person to fill in. PartQuestion is the form, Questions hands the questionnaire, QuestionItem is one fieldset with Answer per choice and OtherAnswer plus QuestionOther for a free answer. ClearAnswer takes an optional pick back. QuestionProgress, QuestionBack and QuestionNext step through several questions, and QuestionInvalid says why Next is refused. SubmitAnswers sends, SkipQuestions writes a skipped output the model reads, QuestionError reports a failed write, and QuestionReceipt takes the form's place once answered.

Capability: tools

Source: @slices.sh/ai-chat/src/headless/questions.tsx

The askQuestions tool: a form the model asks the person to fill in. PartQuestion is the form, Questions hands the questionnaire, QuestionItem is one fieldset with Answer per choice and OtherAnswer plus QuestionOther for a free answer. ClearAnswer takes an optional pick back. QuestionProgress, QuestionBack and QuestionNext step through several questions, and QuestionInvalid says why Next is refused. SubmitAnswers sends, SkipQuestions writes a skipped output the model reads, QuestionError reports a failed write, and QuestionReceipt takes the form's place once answered.

Capability: tools

Source: @slices.sh/ai-chat/src/headless/part-question.tsx

Sources collects a message's source-url parts. References numbers and deduplicates every source of the message, and PartSource renders the first occurrence of one in place. SourceRoot scopes one source for SourceLink (a validated http(s) link) and SourceUnavailable. CitationRoot and its Trigger, Content, Title and Description are a popover for one citation; SourceSheetRoot and its parts are a modal list of all of them. Nothing renders for an answer without sources, which is most answers from most models.

Capability: sources

Source: @slices.sh/ai-chat/src/headless/citation-root.tsx

The skin's surface preserves the corresponding Motion primitive adapter.

Capability: sources

Source: @slices.sh/ai-chat/src/headless/citation-content.tsx

Sources collects a message's source-url parts. References numbers and deduplicates every source of the message, and PartSource renders the first occurrence of one in place. SourceRoot scopes one source for SourceLink (a validated http(s) link) and SourceUnavailable. CitationRoot and its Trigger, Content, Title and Description are a popover for one citation; SourceSheetRoot and its parts are a modal list of all of them. Nothing renders for an answer without sources, which is most answers from most models.

Capability: sources

Source: @slices.sh/ai-chat/src/headless/citation-trigger.tsx

Sources collects a message's source-url parts. References numbers and deduplicates every source of the message, and PartSource renders the first occurrence of one in place. SourceRoot scopes one source for SourceLink (a validated http(s) link) and SourceUnavailable. CitationRoot and its Trigger, Content, Title and Description are a popover for one citation; SourceSheetRoot and its parts are a modal list of all of them. Nothing renders for an answer without sources, which is most answers from most models.

Capability: sources

Source: @slices.sh/ai-chat/src/headless/citation-title.tsx

Sources collects a message's source-url parts. References numbers and deduplicates every source of the message, and PartSource renders the first occurrence of one in place. SourceRoot scopes one source for SourceLink (a validated http(s) link) and SourceUnavailable. CitationRoot and its Trigger, Content, Title and Description are a popover for one citation; SourceSheetRoot and its parts are a modal list of all of them. Nothing renders for an answer without sources, which is most answers from most models.

Capability: sources

Source: @slices.sh/ai-chat/src/headless/citation-description.tsx

Sources collects a message's source-url parts. References numbers and deduplicates every source of the message, and PartSource renders the first occurrence of one in place. SourceRoot scopes one source for SourceLink (a validated http(s) link) and SourceUnavailable. CitationRoot and its Trigger, Content, Title and Description are a popover for one citation; SourceSheetRoot and its parts are a modal list of all of them. Nothing renders for an answer without sources, which is most answers from most models.

Capability: sources

Source: @slices.sh/ai-chat/src/headless/source-sheet-root.tsx

The skin's surface preserves the corresponding Motion primitive adapter.

Capability: sources

Source: @slices.sh/ai-chat/src/headless/source-sheet-content.tsx

Sources collects a message's source-url parts. References numbers and deduplicates every source of the message, and PartSource renders the first occurrence of one in place. SourceRoot scopes one source for SourceLink (a validated http(s) link) and SourceUnavailable. CitationRoot and its Trigger, Content, Title and Description are a popover for one citation; SourceSheetRoot and its parts are a modal list of all of them. Nothing renders for an answer without sources, which is most answers from most models.

Capability: sources

Source: @slices.sh/ai-chat/src/headless/source-sheet-trigger.tsx

Sources collects a message's source-url parts. References numbers and deduplicates every source of the message, and PartSource renders the first occurrence of one in place. SourceRoot scopes one source for SourceLink (a validated http(s) link) and SourceUnavailable. CitationRoot and its Trigger, Content, Title and Description are a popover for one citation; SourceSheetRoot and its parts are a modal list of all of them. Nothing renders for an answer without sources, which is most answers from most models.

Capability: sources

Source: @slices.sh/ai-chat/src/headless/source-sheet-title.tsx

Sources collects a message's source-url parts. References numbers and deduplicates every source of the message, and PartSource renders the first occurrence of one in place. SourceRoot scopes one source for SourceLink (a validated http(s) link) and SourceUnavailable. CitationRoot and its Trigger, Content, Title and Description are a popover for one citation; SourceSheetRoot and its parts are a modal list of all of them. Nothing renders for an answer without sources, which is most answers from most models.

Capability: sources

Source: @slices.sh/ai-chat/src/headless/source-sheet-description.tsx

Sources collects a message's source-url parts. References numbers and deduplicates every source of the message, and PartSource renders the first occurrence of one in place. SourceRoot scopes one source for SourceLink (a validated http(s) link) and SourceUnavailable. CitationRoot and its Trigger, Content, Title and Description are a popover for one citation; SourceSheetRoot and its parts are a modal list of all of them. Nothing renders for an answer without sources, which is most answers from most models.

Capability: sources

Source: @slices.sh/ai-chat/src/headless/source-sheet-close.tsx

URL and document references in native transcript order, deduplicated by source identity.

Capability: sources

Source: @slices.sh/ai-chat/src/headless/references.tsx

Sources collects a message's source-url parts. References numbers and deduplicates every source of the message, and PartSource renders the first occurrence of one in place. SourceRoot scopes one source for SourceLink (a validated http(s) link) and SourceUnavailable. CitationRoot and its Trigger, Content, Title and Description are a popover for one citation; SourceSheetRoot and its parts are a modal list of all of them. Nothing renders for an answer without sources, which is most answers from most models.

Capability: sources

Source: @slices.sh/ai-chat/src/headless/part-source.tsx

Sources collects a message's source-url parts. References numbers and deduplicates every source of the message, and PartSource renders the first occurrence of one in place. SourceRoot scopes one source for SourceLink (a validated http(s) link) and SourceUnavailable. CitationRoot and its Trigger, Content, Title and Description are a popover for one citation; SourceSheetRoot and its parts are a modal list of all of them. Nothing renders for an answer without sources, which is most answers from most models.

Capability: sources

Source: @slices.sh/ai-chat/src/headless/source-root.tsx

Sources collects a message's source-url parts. References numbers and deduplicates every source of the message, and PartSource renders the first occurrence of one in place. SourceRoot scopes one source for SourceLink (a validated http(s) link) and SourceUnavailable. CitationRoot and its Trigger, Content, Title and Description are a popover for one citation; SourceSheetRoot and its parts are a modal list of all of them. Nothing renders for an answer without sources, which is most answers from most models.

Capability: sources

Source: @slices.sh/ai-chat/src/headless/source-link.tsx

Sources collects a message's source-url parts. References numbers and deduplicates every source of the message, and PartSource renders the first occurrence of one in place. SourceRoot scopes one source for SourceLink (a validated http(s) link) and SourceUnavailable. CitationRoot and its Trigger, Content, Title and Description are a popover for one citation; SourceSheetRoot and its parts are a modal list of all of them. Nothing renders for an answer without sources, which is most answers from most models.

Capability: sources

Source: @slices.sh/ai-chat/src/headless/source-unavailable.tsx

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.

Capability: sources

Source: @slices.sh/ai-chat/src/headless/sources.tsx

PartFile gates a file part. FileRoot validates one FileUIPart and owns its load error. FileKind gates by media kind, FileImage, FileAudio and FileVideo render the media with the source locked, FileLink is an http(s) link only, and FileUnavailable covers a bad source or a failed load. These parts display files the conversation already holds. Sending files is Composer's attachments field, and grouped previews are the chat-media parts.

Capability: files

Source: @slices.sh/ai-chat/src/headless/file-root.tsx

PartFile gates a file part. FileRoot validates one FileUIPart and owns its load error. FileKind gates by media kind, FileImage, FileAudio and FileVideo render the media with the source locked, FileLink is an http(s) link only, and FileUnavailable covers a bad source or a failed load. These parts display files the conversation already holds. Sending files is Composer's attachments field, and grouped previews are the chat-media parts.

Capability: files

Source: @slices.sh/ai-chat/src/headless/file-kind-gate.tsx

PartFile gates a file part. FileRoot validates one FileUIPart and owns its load error. FileKind gates by media kind, FileImage, FileAudio and FileVideo render the media with the source locked, FileLink is an http(s) link only, and FileUnavailable covers a bad source or a failed load. These parts display files the conversation already holds. Sending files is Composer's attachments field, and grouped previews are the chat-media parts.

Capability: files

Source: @slices.sh/ai-chat/src/headless/file-img.tsx

PartFile gates a file part. FileRoot validates one FileUIPart and owns its load error. FileKind gates by media kind, FileImage, FileAudio and FileVideo render the media with the source locked, FileLink is an http(s) link only, and FileUnavailable covers a bad source or a failed load. These parts display files the conversation already holds. Sending files is Composer's attachments field, and grouped previews are the chat-media parts.

Capability: files

Source: @slices.sh/ai-chat/src/headless/file-audio.tsx

PartFile gates a file part. FileRoot validates one FileUIPart and owns its load error. FileKind gates by media kind, FileImage, FileAudio and FileVideo render the media with the source locked, FileLink is an http(s) link only, and FileUnavailable covers a bad source or a failed load. These parts display files the conversation already holds. Sending files is Composer's attachments field, and grouped previews are the chat-media parts.

Capability: files

Source: @slices.sh/ai-chat/src/headless/file-video.tsx

Data and blob media render in their element; only web links navigate away.

Capability: files

Source: @slices.sh/ai-chat/src/headless/file-link.tsx

PartFile gates a file part. FileRoot validates one FileUIPart and owns its load error. FileKind gates by media kind, FileImage, FileAudio and FileVideo render the media with the source locked, FileLink is an http(s) link only, and FileUnavailable covers a bad source or a failed load. These parts display files the conversation already holds. Sending files is Composer's attachments field, and grouped previews are the chat-media parts.

Capability: files

Source: @slices.sh/ai-chat/src/headless/file-unavailable.tsx

A native file stays visible in history even when the rich media viewer is not installed.

Capability: files

Source: @slices.sh/ai-chat/src/headless/part-file.tsx

BranchNavigation, BranchPrevious, BranchNext and BranchPage ({ index, total }) step through the alternatives Regenerate and edits create. MessageEditRoot wraps a message's content, and MessageReading and MessageEditing gate the two modes. Edit opens the editor. Editing a sent message is chat behaviour, so the editor stays a chat part: in v2 MessageEditor provides its own sink (whenBusy "hold", submit creates a branch) and renders a Composer with the message's text as defaultValue. EditedInput and SaveEdit map to Composer.Input and Composer.Submit inside it. EditedAttachments exposes the files the edited message keeps, and CancelEdit leaves history unchanged.

Source: @slices.sh/ai-chat/src/headless/edited-attachments.tsx

BranchNavigation, BranchPrevious, BranchNext and BranchPage ({ index, total }) step through the alternatives Regenerate and edits create. MessageEditRoot wraps a message's content, and MessageReading and MessageEditing gate the two modes. Edit opens the editor. Editing a sent message is chat behaviour, so the editor stays a chat part: in v2 MessageEditor provides its own sink (whenBusy "hold", submit creates a branch) and renders a Composer with the message's text as defaultValue. EditedInput and SaveEdit map to Composer.Input and Composer.Submit inside it. EditedAttachments exposes the files the edited message keeps, and CancelEdit leaves history unchanged.

Source: @slices.sh/ai-chat/src/headless/branch-navigation.tsx

BranchNavigation, BranchPrevious, BranchNext and BranchPage ({ index, total }) step through the alternatives Regenerate and edits create. MessageEditRoot wraps a message's content, and MessageReading and MessageEditing gate the two modes. Edit opens the editor. Editing a sent message is chat behaviour, so the editor stays a chat part: in v2 MessageEditor provides its own sink (whenBusy "hold", submit creates a branch) and renders a Composer with the message's text as defaultValue. EditedInput and SaveEdit map to Composer.Input and Composer.Submit inside it. EditedAttachments exposes the files the edited message keeps, and CancelEdit leaves history unchanged.

Source: @slices.sh/ai-chat/src/headless/branch-previous.tsx

BranchNavigation, BranchPrevious, BranchNext and BranchPage ({ index, total }) step through the alternatives Regenerate and edits create. MessageEditRoot wraps a message's content, and MessageReading and MessageEditing gate the two modes. Edit opens the editor. Editing a sent message is chat behaviour, so the editor stays a chat part: in v2 MessageEditor provides its own sink (whenBusy "hold", submit creates a branch) and renders a Composer with the message's text as defaultValue. EditedInput and SaveEdit map to Composer.Input and Composer.Submit inside it. EditedAttachments exposes the files the edited message keeps, and CancelEdit leaves history unchanged.

Source: @slices.sh/ai-chat/src/headless/branch-next.tsx

BranchNavigation, BranchPrevious, BranchNext and BranchPage ({ index, total }) step through the alternatives Regenerate and edits create. MessageEditRoot wraps a message's content, and MessageReading and MessageEditing gate the two modes. Edit opens the editor. Editing a sent message is chat behaviour, so the editor stays a chat part: in v2 MessageEditor provides its own sink (whenBusy "hold", submit creates a branch) and renders a Composer with the message's text as defaultValue. EditedInput and SaveEdit map to Composer.Input and Composer.Submit inside it. EditedAttachments exposes the files the edited message keeps, and CancelEdit leaves history unchanged.

Source: @slices.sh/ai-chat/src/headless/branch-page.tsx

BranchNavigation, BranchPrevious, BranchNext and BranchPage ({ index, total }) step through the alternatives Regenerate and edits create. MessageEditRoot wraps a message's content, and MessageReading and MessageEditing gate the two modes. Edit opens the editor. Editing a sent message is chat behaviour, so the editor stays a chat part: in v2 MessageEditor provides its own sink (whenBusy "hold", submit creates a branch) and renders a Composer with the message's text as defaultValue. EditedInput and SaveEdit map to Composer.Input and Composer.Submit inside it. EditedAttachments exposes the files the edited message keeps, and CancelEdit leaves history unchanged.

Source: @slices.sh/ai-chat/src/headless/message-edit-root.tsx

BranchNavigation, BranchPrevious, BranchNext and BranchPage ({ index, total }) step through the alternatives Regenerate and edits create. MessageEditRoot wraps a message's content, and MessageReading and MessageEditing gate the two modes. Edit opens the editor. Editing a sent message is chat behaviour, so the editor stays a chat part: in v2 MessageEditor provides its own sink (whenBusy "hold", submit creates a branch) and renders a Composer with the message's text as defaultValue. EditedInput and SaveEdit map to Composer.Input and Composer.Submit inside it. EditedAttachments exposes the files the edited message keeps, and CancelEdit leaves history unchanged.

Source: @slices.sh/ai-chat/src/headless/message-editing.tsx

BranchNavigation, BranchPrevious, BranchNext and BranchPage ({ index, total }) step through the alternatives Regenerate and edits create. MessageEditRoot wraps a message's content, and MessageReading and MessageEditing gate the two modes. Edit opens the editor. Editing a sent message is chat behaviour, so the editor stays a chat part: in v2 MessageEditor provides its own sink (whenBusy "hold", submit creates a branch) and renders a Composer with the message's text as defaultValue. EditedInput and SaveEdit map to Composer.Input and Composer.Submit inside it. EditedAttachments exposes the files the edited message keeps, and CancelEdit leaves history unchanged.

Source: @slices.sh/ai-chat/src/headless/message-reading.tsx

BranchNavigation, BranchPrevious, BranchNext and BranchPage ({ index, total }) step through the alternatives Regenerate and edits create. MessageEditRoot wraps a message's content, and MessageReading and MessageEditing gate the two modes. Edit opens the editor. Editing a sent message is chat behaviour, so the editor stays a chat part: in v2 MessageEditor provides its own sink (whenBusy "hold", submit creates a branch) and renders a Composer with the message's text as defaultValue. EditedInput and SaveEdit map to Composer.Input and Composer.Submit inside it. EditedAttachments exposes the files the edited message keeps, and CancelEdit leaves history unchanged.

Source: @slices.sh/ai-chat/src/headless/edit.tsx

BranchNavigation, BranchPrevious, BranchNext and BranchPage ({ index, total }) step through the alternatives Regenerate and edits create. MessageEditRoot wraps a message's content, and MessageReading and MessageEditing gate the two modes. Edit opens the editor. Editing a sent message is chat behaviour, so the editor stays a chat part: in v2 MessageEditor provides its own sink (whenBusy "hold", submit creates a branch) and renders a Composer with the message's text as defaultValue. EditedInput and SaveEdit map to Composer.Input and Composer.Submit inside it. EditedAttachments exposes the files the edited message keeps, and CancelEdit leaves history unchanged.

Source: @slices.sh/ai-chat/src/headless/message-editor.tsx

BranchNavigation, BranchPrevious, BranchNext and BranchPage ({ index, total }) step through the alternatives Regenerate and edits create. MessageEditRoot wraps a message's content, and MessageReading and MessageEditing gate the two modes. Edit opens the editor. Editing a sent message is chat behaviour, so the editor stays a chat part: in v2 MessageEditor provides its own sink (whenBusy "hold", submit creates a branch) and renders a Composer with the message's text as defaultValue. EditedInput and SaveEdit map to Composer.Input and Composer.Submit inside it. EditedAttachments exposes the files the edited message keeps, and CancelEdit leaves history unchanged.

Source: @slices.sh/ai-chat/src/headless/edited-input.tsx

BranchNavigation, BranchPrevious, BranchNext and BranchPage ({ index, total }) step through the alternatives Regenerate and edits create. MessageEditRoot wraps a message's content, and MessageReading and MessageEditing gate the two modes. Edit opens the editor. Editing a sent message is chat behaviour, so the editor stays a chat part: in v2 MessageEditor provides its own sink (whenBusy "hold", submit creates a branch) and renders a Composer with the message's text as defaultValue. EditedInput and SaveEdit map to Composer.Input and Composer.Submit inside it. EditedAttachments exposes the files the edited message keeps, and CancelEdit leaves history unchanged.

Source: @slices.sh/ai-chat/src/headless/cancel-edit.tsx

BranchNavigation, BranchPrevious, BranchNext and BranchPage ({ index, total }) step through the alternatives Regenerate and edits create. MessageEditRoot wraps a message's content, and MessageReading and MessageEditing gate the two modes. Edit opens the editor. Editing a sent message is chat behaviour, so the editor stays a chat part: in v2 MessageEditor provides its own sink (whenBusy "hold", submit creates a branch) and renders a Composer with the message's text as defaultValue. EditedInput and SaveEdit map to Composer.Input and Composer.Submit inside it. EditedAttachments exposes the files the edited message keeps, and CancelEdit leaves history unchanged.

Source: @slices.sh/ai-chat/src/headless/save-edit.tsx

Completed-turn actions stay available on the latest answer and to keyboard/touch readers.

Source: @slices.sh/ai-chat/src/headless/message-footer.tsx

Puts this message's text on the clipboard, and says so. The text and nothing else: a reader copying an answer wants the answer, not the reasoning trace above it or the JSON of a tool call beside it. Runs of prose a tool call separated stay separate paragraphs.

Source: @slices.sh/ai-chat/src/headless/copy.tsx

MessageFooter holds a turn's actions and is data-active on the latest answer. Copy puts the text parts on the clipboard. ReadAloud speaks the answer. Regenerate renders only on the last assistant message. FeedbackRoot, Feedback rating="up" or "down" and FeedbackError call onFeedback and render nothing without it.

Source: @slices.sh/ai-chat/src/headless/feedback-root.tsx

MessageFooter holds a turn's actions and is data-active on the latest answer. Copy puts the text parts on the clipboard. ReadAloud speaks the answer. Regenerate renders only on the last assistant message. FeedbackRoot, Feedback rating="up" or "down" and FeedbackError call onFeedback and render nothing without it.

Source: @slices.sh/ai-chat/src/headless/feedback.tsx

MessageFooter holds a turn's actions and is data-active on the latest answer. Copy puts the text parts on the clipboard. ReadAloud speaks the answer. Regenerate renders only on the last assistant message. FeedbackRoot, Feedback rating="up" or "down" and FeedbackError call onFeedback and render nothing without it.

Source: @slices.sh/ai-chat/src/headless/feedback-error.tsx

MessageFooter holds a turn's actions and is data-active on the latest answer. Copy puts the text parts on the clipboard. ReadAloud speaks the answer. Regenerate renders only on the last assistant message. FeedbackRoot, Feedback rating="up" or "down" and FeedbackError call onFeedback and render nothing without it.

Source: @slices.sh/ai-chat/src/headless/read-aloud.tsx

An older answer is safe to regenerate once its entire tail is preserved as a branch.

Source: @slices.sh/ai-chat/src/headless/regenerate.tsx

Settings gates a toolbar that exists only when the config publishes a catalog. Models hands the models on offer and ModelPicker is a native select. OptionalTools hands the catalog, or with selected the active subset, and ToggleTool tool={id} is a pressed/unpressed button. Choices belong to this conversation and the server checks every one.

Source: @slices.sh/ai-chat/src/headless/toggle-tool.tsx

Settings gates a toolbar that exists only when the config publishes a catalog. Models hands the models on offer and ModelPicker is a native select. OptionalTools hands the catalog, or with selected the active subset, and ToggleTool tool={id} is a pressed/unpressed button. Choices belong to this conversation and the server checks every one.

Source: @slices.sh/ai-chat/src/headless/optional-tools.tsx

Settings gates a toolbar that exists only when the config publishes a catalog. Models hands the models on offer and ModelPicker is a native select. OptionalTools hands the catalog, or with selected the active subset, and ToggleTool tool={id} is a pressed/unpressed button. Choices belong to this conversation and the server checks every one.

Source: @slices.sh/ai-chat/src/headless/model-picker.tsx

Settings gates a toolbar that exists only when the config publishes a catalog. Models hands the models on offer and ModelPicker is a native select. OptionalTools hands the catalog, or with selected the active subset, and ToggleTool tool={id} is a pressed/unpressed button. Choices belong to this conversation and the server checks every one.

Source: @slices.sh/ai-chat/src/headless/models.tsx

Settings gates a toolbar that exists only when the config publishes a catalog. Models hands the models on offer and ModelPicker is a native select. OptionalTools hands the catalog, or with selected the active subset, and ToggleTool tool={id} is a pressed/unpressed button. Choices belong to this conversation and the server checks every one.

Source: @slices.sh/ai-chat/src/headless/settings.tsx

The queue belongs to the sink: with whenBusy "queue", Chat.Root accepts a message while a reply streams and holds it until the chat is ready. These parts show it. Queued hands { count, waitingFor } where waitingFor is "turn", "question" or "approval", and belongs inside a region mounted from the first render. QueueItems repeats the waiting messages, QueueItem is one, QueuePreview shows its text and files. EditQueued opens QueueEditing with QueuedInput, SaveQueued and CancelQueueEdit. CancelQueued drops one. SendNow stops the running answer and sends this one first; with a question open, it skips the question and sends the message as the reply.

Source: @slices.sh/ai-chat/src/headless/send-now.tsx

The queue belongs to the sink: with whenBusy "queue", Chat.Root accepts a message while a reply streams and holds it until the chat is ready. These parts show it. Queued hands { count, waitingFor } where waitingFor is "turn", "question" or "approval", and belongs inside a region mounted from the first render. QueueItems repeats the waiting messages, QueueItem is one, QueuePreview shows its text and files. EditQueued opens QueueEditing with QueuedInput, SaveQueued and CancelQueueEdit. CancelQueued drops one. SendNow stops the running answer and sends this one first; with a question open, it skips the question and sends the message as the reply.

Source: @slices.sh/ai-chat/src/headless/cancel-queued.tsx

The queue belongs to the sink: with whenBusy "queue", Chat.Root accepts a message while a reply streams and holds it until the chat is ready. These parts show it. Queued hands { count, waitingFor } where waitingFor is "turn", "question" or "approval", and belongs inside a region mounted from the first render. QueueItems repeats the waiting messages, QueueItem is one, QueuePreview shows its text and files. EditQueued opens QueueEditing with QueuedInput, SaveQueued and CancelQueueEdit. CancelQueued drops one. SendNow stops the running answer and sends this one first; with a question open, it skips the question and sends the message as the reply.

Source: @slices.sh/ai-chat/src/headless/cancel-queue-edit.tsx

The queue belongs to the sink: with whenBusy "queue", Chat.Root accepts a message while a reply streams and holds it until the chat is ready. These parts show it. Queued hands { count, waitingFor } where waitingFor is "turn", "question" or "approval", and belongs inside a region mounted from the first render. QueueItems repeats the waiting messages, QueueItem is one, QueuePreview shows its text and files. EditQueued opens QueueEditing with QueuedInput, SaveQueued and CancelQueueEdit. CancelQueued drops one. SendNow stops the running answer and sends this one first; with a question open, it skips the question and sends the message as the reply.

Source: @slices.sh/ai-chat/src/headless/save-queued.tsx

The queue belongs to the sink: with whenBusy "queue", Chat.Root accepts a message while a reply streams and holds it until the chat is ready. These parts show it. Queued hands { count, waitingFor } where waitingFor is "turn", "question" or "approval", and belongs inside a region mounted from the first render. QueueItems repeats the waiting messages, QueueItem is one, QueuePreview shows its text and files. EditQueued opens QueueEditing with QueuedInput, SaveQueued and CancelQueueEdit. CancelQueued drops one. SendNow stops the running answer and sends this one first; with a question open, it skips the question and sends the message as the reply.

Source: @slices.sh/ai-chat/src/headless/edit-queued.tsx

The queue belongs to the sink: with whenBusy "queue", Chat.Root accepts a message while a reply streams and holds it until the chat is ready. These parts show it. Queued hands { count, waitingFor } where waitingFor is "turn", "question" or "approval", and belongs inside a region mounted from the first render. QueueItems repeats the waiting messages, QueueItem is one, QueuePreview shows its text and files. EditQueued opens QueueEditing with QueuedInput, SaveQueued and CancelQueueEdit. CancelQueued drops one. SendNow stops the running answer and sends this one first; with a question open, it skips the question and sends the message as the reply.

Source: @slices.sh/ai-chat/src/headless/queued-input.tsx

The queue belongs to the sink: with whenBusy "queue", Chat.Root accepts a message while a reply streams and holds it until the chat is ready. These parts show it. Queued hands { count, waitingFor } where waitingFor is "turn", "question" or "approval", and belongs inside a region mounted from the first render. QueueItems repeats the waiting messages, QueueItem is one, QueuePreview shows its text and files. EditQueued opens QueueEditing with QueuedInput, SaveQueued and CancelQueueEdit. CancelQueued drops one. SendNow stops the running answer and sends this one first; with a question open, it skips the question and sends the message as the reply.

Source: @slices.sh/ai-chat/src/headless/queue-editing.tsx

The queue belongs to the sink: with whenBusy "queue", Chat.Root accepts a message while a reply streams and holds it until the chat is ready. These parts show it. Queued hands { count, waitingFor } where waitingFor is "turn", "question" or "approval", and belongs inside a region mounted from the first render. QueueItems repeats the waiting messages, QueueItem is one, QueuePreview shows its text and files. EditQueued opens QueueEditing with QueuedInput, SaveQueued and CancelQueueEdit. CancelQueued drops one. SendNow stops the running answer and sends this one first; with a question open, it skips the question and sends the message as the reply.

Source: @slices.sh/ai-chat/src/headless/queue-preview.tsx

The queue belongs to the sink: with whenBusy "queue", Chat.Root accepts a message while a reply streams and holds it until the chat is ready. These parts show it. Queued hands { count, waitingFor } where waitingFor is "turn", "question" or "approval", and belongs inside a region mounted from the first render. QueueItems repeats the waiting messages, QueueItem is one, QueuePreview shows its text and files. EditQueued opens QueueEditing with QueuedInput, SaveQueued and CancelQueueEdit. CancelQueued drops one. SendNow stops the running answer and sends this one first; with a question open, it skips the question and sends the message as the reply.

Source: @slices.sh/ai-chat/src/headless/queue-item.tsx

The queue belongs to the sink: with whenBusy "queue", Chat.Root accepts a message while a reply streams and holds it until the chat is ready. These parts show it. Queued hands { count, waitingFor } where waitingFor is "turn", "question" or "approval", and belongs inside a region mounted from the first render. QueueItems repeats the waiting messages, QueueItem is one, QueuePreview shows its text and files. EditQueued opens QueueEditing with QueuedInput, SaveQueued and CancelQueueEdit. CancelQueued drops one. SendNow stops the running answer and sends this one first; with a question open, it skips the question and sends the message as the reply.

Source: @slices.sh/ai-chat/src/headless/queue-items.tsx

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.

Source: @slices.sh/ai-chat/src/headless/queued.tsx

Root scopes one message and registers its media with Quick Look, so previous and next move through this message's files. ImageRun gates a run of consecutive images and hands { images, remaining }. More count={n} renders only when a run holds more images than are drawn, for a +N tile that opens the rest. OtherFile gates any other file and hands { file, id } so it keeps its name and media type, with a native player for audio and video.

Source: @slices.sh/chat-media/src/headless/root.tsx

Root scopes one message and registers its media with Quick Look, so previous and next move through this message's files. ImageRun gates a run of consecutive images and hands { images, remaining }. More count={n} renders only when a run holds more images than are drawn, for a +N tile that opens the rest. OtherFile gates any other file and hands { file, id } so it keeps its name and media type, with a native player for audio and video.

Source: @slices.sh/chat-media/src/headless/image-run.tsx

Root scopes one message and registers its media with Quick Look, so previous and next move through this message's files. ImageRun gates a run of consecutive images and hands { images, remaining }. More count={n} renders only when a run holds more images than are drawn, for a +N tile that opens the rest. OtherFile gates any other file and hands { file, id } so it keeps its name and media type, with a native player for audio and video.

Source: @slices.sh/chat-media/src/headless/other-file.tsx

Root scopes one message and registers its media with Quick Look, so previous and next move through this message's files. ImageRun gates a run of consecutive images and hands { images, remaining }. More count={n} renders only when a run holds more images than are drawn, for a +N tile that opens the rest. OtherFile gates any other file and hands { file, id } so it keeps its name and media type, with a native player for audio and video.

Source: @slices.sh/chat-media/src/headless/more.tsx

Model output as markdown, safely, while it is still arriving. Two of these are not things to write by hand, which is why there is a dependency here at all. Completing half-streamed markdown: a fence, a bold run or a link that the next token will finish must render as what it is becoming, or every answer flickers through its own source. And sanitising: this text came from a model that reads the web, so a link is untrusted input and an `<img onerror>` is a real thing to receive — the renderer hardens the tree and this narrows what a URL may start with. Nothing here is styled: the caller's `components` and `className` are the looks, so there is no stylesheet to import and no class that Tailwind was never shown.

Source: @slices.sh/markdown/src/markdown-view.tsx

Missing storage leaves a fully functional text composer with no attachment controls.

Source: @slices.sh/chat-attachments/src/headless/attachments-root.tsx

ChatAttachments.Available conditionally renders its children.

Source: @slices.sh/chat-attachments/src/headless/attachments-available.tsx

Paste and drop share the upload guard and queue.

Source: @slices.sh/chat-attachments/src/headless/attachment-surface.tsx

ChatAttachments.Error conditionally renders its children.

Source: @slices.sh/chat-attachments/src/headless/attachment-error.tsx

ChatAttachments.Retry renders a button element.

Source: @slices.sh/chat-attachments/src/headless/retry-attachments.tsx

The existing dictation engine writes into the same draft as the native chat composer.

Source: @slices.sh/ai-chat/src/headless/chat-dictation/root.tsx

Dictation.Field remains the sole owner of editing and caret restoration.

Source: @slices.sh/ai-chat/src/headless/chat-dictation/input.tsx

Keep AnimatePresence mounted across the recording-to-text transition.

Source: @slices.sh/ai-chat/src/headless/chat-dictation/voice.tsx

Keep the actual field mounted so its caret owner survives the voice surface.

Source: @slices.sh/ai-chat/src/headless/chat-dictation/text.tsx

ChatDictation.Confirm renders a button element.

Source: @slices.sh/ai-chat/src/headless/chat-dictation/confirm.tsx

The queue, its limits, and its field registration when it has a name inside a Composer.

Source: @slices.sh/file-storage/src/headless/upload-root.tsx