# AI Send
> An email the assistant drafted, editable in place. Send starts a short countdown you can undo before anything goes out.

Source: https://kokonutui.com/docs/ai/ai-send

## Installation

```bash
npx shadcn@latest add @kokonutui/ai-send
```

## Props

| Prop | Type | Default | Description |
| --- | --- | --- | --- |
| `prompt?` | `string` |  | The user's message, drawn as a bubble. Only the demo draws one by default. |
| `message?` | `string` |  | What the assistant says above the draft. |
| `draft?` | `DraftEmail` |  | The email, usually a tool's input. It can stream in: the body follows it until the person edits it. Leave it out for the demo. |
| `writing?` | `boolean` | `false` | The model is still writing the draft, so Send waits. |
| `undoSeconds?` | `number` | `5` | Seconds you have to undo before it really sends. |
| `onSend?` | `(draft: DraftEmail) => void \| Promise<void>` |  | Called once the undo window has passed, with the final text. Return a Promise to show it sending until it resolves; throw and the draft comes back with the error's message. |
| `className?` | `string` |  | Extra classes for the root element. |

### DraftEmail

| Field | Type | Description |
| --- | --- | --- |
| `from` | `string` |  |
| `toName` | `string` |  |
| `toEmail` | `string` |  |
| `subject` | `string` |  |
| `body` | `string` |  |

## Source

```tsx
"use client";

/**
 * @author: @kokonutui
 * @description: AI Send
 * @version: 1.1.0
 * @date: 2026-10-31
 * @license: MIT
 * @website: https://kokonutui.com
 * @github: https://github.com/kokonut-labs/kokonutui
 */

import { Check, Mail, SendHorizontal } from "lucide-react";
import { AnimatePresence, MotionConfig, motion } from "motion/react";
import {
  type ReactNode,
  type Ref,
  useEffect,
  useId,
  useRef,
  useState,
} from "react";
import { cn } from "@/lib/utils";

export interface DraftEmail {
  from: string;
  toName: string;
  toEmail: string;
  subject: string;
  body: string;
}

export interface AISendProps {
  /** The user's message, drawn as a bubble. Only the demo draws one by default. */
  prompt?: string;
  /** What the assistant says above the draft. */
  message?: string;
  /**
   * The email, usually a tool's input. It can stream in: the body follows
   * it until the person edits it. Leave it out for the demo.
   */
  draft?: DraftEmail;
  /** The model is still writing the draft, so Send waits. */
  writing?: boolean;
  /** Seconds you have to undo before it really sends. */
  undoSeconds?: number;
  /**
   * Called once the undo window has passed, with the final text. Return a
   * Promise to show it sending until it resolves; throw and the draft comes
   * back with the error's message.
   */
  onSend?: (draft: DraftEmail) => void | Promise<void>;
  className?: string;
}

type Status = "draft" | "pending" | "sending" | "sent";

const EASE_OUT = [0.23, 1, 0.32, 1] as const;
const EASE_DRAWER = [0.32, 0.72, 0, 1] as const;
const RING = 2 * Math.PI * 8;

const DEMO_DRAFT: DraftEmail = {
  from: "mara@northwind.co",
  toName: "Sam Rivera",
  toEmail: "sam@northwind.co",
  subject: "Launch review moved to Thursday",
  body: "Hi Sam,\n\nQuick heads up: the launch review is now Thursday at 2pm, same room. Design needs the extra day to finish the flows.\n\nThanks,\nMara",
};

const DEMO_TEXT = {
  prompt: "Tell Sam the launch review moved to Thursday at 2",
  message: "Here’s a draft. Change anything you like before it goes.",
};

const reasonOf = (error: unknown) =>
  error instanceof Error && error.message
    ? error.message
    : "It didn’t send. Try again.";

export default function AISend({
  prompt,
  message,
  draft: draftProp,
  writing = false,
  undoSeconds = 5,
  onSend,
  className,
}: AISendProps) {
  const isDemo = draftProp === undefined;
  const draft = draftProp ?? DEMO_DRAFT;
  const shownPrompt = isDemo ? (prompt ?? DEMO_TEXT.prompt) : prompt;
  const shownMessage = isDemo ? (message ?? DEMO_TEXT.message) : message;
  const id = useId();
  const [status, setStatus] = useState<Status>("draft");
  // Follows the draft as it streams in, until the person edits it.
  const [edited, setEdited] = useState<string>();
  const body = edited ?? draft.body;
  const [left, setLeft] = useState(undoSeconds);
  const [error, setError] = useState<string>();
  const sendRef = useRef<HTMLButtonElement>(null);
  const final = useRef<DraftEmail>(draft);
  final.current = { ...draft, body };
  const onSendRef = useRef(onSend);
  onSendRef.current = onSend;

  // Counts down the undo window, then sends for real.
  useEffect(() => {
    if (status !== "pending") {
      return;
    }
    if (left > 0) {
      const t = setTimeout(() => setLeft((n) => n - 1), 1000);
      return () => clearTimeout(t);
    }
    setStatus("sending");
    Promise.resolve(onSendRef.current?.(final.current)).then(
      () => setStatus("sent"),
      (e: unknown) => {
        setError(reasonOf(e));
        setStatus("draft");
      }
    );
  }, [status, left]);

  const send = () => {
    setLeft(undoSeconds);
    setError(undefined);
    setStatus("pending");
  };

  const undo = () => {
    setStatus("draft");
    requestAnimationFrame(() => sendRef.current?.focus());
  };

  return (
    <MotionConfig reducedMotion="user">
      <div
        className={cn("flex w-full max-w-md flex-col gap-4", className)}
        data-state={writing ? "writing" : status}
      >
        {shownPrompt ? (
          <p className="max-w-[85%] self-end text-pretty rounded-2xl rounded-br-md bg-zinc-100 px-3.5 py-2 text-[14px] text-zinc-800 leading-snug dark:bg-zinc-800 dark:text-zinc-100">
            {shownPrompt}
          </p>
        ) : null}
        {shownMessage ? (
          <p className="text-pretty text-[15px] text-zinc-800 leading-7 dark:text-zinc-200">
            {shownMessage}
          </p>
        ) : null}

        <AutoHeight className="rounded-2xl bg-white ring-1 ring-black/[0.08] dark:bg-zinc-900 dark:ring-white/10">
          <AnimatePresence initial={false} mode="popLayout">
            {status === "sent" ? (
              <motion.div
                animate={{ opacity: 1, filter: "blur(0px)" }}
                className="flex items-center gap-3 px-4 py-3"
                initial={{ opacity: 0, filter: "blur(3px)" }}
                key="sent"
                transition={{ duration: 0.3, ease: EASE_OUT, delay: 0.08 }}
              >
                <motion.span
                  animate={{ scale: 1 }}
                  className="flex size-7 shrink-0 items-center justify-center rounded-full bg-blue-600 text-white dark:bg-blue-500"
                  initial={{ scale: 0.6 }}
                  transition={{
                    type: "spring",
                    stiffness: 500,
                    damping: 26,
                    delay: 0.1,
                  }}
                >
                  <Check
                    aria-hidden="true"
                    className="size-3.5"
                    strokeWidth={2.5}
                  />
                </motion.span>
                <div className="min-w-0 flex-1">
                  <p className="truncate text-[13.5px] text-zinc-900 dark:text-zinc-100">
                    <span className="font-medium">Sent to {draft.toName}</span>
                    <span className="text-zinc-500 dark:text-zinc-400">
                      {" "}
                      · just now
                    </span>
                  </p>
                  <p className="mt-0.5 truncate text-[12px] text-zinc-500 dark:text-zinc-400">
                    {draft.subject}
                  </p>
                </div>
              </motion.div>
            ) : (
              <motion.div
                exit={{ opacity: 0, filter: "blur(3px)" }}
                key="draft"
                transition={{ duration: 0.2 }}
              >
                <dl className="divide-y divide-black/[0.06] px-4 text-[13px] dark:divide-white/[0.08]">
                  <Field label="To">
                    <span className="text-zinc-900 dark:text-zinc-100">
                      {draft.toName}
                    </span>{" "}
                    <span className="text-zinc-400 dark:text-zinc-500">
                      {draft.toEmail}
                    </span>
                  </Field>
                  <Field label="Subject">
                    <span className="text-zinc-900 dark:text-zinc-100">
                      {draft.subject}
                    </span>
                  </Field>
                </dl>
                <label className="sr-only" htmlFor={id}>
                  Message
                </label>
                <textarea
                  className={cn(
                    "field-sizing-content block w-full resize-none border-black/[0.06] border-t bg-transparent px-4 pt-3 pb-4 text-[14px] text-zinc-800 leading-6 caret-blue-500 outline-hidden transition-opacity duration-200 dark:border-white/[0.08] dark:text-zinc-200 dark:caret-blue-400",
                    status !== "draft" && "opacity-50"
                  )}
                  id={id}
                  onChange={(e) => setEdited(e.target.value)}
                  readOnly={status !== "draft" || writing}
                  rows={6}
                  value={body}
                />
                <div className="flex items-center gap-2 border-black/[0.06] border-t px-3 py-2.5 dark:border-white/[0.08]">
                  <span className="flex items-center gap-1.5 pl-1 text-[12px] text-zinc-500 dark:text-zinc-400">
                    <Mail aria-hidden="true" className="size-3.5" />
                    {draft.from}
                  </span>
                  <div className="ml-auto flex items-center gap-1.5">
                    <AnimatePresence initial={false}>
                      {status === "pending" && (
                        <motion.button
                          animate={{ opacity: 1, x: 0 }}
                          className="h-8 rounded-full px-3 font-medium text-[13px] text-zinc-900 outline-hidden transition-colors duration-100 hover:bg-zinc-100 focus-visible:ring-2 focus-visible:ring-blue-500/40 active:bg-zinc-200 dark:text-zinc-100 dark:active:bg-white/[0.11] dark:hover:bg-white/[0.07]"
                          exit={{ opacity: 0, x: 6 }}
                          initial={{ opacity: 0, x: 6 }}
                          onClick={undo}
                          transition={{ duration: 0.18, ease: EASE_OUT }}
                          type="button"
                        >
                          Undo
                        </motion.button>
                      )}
                    </AnimatePresence>
                    <SendButton
                      disabled={writing}
                      left={left}
                      onSend={send}
                      pending={status === "pending" || status === "sending"}
                      ref={sendRef}
                      total={undoSeconds}
                    />
                  </div>
                </div>
                {error && status === "draft" ? (
                  <p
                    className="px-4 pb-3 text-[12.5px] text-rose-600 dark:text-rose-400"
                    role="alert"
                  >
                    {error}
                  </p>
                ) : null}
              </motion.div>
            )}
          </AnimatePresence>
        </AutoHeight>
        <p aria-live="polite" className="sr-only">
          {status === "pending" ? `Sending in ${left} seconds` : ""}
          {status === "sent" ? "Sent" : ""}
        </p>
      </div>
    </MotionConfig>
  );
}

function Field({ label, children }: { label: string; children: ReactNode }) {
  return (
    <div className="flex h-10 items-center gap-3">
      <dt className="w-14 shrink-0 text-zinc-500 dark:text-zinc-400">
        {label}
      </dt>
      <dd className="min-w-0 truncate">{children}</dd>
    </div>
  );
}

/** Send, then a ring that drains while the undo window is open. */
function SendButton({
  pending,
  disabled,
  left,
  total,
  onSend,
  ref,
}: {
  pending: boolean;
  disabled: boolean;
  left: number;
  total: number;
  onSend: () => void;
  ref: Ref<HTMLButtonElement>;
}) {
  return (
    <button
      className={cn(
        "group/send flex h-8 min-w-[84px] items-center justify-center gap-2 rounded-full px-3.5 font-medium text-[13px] outline-hidden transition-colors duration-200 focus-visible:ring-2 focus-visible:ring-blue-500/50 focus-visible:ring-offset-2 dark:focus-visible:ring-offset-zinc-900",
        disabled && !pending && "opacity-50",
        pending
          ? "bg-zinc-100 text-zinc-700 dark:bg-white/[0.08] dark:text-zinc-200"
          : "bg-blue-600 text-white shadow-[inset_0_1px_0_rgb(255_255_255/0.2),0_1px_2px_rgb(29_78_216/0.35)] hover:bg-blue-700 active:bg-blue-800 dark:bg-blue-500 dark:active:bg-blue-700 dark:hover:bg-blue-600"
      )}
      disabled={pending || disabled}
      onClick={onSend}
      ref={ref}
      type="button"
    >
      <AnimatePresence initial={false} mode="popLayout">
        {pending ? (
          <motion.span
            animate={{ opacity: 1 }}
            className="flex items-center gap-2"
            exit={{ opacity: 0 }}
            initial={{ opacity: 0 }}
            key="pending"
            transition={{ duration: 0.15 }}
          >
            <span className="relative flex size-5 items-center justify-center">
              <svg
                aria-hidden="true"
                className="absolute inset-0 -rotate-90"
                viewBox="0 0 20 20"
              >
                <circle
                  className="stroke-zinc-300 dark:stroke-zinc-600"
                  cx="10"
                  cy="10"
                  fill="none"
                  r="8"
                  strokeWidth="1.75"
                />
                <motion.circle
                  animate={{ strokeDashoffset: RING }}
                  className="stroke-blue-600 dark:stroke-blue-400"
                  cx="10"
                  cy="10"
                  fill="none"
                  initial={{ strokeDashoffset: 0 }}
                  r="8"
                  strokeDasharray={RING}
                  strokeLinecap="round"
                  strokeWidth="1.75"
                  transition={{ duration: total, ease: "linear" }}
                />
              </svg>
              <span className="relative overflow-hidden font-mono text-[10.5px] tabular-nums">
                <AnimatePresence initial={false} mode="popLayout">
                  <motion.span
                    animate={{ y: 0, opacity: 1 }}
                    className="block"
                    exit={{ y: -6, opacity: 0 }}
                    initial={{ y: 6, opacity: 0 }}
                    key={left}
                    transition={{ duration: 0.2, ease: EASE_OUT }}
                  >
                    {left > 0 ? left : ""}
                  </motion.span>
                </AnimatePresence>
              </span>
            </span>
            Sending
          </motion.span>
        ) : (
          <motion.span
            animate={{ opacity: 1 }}
            className="flex items-center gap-1.5"
            exit={{ opacity: 0 }}
            initial={{ opacity: 0 }}
            key="send"
            transition={{ duration: 0.15 }}
          >
            Send
            {/* Leans forward on hover, as if about to go. */}
            <SendHorizontal
              aria-hidden="true"
              className="size-3.5 transition-transform duration-200 ease-[cubic-bezier(0.23,1,0.32,1)] group-hover/send:translate-x-0.5 motion-reduce:transition-none"
            />
          </motion.span>
        )}
      </AnimatePresence>
    </button>
  );
}

/** Eases the card to its content's height when the content swaps. */
function AutoHeight({
  className,
  children,
}: {
  className?: string;
  children: ReactNode;
}) {
  const innerRef = useRef<HTMLDivElement>(null);
  const [height, setHeight] = useState<number | "auto">("auto");

  useEffect(() => {
    const inner = innerRef.current;
    if (!inner) {
      return;
    }
    const observer = new ResizeObserver(() => setHeight(inner.offsetHeight));
    observer.observe(inner);
    return () => observer.disconnect();
  }, []);

  return (
    <motion.div
      animate={{ height }}
      className={cn("overflow-hidden", className)}
      initial={false}
      transition={{ duration: 0.3, ease: EASE_DRAWER }}
    >
      <div ref={innerRef}>{children}</div>
    </motion.div>
  );
}
```

## Usage

With no `draft` it plays the demo. Pass `draft` and it draws that email; the body follows it as it streams in, until the person types in it, and Send waits while `writing` is true. After Send there are `undoSeconds` to take it back, then `onSend` gets the final text. Return a Promise and it shows sending until it resolves; throw and the draft comes back with your error's message.

The model writes the draft as a tool's input; the person sends it.

```tsx
"use client";

import { isToolUIPart, type UIMessage } from "ai";
import AISend, { type DraftEmail } from "@/components/kokonutui/ai-send";
import { sendEmail } from "@/app/actions"; // your server action

export function DraftPart({ part }: { part: UIMessage["parts"][number] }) {
  if (!isToolUIPart(part) || part.type !== "tool-draft_email") {
    return null;
  }
  const input = (part.input ?? {}) as Partial<DraftEmail>;

  return (
    <AISend
      draft={{
        from: "you@acme.com",
        toName: input.toName ?? "",
        toEmail: input.toEmail ?? "",
        subject: input.subject ?? "",
        body: input.body ?? "",
      }}
      onSend={async (draft) => {
        const result = await sendEmail(draft);
        if (!result.ok) {
          throw new Error(result.message);
        }
      }}
      writing={part.state === "input-streaming"}
    />
  );
}
```

<Demo(mdx/demos/ai-send-stream) />
