Skip to content

laguagu/claude-code-nextjs-skills / skills/ai-elements

ai-elements

Verified

Maintains AI chat UI built from elements.ai-sdk.dev AI Elements components already copied into the project. Use when changing or debugging those components (conversations, messages, prompt inputs, attachments, reasoning, tool output, sources). New chat UI uses the shadcn/ui AI Elements patterns (`shadcn` skill).

FileKindSize
SKILL.mdskill md3.4 KB
references/agent.mdmarkdown4.1 KB
references/artifact.mdmarkdown2.9 KB
references/attachments.mdmarkdown5.6 KB
references/audio-player.mdmarkdown5.2 KB
references/canvas.mdmarkdown1.1 KB
references/chain-of-thought.mdmarkdown3.3 KB
references/checkpoint.mdmarkdown5.6 KB
references/code-block.mdmarkdown5.4 KB
references/commit.mdmarkdown5.8 KB
references/confirmation.mdmarkdown8.7 KB
references/connection.mdmarkdown1.1 KB
references/context.mdmarkdown5.8 KB
references/controls.mdmarkdown971 B
references/conversation.mdmarkdown7.4 KB
references/edge.mdmarkdown2.1 KB
references/environment-variables.mdmarkdown3.7 KB
references/file-tree.mdmarkdown2.0 KB
references/image.mdmarkdown4.1 KB
references/inline-citation.mdmarkdown10.9 KB
references/integration.mdmarkdown4.3 KB
references/jsx-preview.mdmarkdown3.2 KB
references/message.mdmarkdown9.7 KB
references/mic-selector.mdmarkdown7.7 KB
references/model-selector.mdmarkdown4.3 KB
references/node.mdmarkdown2.8 KB
references/open-in-chat.mdmarkdown2.7 KB
references/package-info.mdmarkdown3.2 KB
references/panel.mdmarkdown1.0 KB
references/persona.mdmarkdown5.4 KB
references/plan.mdmarkdown3.2 KB
references/prompt-input.mdmarkdown20.0 KB
references/queue.mdmarkdown5.4 KB
references/reasoning.mdmarkdown7.8 KB
references/sandbox.mdmarkdown4.3 KB
references/schema-display.mdmarkdown2.5 KB
references/shimmer.mdmarkdown1.6 KB
references/snippet.mdmarkdown2.2 KB
references/sources.mdmarkdown5.9 KB
references/speech-input.mdmarkdown6.5 KB
references/stack-trace.mdmarkdown5.6 KB
references/suggestion.mdmarkdown4.6 KB
references/task.mdmarkdown6.8 KB
references/terminal.mdmarkdown3.1 KB
references/test-results.mdmarkdown5.0 KB
references/tool.mdmarkdown8.5 KB
references/toolbar.mdmarkdown983 B
references/transcription.mdmarkdown4.9 KB
references/voice-selector.mdmarkdown10.3 KB
references/web-preview.mdmarkdown6.3 KB
scripts/agent.tsxother1.6 KB
scripts/artifact.tsxother2.9 KB
scripts/attachments-inline.tsxother3.5 KB
scripts/attachments-list.tsxother2.2 KB
scripts/attachments.tsxother2.0 KB
scripts/audio-player-remote.tsxother1.0 KB
scripts/audio-player.tsxother1.8 KB
scripts/chain-of-thought.tsxother138.6 KB
scripts/checkpoint.tsxother2.8 KB
scripts/code-block-dark.tsxother1.0 KB
scripts/code-block.tsxother2.9 KB
scripts/commit.tsxother2.1 KB
scripts/confirmation-accepted.tsxother1.2 KB
scripts/confirmation-rejected.tsxother1.1 KB
scripts/confirmation-request.tsxother1.7 KB
scripts/confirmation.tsxother1.7 KB
scripts/context.tsxother1.0 KB
scripts/conversation.tsxother4.1 KB
scripts/environment-variables.tsxother1.7 KB
scripts/file-tree-basic.tsxother380 B
scripts/file-tree-expanded.tsxother609 B
scripts/file-tree-selection.tsxother619 B
scripts/file-tree.tsxother1.5 KB
scripts/image.tsxother136.5 KB
scripts/inline-citation.tsxother3.2 KB
scripts/jsx-preview.tsxother3.2 KB
scripts/message.tsxother10.1 KB
scripts/mic-selector.tsxother1.2 KB
scripts/model-selector.tsxother8.3 KB
scripts/open-in-chat.tsxother704 B
scripts/package-info.tsxother1.3 KB
scripts/persona-command.tsxother2.5 KB
scripts/persona-glint.tsxother2.5 KB
scripts/persona-halo.tsxother2.5 KB
scripts/persona-mana.tsxother2.5 KB
scripts/persona-obsidian.tsxother2.5 KB
scripts/persona-opal.tsxother2.5 KB
scripts/plan.tsxother1.9 KB
scripts/prompt-input-cursor.tsxother15.1 KB
scripts/prompt-input-tooltip.tsxother1.1 KB
scripts/prompt-input.tsxother7.4 KB
scripts/queue-prompt-input.tsxother10.5 KB
scripts/queue.tsxother8.0 KB
scripts/reasoning.tsxother2.2 KB
scripts/sandbox.tsxother5.4 KB
scripts/schema-display-basic.tsxother221 B
scripts/schema-display-body.tsxother487 B
scripts/schema-display-nested.tsxother470 B
scripts/schema-display-params.tsxother374 B
scripts/schema-display.tsxother2.7 KB
scripts/shimmer-duration.tsxother934 B
scripts/shimmer-elements.tsxother1.1 KB
scripts/shimmer.tsxother443 B
scripts/snippet-plain.tsxother362 B
scripts/snippet.tsxother589 B
scripts/sources-custom.tsxother1.0 KB
scripts/sources.tsxother752 B
scripts/speech-input.tsxother2.3 KB
scripts/stack-trace-collapsed.tsxother1.1 KB
scripts/stack-trace-no-internal.tsxother1.2 KB
scripts/stack-trace.tsxother1.9 KB
scripts/suggestion-input.tsxother4.5 KB
scripts/suggestion.tsxother802 B
scripts/task.tsxother1.5 KB
scripts/terminal-basic.tsxother169 B
scripts/terminal-clear.tsxother523 B
scripts/terminal-streaming.tsxother1007 B
scripts/terminal.tsxother2.3 KB
scripts/test-results-basic.tsxother464 B
scripts/test-results-errors.tsxother1.3 KB
scripts/test-results-suites.tsxother901 B
scripts/test-results.tsxother2.7 KB
scripts/tool-input-available.tsxother738 B
scripts/tool-input-streaming.tsxother683 B
scripts/tool-output-available.tsxother1.7 KB
scripts/tool-output-error.tsxother1.1 KB
scripts/tool.tsxother6.7 KB
scripts/transcription.tsxother4.9 KB
scripts/voice-selector.tsxother7.1 KB
scripts/web-preview.tsxother2.8 KB

references/reasoning.md

View on GitHub
# Reasoning

A collapsible component that displays AI reasoning content, automatically opening during streaming and closing when finished.

The `Reasoning` component displays AI reasoning content, automatically opening during streaming and closing when finished.

See `scripts/reasoning.tsx` for this example.

## Installation

```bash
npx ai-elements@latest add reasoning
```

## Usage with AI SDK

Build a chatbot with reasoning using Deepseek R1 or other reasoning models.

Some models (like GPT with high reasoning effort) return multiple reasoning parts instead of a single streaming block. The example below consolidates all reasoning parts into a single component to avoid displaying multiple "Thinking..." indicators.

Add the following component to your frontend:

```tsx title="app/page.tsx"
"use client";

import {
  Reasoning,
  ReasoningContent,
  ReasoningTrigger,
} from "@/components/ai-elements/reasoning";
import {
  Conversation,
  ConversationContent,
  ConversationScrollButton,
} from "@/components/ai-elements/conversation";
import {
  PromptInput,
  type PromptInputMessage,
  PromptInputTextarea,
  PromptInputSubmit,
} from "@/components/ai-elements/prompt-input";
import { Spinner } from "@/components/ui/spinner";
import {
  Message,
  MessageContent,
  MessageResponse,
} from "@/components/ai-elements/message";
import { useState } from "react";
import { useChat } from "@ai-sdk/react";
import type { UIMessage } from "ai";

const MessageParts = ({
  message,
  isLastMessage,
  isStreaming,
}: {
  message: UIMessage;
  isLastMessage: boolean;
  isStreaming: boolean;
}) => {
  // Consolidate all reasoning parts into one block
  const reasoningParts = message.parts.filter(
    (part) => part.type === "reasoning"
  );
  const reasoningText = reasoningParts.map((part) => part.text).join("\n\n");
  const hasReasoning = reasoningParts.length > 0;

  // Check if reasoning is still streaming (last part is reasoning on last message)
  const lastPart = message.parts.at(-1);
  const isReasoningStreaming =
    isLastMessage && isStreaming && lastPart?.type === "reasoning";

  return (
    <>
      {hasReasoning && (
        <Reasoning className="w-full" isStreaming={isReasoningStreaming}>
          <ReasoningTrigger />
          <ReasoningContent>{reasoningText}</ReasoningContent>
        </Reasoning>
      )}
      {message.parts.map((part, i) => {
        if (part.type === "text") {
          return (
            <MessageResponse key={`${message.id}-${i}`}>
              {part.text}
            </MessageResponse>
          );
        }
        return null;
      })}
    </>
  );
};

const ReasoningDemo = () => {
  const [input, setInput] = useState("");

  const { messages, sendMessage, status } = useChat();

  const handleSubmit = (message: PromptInputMessage) => {
    sendMessage({ text: message.text });
    setInput("");
  };

  const isStreaming = status === "streaming";

  return (
    <div className="max-w-4xl mx-auto p-6 relative size-full rounded-lg border h-[600px]">
      <div className="flex flex-col h-full">
        <Conversation>
          <ConversationContent>
            {messages.map((message, index) => (
              <Message from={message.role} key={message.id}>
                <MessageContent>
                  <MessageParts
                    message={message}
                    isLastMessage={index === messages.length - 1}
                    isStreaming={isStreaming}
                  />
                </MessageContent>
              </Message>
            ))}
            {status === "submitted" && <Spinner />}
          </ConversationContent>
          <ConversationScrollButton />
        </Conversation>

        <PromptInput
          onSubmit={handleSubmit}
          className="mt-4 w-full max-w-2xl mx-auto relative"
        >
          <PromptInputTextarea
            value={input}
            placeholder="Say something..."
            onChange={(e) => setInput(e.currentTarget.value)}
            className="pr-12"
          />
          <PromptInputSubmit
            status={isStreaming ? "streaming" : "ready"}
            disabled={!input.trim()}
            className="absolute bottom-1 right-1"
          />
        </PromptInput>
      </div>
    </div>
  );
};

export default ReasoningDemo;
```

Add the following route to your backend:

```ts title="app/api/chat/route.ts"
import { streamText, UIMessage, convertToModelMessages } from "ai";

// Allow streaming responses up to 30 seconds
export const maxDuration = 30;

export async function POST(req: Request) {
  const { model, messages }: { messages: UIMessage[]; model: string } =
    await req.json();

  const result = streamText({
    model: "deepseek/deepseek-r1",
    messages: await convertToModelMessages(messages),
  });

  return result.toUIMessageStreamResponse({
    sendReasoning: true,
  });
}
```

## Reasoning vs Chain of Thought

Use the `Reasoning` component when your model outputs thinking content as a single block or continuous stream (Deepseek R1, Claude with extended thinking, etc.).

If your model outputs discrete, labeled steps (search queries, tool calls, distinct thought stages), consider using the [Chain of Thought](chain-of-thought.md) component instead for a more structured visual representation.

## Features

- Automatically opens when streaming content and closes when finished
- Manual toggle control for user interaction
- Smooth animations and transitions powered by Radix UI
- Visual streaming indicator with pulsing animation
- Composable architecture with separate trigger and content components
- Built with accessibility in mind including keyboard navigation
- Responsive design that works across different screen sizes
- Seamlessly integrates with both light and dark themes
- Built on top of shadcn/ui Collapsible primitives
- TypeScript support with proper type definitions

## Props

### `<Reasoning />`

| Prop | Type | Default | Description |
|------|------|---------|-------------|
| `isStreaming` | `boolean` | `false` | Whether the reasoning is currently streaming (auto-opens and closes the panel). |
| `open` | `boolean` | - | Controlled open state. |
| `defaultOpen` | `boolean` | `true` | Default open state when uncontrolled. |
| `onOpenChange` | `(open: boolean) => void` | - | Callback when open state changes. |
| `duration` | `number` | - | Duration in seconds to display (can be controlled externally). |
| `...props` | `React.ComponentProps<typeof Collapsible>` | - | Any other props are spread to the underlying Collapsible component. |

### `<ReasoningTrigger />`

| Prop | Type | Default | Description |
|------|------|---------|-------------|
| `getThinkingMessage` | `(isStreaming: boolean, duration?: number) => ReactNode` | - | Optional function to customize the thinking message. Receives isStreaming and duration parameters. |
| `...props` | `React.ComponentProps<typeof CollapsibleTrigger>` | - | Any other props are spread to the underlying CollapsibleTrigger component. |

### `<ReasoningContent />`

| Prop | Type | Default | Description |
|------|------|---------|-------------|
| `children` | `string` | Required | The reasoning text to display (rendered via Streamdown). |
| `...props` | `React.ComponentProps<typeof CollapsibleContent>` | - | Any other props are spread to the underlying CollapsibleContent component. |

## Hooks

### `useReasoning`

Access the reasoning context from child components.

```tsx
const { isStreaming, isOpen, setIsOpen, duration } = useReasoning();
```

Returns:

| Prop | Type | Default | Description |
|------|------|---------|-------------|
| `isStreaming` | `boolean` | - | Whether reasoning is currently streaming. |
| `isOpen` | `boolean` | - | Whether the reasoning panel is open. |
| `setIsOpen` | `(open: boolean) => void` | - | Function to set the open state. |
| `duration` | `number | undefined` | - | Duration in seconds (undefined while streaming). |
brainstormingobra/superpowersYou MUST use this before any creative work - creating features, building components, adding functionality, modifying behavior, or planning anything new, in software or out of it (a talk, a business, a renovation).Stars: 322kUpdated Claude CodeCodexVerifiedInstall
brand-guidelinesanthropics/skillsApplies Anthropic's official brand colors and typography to any sort of artifact that may benefit from having Anthropic's look-and-feel. Use it when brand colors or style guidelines, visual formatting, or company design standards apply.Stars: 198kUpdated Claude CodeCodexVerifiedInstall
frontend-designanthropics/skillsGuidance for distinctive, intentional visual design when building new UI or reshaping an existing one. Helps with aesthetic direction, typography, and making choices that don't read as templated defaults.Stars: 198kUpdated Claude CodeCodexVerifiedInstall
mcp-builderanthropics/skillsGuide for creating high-quality MCP (Model Context Protocol) servers that enable LLMs to interact with external services through well-designed tools. Use when building MCP servers to integrate external APIs or services, whether in Python (FastMCP) or Node/TypeScript (MCP SDK).Stars: 198kUpdated Claude CodeCodexVerifiedInstall