HextaUI

La vue de conversation d’un chat IA. Gère les réponses qui streament, se modifient et se relancent, et les versions d’une réponse entre lesquelles basculer.

Catégorie
IA
Composants utilisés
10
Fichiers
4
Exemples d’utilisation
2
Accès
HextaUI Pro (55 blocs)
Code mis à jour
Open in new tab

Inclus dans HextaUI Pro, les 55 blocs, $79 en une fois, Comparer les offres

Chat Thread est la conversation autour du champ de saisie : vos messages, les réponses du modèle et ce que vous pouvez en faire. Il démarre avec votre état vide et le champ de saisie centré, puis ancre ce champ en bas dès qu’il y a des messages, sans le remonter, si bien que le focus et le brouillon restent en place.

Le message que vous venez d’envoyer remonte en haut pendant que sa réponse arrive en dessous, et la vue suit le nouveau texte jusqu’à ce que vous défiliez ailleurs. Un rail de points de repère à droite permet de sauter d’un de vos messages à l’autre, avec un aperçu au survol. L’historique plus ancien se charge par le haut sans que la vue bouge.

Survolez un message pour le copier, le modifier ou réessayer. Les modifications et nouveaux essais deviennent des versions entre lesquelles vous pouvez basculer, et rien n’est perdu. Les réponses en échec proposent Try again, les réponses interrompues le disent, et le pouce levé ou baissé se donne en un clic. Dans chaque réponse, Reasoning, ToolCalls et Markdown des autres blocks s’insèrent directement.

Les checkpoints avant vos messages sont des points de restauration. Restore dit exactement ce qui disparaît, par exemple « Removes this message and 3 later messages, and reverts 3 files », atténue ces messages pendant que vous décidez et vous laisse garder votre code avec Conversation only. Les messages suivants se replient, votre message revient dans le compositeur pour être modifié, et un toast propose Undo.

  1. Procurez-vous HextaUI Pro

    Un seul paiement débloque tous les blocs, y compris les prochains. Voir les tarifs.

  2. Ajouter le registre Pro à components.json

    components.json
    {
      "registries": {
        "@hextaui-pro": {
          "url": "https://hextaui.com/r/pro/{name}.json",
          "headers": {
            "Authorization": "Bearer ${HEXTAUI_PRO_TOKEN}"
          }
        }
      }
    }
  3. Ajouter votre token

    Créez un token sur votre page de compte et placez-le dans .env.local sous le nom HEXTAUI_PRO_TOKEN.

  4. Ajouter le block

    pnpm dlx shadcn@latest add @hextaui-pro/chat-thread

Avec AI SDK

Associez les messages de useChat au fil. Les parts de raisonnement vont à Reasoning, les parts d’outil à ToolCalls et le texte à Markdown. Épinglez le dernier message de l’utilisateur, utilisez regenerate pour Try again, et renvoyez une modification à partir de ce point.

"use client"

import { useChat } from "@ai-sdk/react"
import { getToolName, isToolUIPart, type UIMessage } from "ai"

import { PromptInput, PromptInputActions, PromptInputBody, PromptInputSubmit, PromptInputTextarea } from "../prompt-input/prompt-input"
import { Reasoning } from "../thinking/reasoning"
import { ToolCalls } from "../tool-calls/tool-group"
import { getToolPartStatus } from "../tool-calls/tool-part"
import { Markdown } from "../markdown/markdown"
import { ChatAssistantMessage, ChatThread, ChatUserMessage } from "@/components/blocks/chat-thread/chat-thread"

function textOf(message: UIMessage) {
  return message.parts.flatMap((part) => (part.type === "text" ? [part.text] : [])).join("")
}

export function Chat() {
  const { messages, status, sendMessage, regenerate, stop, setMessages } = useChat()
  const busy = status === "submitted" || status === "streaming"
  const lastUser = messages.findLastIndex((message) => message.role === "user")

  return (
    <ChatThread
      busy={busy}
      composer={
        <PromptInput status={status} onStop={stop} onSubmit={({ text }) => sendMessage({ text })}>
          <PromptInputBody>
            <PromptInputTextarea />
            <PromptInputActions>
              <PromptInputSubmit />
            </PromptInputActions>
          </PromptInputBody>
        </PromptInput>
      }
    >
      {messages.map((message, index) => {
        const last = index === messages.length - 1
        if (message.role === "user") {
          return (
            <ChatUserMessage
              key={message.id}
              id={message.id}
              text={textOf(message)}
              pin={index === lastUser}
              onEdit={(text) => {
                setMessages(messages.slice(0, index))
                sendMessage({ text })
              }}
            />
          )
        }
        const reasoning = message.parts.flatMap((part) => (part.type === "reasoning" ? [part.text] : [])).join("\n\n")
        const tools = message.parts.filter(isToolUIPart)
        const streaming = last && busy
        return (
          <ChatAssistantMessage
            key={message.id}
            id={message.id}
            text={textOf(message)}
            streaming={streaming}
            last={last}
            error={last && status === "error" ? "Something went wrong." : null}
            onRetry={last ? () => regenerate() : undefined}
          >
            {reasoning ? <Reasoning text={reasoning} streaming={streaming && !textOf(message)} /> : null}
            {tools.length > 0 ? (
              <ToolCalls
                calls={tools.map((part) => ({
                  id: part.toolCallId,
                  name: getToolName(part),
                  status: getToolPartStatus(part, { stopped: !streaming }),
                }))}
              />
            ) : null}
            <Markdown
              text={textOf(message)}
              streaming={streaming}
              sources={message.parts.flatMap((part) =>
                part.type === "source-url"
                  ? [{ id: part.sourceId, url: part.url, title: part.title ?? part.url }]
                  : []
              )}
            />
          </ChatAssistantMessage>
        )
      })}
    </ChatThread>
  )
}

Points de restauration

Écrivez un part data-checkpoint ({ id, label, files }) depuis le serveur quand une réponse commence, puis réécrivez-le avec le même id quand des fichiers changent. getCheckpoints les associe aux messages utilisateur, restoreMessages découpe l’historique, et le undoRestore renvoyé rétablit tout.

"use client"

import * as React from "react"
import { useChat } from "@ai-sdk/react"
import type { UIMessage } from "ai"

import { PromptInput, PromptInputActions, PromptInputBody, PromptInputSubmit, PromptInputTextarea } from "../prompt-input/prompt-input"
import { Markdown } from "../markdown/markdown"
import {
  ChatAssistantMessage,
  ChatThread,
  ChatUserMessage,
  type ChatCheckpointData,
  type ChatRestoreOptions,
} from "@/components/blocks/chat-thread/chat-thread"
import { getCheckpoints, restoreMessages } from "@/components/blocks/chat-thread/checkpoints"

type AgentMessage = UIMessage<unknown, { checkpoint: ChatCheckpointData }>

function textOf(message: AgentMessage) {
  return message.parts.flatMap((part) => (part.type === "text" ? [part.text] : [])).join("")
}

function revertFiles(checkpointId: string, undo = false) {
  return fetch(`/api/checkpoints/${checkpointId}`, { method: undo ? "DELETE" : "POST" })
}

export function Chat() {
  const { messages, status, sendMessage, stop, setMessages } = useChat<AgentMessage>()
  const [input, setInput] = React.useState("")
  const busy = status === "submitted" || status === "streaming"
  const checkpoints = getCheckpoints(messages)

  const restore = (checkpointId: string, { code }: ChatRestoreOptions) => {
    const before = messages
    const draft = input
    const { kept, removed } = restoreMessages(messages, checkpointId)
    setMessages(kept)
    setInput(removed[0] ? textOf(removed[0]) : "")
    if (code) void revertFiles(checkpointId)

    return function undoRestore() {
      setMessages(before)
      setInput(draft)
      if (code) void revertFiles(checkpointId, true)
    }
  }

  return (
    <ChatThread
      busy={busy}
      onRestore={busy ? undefined : restore}
      composer={
        <PromptInput
          value={input}
          onValueChange={setInput}
          status={status}
          onStop={stop}
          onSubmit={({ text }) => sendMessage({ text })}
        >
          <PromptInputBody>
            <PromptInputTextarea />
            <PromptInputActions>
              <PromptInputSubmit />
            </PromptInputActions>
          </PromptInputBody>
        </PromptInput>
      }
    >
      {messages.map((message, index) =>
        message.role === "user" ? (
          <ChatUserMessage
            key={message.id}
            id={message.id}
            text={textOf(message)}
            checkpoint={checkpoints.get(message.id)}
          />
        ) : (
          <ChatAssistantMessage
            key={message.id}
            id={message.id}
            text={textOf(message)}
            streaming={busy && index === messages.length - 1}
            last={index === messages.length - 1}
          >
            <Markdown text={textOf(message)} streaming={busy && index === messages.length - 1} />
          </ChatAssistantMessage>
        )
      )}
    </ChatThread>
  )
}

Anatomie

Les parties à composer, de l’extérieur vers l’intérieur.

PartieDescription
ChatThreadLe cadre : scroller, points de repère, état vide et emplacement du champ de saisie.
ChatUserMessageVotre message : pièces jointes, bulle, heure, versions, copie et modification.
ChatAssistantMessageUne réponse. Placez-y Reasoning, ToolCalls et Markdown ; elle ajoute les actions et les états d’erreur et d’arrêt.
ChatCheckpointUn point de restauration avant un message de l’utilisateur : une ligne discrète avec les fichiers modifiés par ce tour, et Restore avec sa confirmation. ChatUserMessage l’affiche à partir de checkpoint.
ChatDividerUne ligne libellée entre des groupes de messages.
ChatAttachments, ChatAction, ChatCopy, ChatBranchSwitch, ChatEditorLes éléments utilisés par les messages, exportés pour des mises en page personnalisées.
PropTypePar défaut
childrenMessages et séparateurs, dans l’ordre.
ReactNode–
composerGénéralement Prompt Input. Centré quand c’est vide, ancré en bas sinon.
ReactNode–
emptyAffiché au-dessus du champ de saisie quand il n’y a aucun message.
ReactNode–
busyMarque la conversation comme occupée pour les technologies d’assistance pendant qu’une réponse arrive en streaming.
booleanfalse
hasOlderAffiche « Load earlier messages » en haut.
booleanfalse
loadingOlderAffiche un spinner sur ce bouton. La position de défilement est restaurée quand la valeur repasse à false.
booleanfalse
onLoadOlderAjoutez ici les messages plus anciens en tête.
() => void–
onRestoreAffiche Restore sur les checkpoints. Supprimez ici les messages suivants et remettez le message dans le compositeur. Renvoyez une fonction pour proposer Undo dans le toast, et montez Toaster une fois dans votre app.
(checkpointId: string, options: { code: boolean }) => void | (() => void)–
PropTypePar défaut
idId stable. Gardez-le identique d’une version à l’autre pour que la vue ne saute pas.
string–
textLe message. Également utilisé pour l’aperçu du point de repère.
string–
pinFait défiler ce message jusqu’en haut quand il apparaît. À définir sur le message qui vient d’être envoyé.
booleanfalse
files{ id, name, size?, type?, url? }. Les images avec une url s’affichent en miniatures.
ChatFile[]–
timeAffiché au survol, dans la locale du lecteur.
Date–
branch{ index, count, onChange } pour les flèches de version.
ChatBranch–
onEditAffiche Edit. Appelé avec le nouveau texte lorsqu’il a changé.
(text: string) => void–
checkpoint{ id, label?, files? }. Affiche un point de restauration avant ce message ; files sont les chemins modifiés par ce tour.
ChatCheckpointData–
attachmentsContenu personnalisé au-dessus de la bulle.
ReactNode–
PropTypePar défaut
idId stable.
string–
childrenReasoning, ToolCalls, Markdown ou tout autre contenu.
ReactNode–
textTexte brut pour Copy.
string–
streamingMasque les actions jusqu’à la fin de la réponse.
booleanfalse
lastGarde les actions visibles au lieu de les afficher au survol.
booleanfalse
metaCôté droit de la rangée d’actions, comme le modèle et l’effort.
ReactNode–
branchFlèches de version pour les nouveaux essais.
ChatBranch–
feedbackLa notation actuelle.
"up" | "down" | nullnull
onFeedbackAffiche les pouces. Appelé avec null quand une notation est annulée.
(feedback) => void–
onRetryAffiche Try again.
() => void–
errorAffiche le message avec Try again à la place des actions.
string | null–
stoppedMarque une réponse interrompue prématurément.
booleanfalse
PropTypePar défaut
messageIdLe message utilisateur devant lequel il se trouve.
string–
checkpoint{ id, label?, files? }.
ChatCheckpointData–
labelNom de secours pour Restore et le toast, en général le texte du message.
string–
PropTypePar défaut
childrenLe libellé, comme Today ou « Switched to Nova 3 Max ».
ReactNode–
PropTypePar défaut
messagesMessages useChat avec des parts data-checkpoint.
UIMessage[]–
checkpointIdRenvoie { kept, removed } : tout ce qui précède le message utilisateur du checkpoint, et ce message et la suite. removed[0] est le message à remettre dans le compositeur.
string–
PropTypePar défaut
messagesRenvoie une Map de l’id du message utilisateur vers son checkpoint, pour ChatUserMessage. Un part réécrit avec le même id le met à jour sur place.
UIMessage[]–
ToucheAction
TabParcourt les actions des messages. Elles apparaissent au focus, pas seulement au survol.
EnterEnvoie un message modifié.
ShiftEnterAjoute une ligne pendant la modification.
EscAnnule une modification.
↑↓PgUpPgDnFait défiler la conversation quand elle a le focus.
EnterExécute le choix ciblé dans la confirmation de restauration. Restore conversation and code reçoit le focus en premier.
EscFerme la confirmation de restauration et rend le focus à Restore.
  • La conversation est une région libellée contenant un log, donc les nouveaux messages sont annoncés à leur arrivée et la région est marquée comme occupée pendant qu’une réponse arrive en streaming.
  • Chaque action d’icône a un libellé et une infobulle. Les pouces utilisent aria-pressed, Copy et le retour de notation confirment via une région live polie, et les erreurs utilisent role=alert.
  • Les points de repère forment une zone de navigation de boutons nommés « Message 2: … », et le point courant a aria-current.
  • Les flèches de version forment un groupe nommé « Version 1 of 2 ».
  • L’éditeur prend lui-même le focus avec le curseur à la fin et revient au message sur Cancel. Enter attend tant qu’une méthode de saisie est en cours de composition.
  • Les anneaux de focus ne sont jamais coupés par le scroller, et les actions restent visibles sur les écrans tactiles.
  • Les boutons Restore s’appellent « Restore checkpoint: … » d’après leur message et sont décrits par la ligne du checkpoint. La confirmation est une boîte de dialogue qui dit exactement ce qui sera supprimé et annulé, et les messages concernés sont atténués tant qu’elle est ouverte.
  • Après une restauration, le focus passe au compositeur avec le curseur à la fin, et le toast annonce ce qui a été restauré avec un bouton Undo. Avec les animations réduites, les messages suivants s’estompent au lieu de se replier.

Construit avec

Les composants HextaUI gratuits dont Chat Thread est constitué. Chacun s’installe séparément.

Code

4 fichiers, ajoutés à components/blocks/chat-thread.