# Prompt Input

> A chat composer that grows as you type. Handles file uploads, @ and / menus at the caret and messages typed while a reply streams.

Canonical: https://hextaui.com/blocks/prompt-input
Last updated: 2026-10-29

## Overview

The composer is the part of a chat people touch most, so every keystroke has to feel right. Prompt Input starts as one calm line with the + on the left and send on the right, grows into a card once the text wraps or files are added, and settles back when cleared.

Enter sends and Shift+Enter adds a line, and input methods for Japanese, Chinese and Korean are never interrupted. On touch screens Enter adds a line, since the keyboard has no Shift. Inserts go through the browser’s own undo stack, so ⌘Z always works, and long pastes become an attachment you can preview or put back inline.

Everything is composed from parts that share one context. Use just the field and send button, or add file uploads with progress and retry, @ and / menus at the caret, a model picker, an effort slider, a context ring with a token and cost breakdown, dictation, tool chips, a queue for messages sent while a reply streams, and drafts that survive a reload.

## Installation

Prompt Input is free. Install it without an account or a token, and use it under the [Pro License](https://hextaui.com/legal/license) in as many projects as you like.

```bash
npx shadcn@latest add https://hextaui.com/r/pro/prompt-input.json
```

## Build the rest of the chat

Prompt Input is free. These blocks build the rest of the chat around it, and come with HextaUI Pro.

- [Chat Thread](https://hextaui.com/blocks/chat-thread) - The conversation view of an AI chat. Handles replies that stream, edit and retry, and versions of a reply you can switch between.
- [Streaming](https://hextaui.com/blocks/streaming) - Text that streams from a model at a steady pace. Bursty chunks are smoothed out, with a fade on new words and a caret while it writes.
- [Thinking](https://hextaui.com/blocks/thinking) - The thinking view of an AI chat. A live label follows each step, searches and sources fold into a trail, and citations sit beside the answer.
- [Tool Calls](https://hextaui.com/blocks/tool-calls) - The list of what an agent does, one line per step. Reads fold into a summary, edits and errors stay in view, and approvals ask before a tool runs.

## Usage

### With the AI SDK

Pass useChat’s status and stop. Files arrive as FileUIPart with a data URL, and a message typed while a reply streams is queued and sent when it finishes. Send usage from the server as message metadata to fill the context ring.

```tsx
"use client"

import { useChat } from "@ai-sdk/react"
import type { FileUIPart, LanguageModelUsage, UIMessage } from "ai"

import {
  PromptInputAddMenu,
  PromptInputContextUsage,
  PromptInputMeta,
} from "@/components/blocks/prompt-input/prompt-controls"
import {
  PromptInput,
  PromptInputAttachments,
  PromptInputBody,
  PromptInputActions,
  PromptInputQueue,
  PromptInputSubmit,
  PromptInputTextarea,
  PromptInputTools,
  type PromptMessage,
} from "@/components/blocks/prompt-input/prompt-input"

function toDataUrl(file: File) {
  return new Promise<string>((resolve, reject) => {
    const reader = new FileReader()
    reader.onload = () => resolve(String(reader.result))
    reader.onerror = () => reject(reader.error)
    reader.readAsDataURL(file)
  })
}

type ChatMessage = UIMessage<{ usage?: LanguageModelUsage }>

export function Composer({ chatId }: { chatId: string }) {
  const { messages, sendMessage, status, stop } = useChat<ChatMessage>({
    id: chatId,
  })
  const usage = messages.findLast((message) => message.metadata?.usage)
    ?.metadata?.usage

  const send = async ({ text, files }: PromptMessage) => {
    const parts: FileUIPart[] = await Promise.all(
      files.map(async ({ file }) => ({
        type: "file" as const,
        mediaType: file.type,
        filename: file.name,
        url: await toDataUrl(file),
      }))
    )
    await sendMessage({ text, files: parts })
  }

  return (
    <PromptInput
      status={status}
      onStop={stop}
      onSubmit={send}
      accept="image/*,.pdf"
      maxFileSize={20 * 1024 * 1024}
      draftKey={chatId}
    >
      <PromptInputQueue />
      <PromptInputBody>
        <PromptInputAttachments />
        <PromptInputTools>
          <PromptInputAddMenu />
        </PromptInputTools>
        <PromptInputTextarea />
        <PromptInputActions>
          <PromptInputSubmit />
        </PromptInputActions>
      </PromptInputBody>
      <PromptInputMeta>
        <PromptInputContextUsage
          usage={usage}
          limit={200000}
          pricing={{ input: 3, cachedInput: 0.3, output: 15 }}
        />
      </PromptInputMeta>
    </PromptInput>
  )
}
```

### Model, effort and dictation

Put the model picker, effort slider and context ring under the composer with PromptInputMeta. The ring breaks usage down into input, cache, output and reasoning, prices it, and offers to compact the conversation near the limit. Turn tools on from the + menu and show them as chips. Pass transcribe to send recordings to your own speech model, and autoSend to send as soon as the text lands.

```tsx
"use client"

import * as React from "react"
import { IconWorld } from "@tabler/icons-react"

import { DropdownMenuCheckboxItem } from "@/components/ui/dropdown-menu"

import {
  PromptInputAddMenu,
  PromptInputContextUsage,
  PromptInputDictation,
  PromptInputEffort,
  PromptInputMeta,
  PromptInputModelSelect,
  PromptInputTool,
  type PromptTokenUsage,
} from "@/components/blocks/prompt-input/prompt-controls"
import {
  PromptInput,
  PromptInputActions,
  PromptInputAttachments,
  PromptInputBody,
  PromptInputSubmit,
  PromptInputTextarea,
  PromptInputTools,
  type PromptMessage,
} from "@/components/blocks/prompt-input/prompt-input"

const models = [
  { value: "large", label: "Large" },
  { value: "small", label: "Small" },
]

const efforts = [
  { value: "low", label: "Low" },
  { value: "medium", label: "Medium" },
  { value: "high", label: "High" },
  { value: "max", label: "Max" },
]

export function Composer({
  onSend,
  usage,
  onCompact,
  transcribe,
}: {
  onSend: (message: PromptMessage) => void
  usage: PromptTokenUsage
  onCompact: () => Promise<void>
  transcribe: (audio: Blob) => Promise<string>
}) {
  const [model, setModel] = React.useState("large")
  const [effort, setEffort] = React.useState("medium")
  const [thinking, setThinking] = React.useState(true)
  const [search, setSearch] = React.useState(false)

  return (
    <PromptInput onSubmit={onSend} focusOnType>
      <PromptInputBody>
        <PromptInputAttachments />
        <PromptInputTools>
          <PromptInputAddMenu>
            <DropdownMenuCheckboxItem
              indicator="end"
              checked={search}
              onCheckedChange={setSearch}
            >
              <IconWorld />
              Web search
            </DropdownMenuCheckboxItem>
          </PromptInputAddMenu>
          {search ? (
            <PromptInputTool
              icon={<IconWorld />}
              tone="blue"
              onRemove={() => setSearch(false)}
            >
              Search
            </PromptInputTool>
          ) : null}
        </PromptInputTools>
        <PromptInputTextarea autoFocus />
        <PromptInputActions>
          <PromptInputDictation transcribe={transcribe} autoSend />
          <PromptInputSubmit />
        </PromptInputActions>
      </PromptInputBody>
      <PromptInputMeta>
        <PromptInputModelSelect
          models={models}
          value={model}
          onValueChange={setModel}
        />
        <PromptInputEffort
          levels={efforts}
          value={effort}
          onValueChange={setEffort}
          recommended="medium"
          thinking={thinking}
          onThinkingChange={setThinking}
        />
        <PromptInputContextUsage
          usage={usage}
          limit={200000}
          model={models.find((item) => item.value === model)?.label}
          pricing={{ input: 3, cachedInput: 0.3, output: 15 }}
          onCompact={onCompact}
        />
      </PromptInputMeta>
    </PromptInput>
  )
}
```

### Mentions and commands

Add a menu per trigger. @ turns a pick into a chip above the text, and / inserts the command. Arrow keys move, Enter or Tab picks and Escape closes, all without leaving the text.

```tsx
"use client"

import { IconBrandTypescript, IconTrash } from "@tabler/icons-react"

import {
  PromptInput,
  PromptInputAttachments,
  PromptInputBody,
  PromptInputActions,
  PromptInputSubmit,
  PromptInputTextarea,
  type PromptMessage,
} from "@/components/blocks/prompt-input/prompt-input"
import { PromptInputMenu, type PromptMenuItem } from "@/components/blocks/prompt-input/prompt-menu"

const files: PromptMenuItem[] = [
  {
    value: "app/page.tsx",
    label: "page.tsx",
    description: "app",
    icon: <IconBrandTypescript />,
  },
  {
    value: "lib/utils.ts",
    label: "utils.ts",
    description: "lib",
    icon: <IconBrandTypescript />,
  },
]

const commands: PromptMenuItem[] = [
  { value: "explain", label: "explain", description: "Explain code step by step" },
  { value: "test", label: "test", description: "Write tests for a file" },
  {
    value: "clear",
    label: "clear",
    description: "Start a new conversation",
    icon: <IconTrash />,
    insert: "",
  },
]

export function Composer({
  onSend,
  onClear,
}: {
  onSend: (message: PromptMessage) => void
  onClear: () => void
}) {
  return (
    <PromptInput onSubmit={onSend}>
      <PromptInputBody>
        <PromptInputAttachments />
        <PromptInputTextarea placeholder="Ask anything, @ to add files, / for commands" />
        <PromptInputActions>
          <PromptInputSubmit />
        </PromptInputActions>
      </PromptInputBody>
      <PromptInputMenu trigger="@" items={files} />
      <PromptInputMenu
        trigger="/"
        items={commands}
        onSelect={(item) => {
          if (item.value === "clear") onClear()
        }}
      />
    </PromptInput>
  )
}
```

### Uploading files

Give upload a function that reports progress and honours the abort signal. Throw UploadError with retryable: false for errors a retry can’t fix, like a file that’s too large for the server.

```tsx
"use client"

import {
  PromptInput,
  PromptInputAttachments,
  PromptInputBody,
  PromptInputActions,
  PromptInputSubmit,
  PromptInputTextarea,
  PromptInputTools,
  type PromptMessage,
} from "@/components/blocks/prompt-input/prompt-input"
import { PromptInputAddMenu } from "@/components/blocks/prompt-input/prompt-controls"
import { UploadError, type PromptUpload } from "@/components/blocks/prompt-input/use-prompt-files"

const upload: PromptUpload = (file, { signal, onProgress }) =>
  new Promise((resolve, reject) => {
    const request = new XMLHttpRequest()
    request.open("POST", "/api/upload")
    request.upload.onprogress = (event) => {
      if (event.lengthComputable) onProgress((event.loaded / event.total) * 100)
    }
    request.onload = () => {
      if (request.status < 300) {
        resolve(JSON.parse(request.responseText))
        return
      }
      reject(
        new UploadError(
          request.status === 413 ? "Too large for the server" : "Upload failed",
          { retryable: request.status === 429 || request.status >= 500 }
        )
      )
    }
    request.onerror = () => reject(new UploadError("Network error. Try again."))
    signal.addEventListener("abort", () => request.abort())
    const body = new FormData()
    body.append("file", file)
    request.send(body)
  })

export function Composer({ onSend }: { onSend: (message: PromptMessage) => void }) {
  return (
    <PromptInput
      onSubmit={onSend}
      upload={upload}
      accept="image/*,.pdf,.csv"
      maxFiles={5}
      maxFileSize={25 * 1024 * 1024}
      globalDrop
    >
      <PromptInputBody>
        <PromptInputAttachments />
        <PromptInputTools>
          <PromptInputAddMenu />
        </PromptInputTools>
        <PromptInputTextarea />
        <PromptInputActions>
          <PromptInputSubmit />
        </PromptInputActions>
      </PromptInputBody>
    </PromptInput>
  )
}
```

### Agent harness

Wrap the body in PromptInputInset and add a PromptInputFooter. Use PromptInputSelect for the mode, where it runs and which folder it works in.

```tsx
"use client"

import * as React from "react"
import {
  IconCloud,
  IconCode,
  IconDeviceLaptop,
  IconFolder,
  IconFolderOpen,
  IconListCheck,
} from "@tabler/icons-react"

import {
  PromptInputAddMenu,
  PromptInputFooter,
  PromptInputInset,
  PromptInputModel,
  PromptInputSelect,
} from "@/components/blocks/prompt-input/prompt-controls"
import {
  PromptInput,
  PromptInputActions,
  PromptInputAttachments,
  PromptInputBody,
  PromptInputSubmit,
  PromptInputTextarea,
  PromptInputTools,
  type PromptMessage,
} from "@/components/blocks/prompt-input/prompt-input"

const modes = [
  { value: "code", label: "Code", icon: <IconCode /> },
  { value: "plan", label: "Plan", icon: <IconListCheck /> },
]

const locations = [
  { value: "local", label: "Local", icon: <IconDeviceLaptop /> },
  { value: "cloud", label: "Cloud", icon: <IconCloud /> },
]

const folders = [
  { value: "~/code/app", label: "app", icon: <IconFolder /> },
]

const models = [
  { value: "large", label: "Large" },
  { value: "small", label: "Small" },
]

const efforts = [
  { value: "low", label: "Low" },
  { value: "medium", label: "Medium" },
  { value: "high", label: "High" },
]

export function AgentComposer({
  onSend,
}: {
  onSend: (message: PromptMessage & { mode: string }) => void
}) {
  const [mode, setMode] = React.useState("code")
  const [location, setLocation] = React.useState("local")
  const [folder, setFolder] = React.useState<string>()
  const [model, setModel] = React.useState("large")
  const [effort, setEffort] = React.useState("medium")

  return (
    <PromptInput
      layout="expanded"
      onSubmit={(message) => onSend({ ...message, mode })}
    >
      <PromptInputInset>
        <PromptInputBody>
          <PromptInputAttachments />
          <PromptInputTools>
            <PromptInputAddMenu />
            <PromptInputSelect
              label="Mode"
              options={modes}
              value={mode}
              onValueChange={setMode}
              shortcut="alt+m"
            />
          </PromptInputTools>
          <PromptInputTextarea className="min-h-16" />
          <PromptInputActions>
            <PromptInputModel
              models={models}
              model={model}
              onModelChange={setModel}
              levels={efforts}
              effort={effort}
              onEffortChange={setEffort}
            />
            <PromptInputSubmit />
          </PromptInputActions>
        </PromptInputBody>
        <PromptInputFooter>
          <PromptInputSelect
            label="Run on"
            options={locations}
            value={location}
            onValueChange={setLocation}
          />
          <PromptInputSelect
            label="Folder"
            options={folders}
            value={folder}
            onValueChange={setFolder}
            placeholder="Choose folder"
            icon={<IconFolderOpen />}
          />
        </PromptInputFooter>
      </PromptInputInset>
    </PromptInput>
  )
}
```

## Anatomy

The parts you compose, from the outside in.

| Part | Description |
| --- | --- |
| `PromptInput` | The form and shared state: text, files, mentions, queue and status. |
| `PromptInputBody` | The rounded surface that changes between compact and expanded. |
| `PromptInputTextarea` | The field. All keyboard handling lives here. |
| `PromptInputTools` | Left side: the + menu and tool chips. |
| `PromptInputActions` | Right side: dictation and send. |
| `PromptInputSubmit` | Send, stop or queue, depending on status and text. |
| `PromptInputAttachments` | File and mention chips above the text. |
| `PromptInputMenu` | A caret menu for one trigger character. |
| `PromptInputMeta` | The row under the composer for the model, effort and context controls. |
| `PromptInputModel` | One control for the model and effort, with the thinking switch. |
| `PromptInputInset` | A muted shell around the body that holds a footer row, for agent harnesses. |
| `PromptInputFooter` | The row inside the inset shell for location, folder and session controls. |
| `PromptInputSelect` | A compact picker for modes, run location, folders or repositories. |
| `PromptInputQueue, PromptInputSuggestions, PromptInputMeter` | Queued messages, starter prompts and a character meter near maxLength. |

## API reference

### PromptInput

Also accepts every form prop except onSubmit and defaultValue.

| Prop | Type | Default | Description |
| --- | --- | --- | --- |
| `onSubmit` | `(message: PromptMessage) => void \| Promise<unknown>` | – | Receives { text, files, mentions }. Return a promise to keep the text until it resolves. |
| `status` | `"ready" \| "submitted" \| "streaming" \| "error"` | `"ready"` | Pass useChat’s status. While busy, send becomes stop or queue. |
| `onStop` | `() => void` | – | Called from the stop button or Escape. |
| `onEditLast` | `() => string \| void` | – | Return the last message to load it with ↑ in an empty field. |
| `value` | `string` | – | Controlled text. |
| `defaultValue` | `string` | `""` | Initial text. |
| `onValueChange` | `(value: string) => void` | – | Called as the text changes. |
| `submitOn` | `"enter" \| "mod+enter"` | `"enter"` | Which key sends. ⌘↵ always sends. |
| `pasteLimit` | `number \| false` | `5000` | Characters before a paste becomes an attachment. |
| `maxLength` | `number` | – | Hard limit, shown by PromptInputMeter. |
| `draftKey` | `string` | – | Saves unsent text to local storage under this key. |
| `globalDrop` | `boolean` | `false` | Accept files dropped anywhere on the page. |
| `focusOnType` | `boolean` | `false` | Typing while nothing else has focus starts typing here. |
| `layout` | `"auto" \| "compact" \| "expanded"` | `"auto"` | Force a layout instead of switching. |
| `accept` | `string` | – | Accepted file types, like the input attribute. |
| `maxFiles` | `number` | – | Most files at once. |
| `maxFileSize` | `number` | – | Largest file in bytes. |
| `upload` | `(file, { signal, onProgress }) => Promise<unknown>` | – | Uploads each file. Throw UploadError with retryable: false for permanent failures. |
| `onReject` | `(file: File, reason: string) => void` | – | Called for files over a limit or of the wrong type. |
| `disabled` | `boolean` | `false` | Disables the whole composer. |

### PromptInputMenu

| Prop | Type | Default | Description |
| --- | --- | --- | --- |
| `trigger` | `string` | – | The character that opens it, such as @ or /. |
| `items` | `PromptMenuItem[]` | – | { value, label, description?, icon?, hint?, keywords?, insert? } |
| `mode` | `"mention" \| "text"` | – | Mentions add a chip; text inserts insert ?? label. |
| `label` | `string` | – | Section label at the top of the menu. |
| `limit` | `number` | – | Most rows shown. |
| `onSelect` | `(item: PromptMenuItem) => void` | – | Called after a pick. |

### PromptInputModel

The model picker and effort slider in one control. Also takes every PromptInputEffort prop except value and onValueChange.

| Prop | Type | Default | Description |
| --- | --- | --- | --- |
| `models` | `{ value, label }[]` | – | The first nine get 1–9 shortcuts. |
| `model` | `string` | – | Selected model. |
| `onModelChange` | `(value: string) => void` | – | Called on pick. |
| `levels` | `{ value, label }[]` | – | Effort levels, from least to most. |
| `effort` | `string` | – | Selected effort. |
| `onEffortChange` | `(value: string) => void` | – | Called as the slider moves. |

### PromptInputModelSelect

| Prop | Type | Default | Description |
| --- | --- | --- | --- |
| `models` | `{ value, label }[]` | – | The first nine get 1–9 shortcuts. |
| `value` | `string` | – | Selected model. |
| `onValueChange` | `(value: string) => void` | – | Called on pick. |

### PromptInputEffort

| Prop | Type | Default | Description |
| --- | --- | --- | --- |
| `levels` | `{ value, label }[]` | – | From least to most. |
| `value` | `string` | – | Selected level. |
| `onValueChange` | `(value: string) => void` | – | Called as the slider moves. |
| `recommended` | `string` | – | Marks one level as recommended. |
| `thinking` | `boolean` | – | Shows the extended-thinking switch when set. |
| `onThinkingChange` | `(thinking: boolean) => void` | – | Called from the switch. |
| `thinkingLabel` | `string` | – | Switch label. |
| `description` | `string` | – | Help text in the tooltip. |

### PromptInputContextUsage

A ring that fills as the context window does. Hover, click or press Enter to see the breakdown.

| Prop | Type | Default | Description |
| --- | --- | --- | --- |
| `used` | `number` | – | Tokens used. Defaults to the total in usage. |
| `limit` | `number` | – | Context window size. |
| `usage` | `LanguageModelUsage` | – | AI SDK usage, flat or nested. Splits the bar into input, cached input, output and reasoning. |
| `model` | `string` | – | Model name shown at the top. |
| `pricing` | `{ input, output, cachedInput?, reasoning? }` | – | Dollars per million tokens. Prices each row and adds a total. |
| `cost` | `number` | – | Total cost in dollars, when you already have it. |
| `onCompact` | `() => void \| Promise<unknown>` | – | Shows Compact conversation from 80% full. Return a promise to show progress. The popover closes when it resolves. |
| `limits` | `{ label, used, detail? }[]` | – | Extra rows, such as plan usage. |
| `limitsLabel` | `string` | – | Heading for those rows. |

### PromptInputDictation

| Prop | Type | Default | Description |
| --- | --- | --- | --- |
| `transcribe` | `(audio: Blob) => Promise<string>` | – | Send the recording to your speech model. Without it, the browser’s speech recognition is used. |
| `shortcut` | `string \| false` | `"ctrl+shift+d"` | Starts and finishes a recording from anywhere. |
| `autoSend` | `boolean` | `false` | Send as soon as the transcript lands. |

### PromptInputTool

| Prop | Type | Default | Description |
| --- | --- | --- | --- |
| `icon` | `ReactNode` | – | Shown in the chip, and replaced by × on hover. |
| `children` | `string` | – | Tool name. |
| `tone` | `"blue" \| "green" \| "amber" \| "violet" \| "pink"` | `"blue"` | Chip color. |
| `onRemove` | `() => void` | – | Called when the chip is clicked. |

### PromptInputSelect

| Prop | Type | Default | Description |
| --- | --- | --- | --- |
| `options` | `{ value, label, icon?, description? }[]` | – | The choices. Descriptions show under each label. |
| `value` | `string` | – | Selected option. Leave it unset to show the placeholder. |
| `onValueChange` | `(value: string) => void` | – | Called on pick. |
| `label` | `string` | – | Accessible name and tooltip, like Mode or Run on. |
| `placeholder` | `string` | – | Shown when nothing is selected. |
| `icon` | `ReactNode` | – | Shown when the selected option has no icon. |
| `heading` | `string` | – | Label at the top of the menu. |
| `shortcut` | `string` | – | Cycles through the options from anywhere, like alt+m. |
| `children` | `ReactNode` | – | Extra menu items below the options, like Open folder. |

## Keyboard

| Key | Action |
| --- | --- |
| `Enter` | Sends. On touch screens it adds a line instead. |
| `Shift` `Enter` | Adds a line. |
| `⌘` `Enter` | Always sends, even when submitOn is mod+enter. |
| `Esc` | Stops a streaming reply, closes a menu, or cancels a recording. |
| `↑` | In an empty field, brings back your last message when onEditLast is set. |
| `↑` `↓` | Moves through an open @ or / menu. |
| `Enter` `Tab` | Picks the highlighted menu row. |
| `1` `–` `9` | Picks a model while the model menu is open. |
| `←` `→` | Moves the effort slider. Home and End jump to the ends. |
| `Ctrl` `Shift` `D` | Starts dictation, and inserts the transcript when pressed again. |
| `Alt` `M` | Cycles a PromptInputSelect that has shortcut="alt+m", like the agent mode. |

## Accessibility

- The field has a visible placeholder and an accessible name, and every icon button has a label and tooltip with its shortcut.
- The caret menu is a combobox with aria-activedescendant, so focus never leaves the text while moving through it.
- Uploads, rejections, queue changes and dictation are announced through a polite live region.
- The effort control is a slider with a value text, and it keeps working with arrow keys and Home and End.
- The context ring opens on hover, click, Enter or Space, its label says how much of the context is used, and the breakdown is a table with a caption.
- Inputs are at least 16px on touch screens, so iOS never zooms in on focus.
- With reduced motion, height changes, the waveform and the effort fill all settle without animating.

## Built with

The free HextaUI components Prompt Input is made from. Each one installs on its own.

- [Attachment](https://hextaui.com/docs/attachment) - File and image cards for uploads, with progress, states, actions, a full-card trigger and names that keep their extension.
- [Button](https://hextaui.com/docs/button) - Buttons in every variant and size, with a built-in loading, success and error flow that skips the spinner for fast requests.
- [Dialog](https://hextaui.com/docs/dialog) - A window over the page for forms and focused tasks, with a pinned header and footer, nesting, and a swipeable bottom sheet on phones.
- [Dropdown menu](https://hextaui.com/docs/dropdown-menu) - A menu of actions and options behind a button, with groups, submenus, checkbox and radio items, and shortcuts.
- [Kbd](https://hextaui.com/docs/kbd) - Key caps for shortcuts that show the right symbols on every platform, read them out properly and press down with the real keys.
- [Number flow](https://hextaui.com/docs/number-flow) - Animated numbers where only the changed digits spin, with any Intl format and locale.
- [Popover](https://hextaui.com/docs/popover) - A floating panel anchored to a trigger that resizes smoothly with its content and follows the trigger’s direction.
- [Switch](https://hextaui.com/docs/switch) - An on/off toggle you can tap, press or drag, with a thumb that stretches under your finger and an optional pending state for saves.
- [Tooltip](https://hextaui.com/docs/tooltip) - A short hint on hover or keyboard focus that opens after a brief rest, switches instantly between neighbours and shows shortcuts.

## Code

11 files, added to components/blocks/prompt-input.
