Skip to content

DeepTutor: Lifelong Personalized Tutoring. https://deeptutor.info/.

28.4 KB
Raw Blame
'use client'
/**
 * Dito — a conversation held at one line of the page.
 *
 * The panel opens on a line (a selection, the line's own "ask" orb, a
 * learning block's Generate) and shows that line's conversation; closing it
 * folds the conversation back onto the line as an orb. It can switch to any
 * other conversation on the page, and the page scrolls to where that one
 * was held.
 *
 * The transcript is the main chat's own component, since the conversation is
 * an ordinary session in the shared runtime. The composer is the notebook's:
 * on a page Dito explains, rewrites and makes learning material in place, so
 * it offers that instead of chat's modes, skills and connectors.
 */
import './note-companion.css'
import Link from 'next/link'
import { usePathname } from 'next/navigation'
import { useCallback, useEffect, useMemo, useRef, useState } from 'react'
import { useTranslation } from 'react-i18next'
import {
  ArrowUp,
  Check,
  FilePlus2,
  Files,
  Languages,
  Lightbulb,
  ListChecks,
  MessageSquareText,
  MessagesSquare,
  Minimize2,
  PenLine,
  Plus,
  Search,
  ShieldCheck,
  Sparkles,
  Square,
  TextQuote,
  X,
  AlignLeft,
  WandSparkles,
} from 'lucide-react'
import { ChatMessageList, RoughActionButton } from '@/features/chat/messages'
import {
  useChatStateAdapter,
  type MessageAttachment,
  type MessageItem,
} from '@/features/chat/ChatStateAdapter'
import { buildSessionActivity } from '@/components/chat/home/SessionActivityPanel'
import SessionViewerPanel, {
  type SessionViewerPanelHandle,
} from '@/components/chat/home/SessionViewerPanel'
import { ChatViewerBridges } from '@/components/chat/home/ChatViewerBridges'
import ModelSelector from '@/components/chat/home/ModelSelector'
import { COMMAND_CONFIRMATION_FAILED } from '@/features/chat/transport/command-delivery'
import { useChatAutoScroll } from '@/hooks/useChatAutoScroll'
import { useMeasuredHeight } from '@/hooks/useMeasuredHeight'
import { useResearchOutlineContinuation } from '@/hooks/useResearchOutlineContinuation'
import { hasPendingAskUser, REPLY_SENT_AS_NEW_MESSAGE } from '@/lib/ask-user-state'
import { copyText } from '@/lib/clipboard'
import { listLLMOptions, type LLMOption } from '@/lib/llm-options'
import type { LLMSelection } from '@/features/chat/model/protocol'
import { notify } from '@/lib/notifications'
import { createNote, noteRequest, saveNote } from '@/lib/notes-api'
import Tooltip from '@/shared/ui/Tooltip'
import { useMenuPopover } from '@/shared/ui/useMenuPopover'
import { resultLearningBlock } from '../model/results'
import { LEARNING_KINDS, learningKind } from '../model/learning-kinds'
import { relativeTime, type NoteThreadView } from '../model/threads'
import type { NoteCompanionProps } from './note-companion-props'

const COMPOSER_FADE = 'linear-gradient(to bottom, #000 calc(100% - 28px), transparent)'
/** What can be made at a line from the composer; a task is not generated. */
const MAKE_KINDS = LEARNING_KINDS.filter(kind => kind.kind !== 'task')

const ABOUT_SELECTION = [
  { label: 'Explain this', prompt: 'Explain this passage in plain words.', Icon: Lightbulb },
  {
    label: 'Rewrite',
    prompt: 'Rewrite this passage more clearly and suggest it as an edit.',
    Icon: PenLine,
  },
  {
    label: 'Make shorter',
    prompt: 'Shorten this passage and suggest it as an edit.',
    Icon: Minimize2,
  },
  { label: 'Give an example', prompt: 'Give a concrete example of this.', Icon: MessageSquareText },
  {
    label: 'Translate',
    prompt: 'Translate this passage and suggest it as an edit.',
    Icon: Languages,
  },
  {
    label: 'Quiz me on this',
    prompt: 'Ask me two questions to check I understand this.',
    Icon: ListChecks,
  },
]
const ABOUT_LINE = [
  {
    label: 'Continue writing here',
    prompt: 'Continue writing from this line and suggest it as an insert.',
    Icon: PenLine,
  },
  { label: 'Explain this part', prompt: 'Explain this part of my notes.', Icon: Lightbulb },
  {
    label: 'Check the facts',
    prompt: 'Check the facts around this line and comment on anything wrong.',
    Icon: ShieldCheck,
  },
  { label: 'Summarize this page', prompt: 'Summarize this page.', Icon: AlignLeft },
]

/** About a card on the page: a learning block, a figure, an embed. */
const ABOUT_CARD = [
  {
    label: 'Walk me through this',
    prompt: 'Walk me through this block: what it shows, step by step, and why it matters.',
    Icon: Lightbulb,
  },
  {
    label: 'Quiz me on this',
    prompt: 'Ask me two questions to check I understand this block.',
    Icon: ListChecks,
  },
  {
    label: 'Improve this block',
    prompt: 'Fix mistakes and fill gaps in this block, and suggest the improved block as an edit.',
    Icon: PenLine,
  },
  {
    label: 'Check the facts',
    prompt: 'Check the facts in this block and comment on anything wrong.',
    Icon: ShieldCheck,
  },
]
const CARD_TYPES = new Set([
  'learning',
  'image',
  'video',
  'audio',
  'file',
  'webCard',
  'htmlEmbed',
  'math',
  'clip',
  'table',
  'codeBlock',
])
const isCard = (kind: string | null) => !!kind && CARD_TYPES.has(kind.split(':')[0])
/** The icon a block is named with: its learning kind's, or a quote mark. */
function BlockIcon({ kind }: { kind: string | null }) {
  const Icon = kind?.startsWith('learning:') ? learningKind(kind.slice(9)).Icon : TextQuote
  return <Icon size={13} strokeWidth={1.8} aria-hidden />
}

function resultBlock(message: MessageItem) {
  const event = [...(message.events || [])].reverse().find(e => e.type === 'result')
  if (!event) return undefined
  const result = (event.metadata || {}) as Record<string, unknown>
  return resultLearningBlock(
    result,
    String(result.response || event.content || message.content || '')
  )
}


export default function NoteCompanion(props: NoteCompanionProps) {
  // Inside /chat's viewer the shared runtime is showing the conversation the
  // learner is in; a second thread here would switch it underneath them.
  const pathname = usePathname() || ''
  if (!pathname.startsWith('/co-writer')) return <EmbeddedNotice {...props} />
  return <ThreadPanel {...props} />
}

function EmbeddedNotice({ pageId, onClose }: NoteCompanionProps) {
  const { t } = useTranslation()
  return (
    <aside className="dt-note-companion" aria-label={t('Dito')}>
      <header className="dt-note-companion-head">
        <Sparkles
          size={15}
          strokeWidth={1.8}
          className="shrink-0 text-[var(--primary)]"
          aria-hidden
        />
        <h2 className="flex-1">{t('Dito')}</h2>
        <button className="dt-note-icon-button" aria-label={t('Close')} onClick={onClose}>
          <X size={16} strokeWidth={1.7} />
        </button>
      </header>
      <div className="dt-note-companion-welcome">
        <p>{t('Dito works beside the page in the notebook, so this conversation stays yours.')}</p>
        <Link className="dt-note-companion-link" href={`/co-writer/${encodeURIComponent(pageId)}`}>
          {t('Open in the notebook')} →
        </Link>
      </div>
    </aside>
  )
}

function ThreadPanel({
  pageId,
  thread,
  bound,
  threads,
  blockText,
  blockKind,
  focus,
  onAskFocus,
  onDismissFocus,
  prefill,
  onSend,
  onMake,
  onRegenerate,
  onSelect,
  onNewHere,
  onJump,
  onSuggestions,
  onClose,
}: NoteCompanionProps) {
  const { t } = useTranslation()
  const {
    state,
    submitUserReply,
    cancelStreamingTurn,
    setLLMSelection,
    deleteTurn,
    editMessage,
    switchBranch,
    loadMessageTrace,
    releaseMessageTrace,
  } = useChatStateAdapter()
  const confirmResearchOutline = useResearchOutlineContinuation()
  const [error, setError] = useState('')
  const [savedPage, setSavedPage] = useState('')
  const [viewerOpen, setViewerOpen] = useState(false)
  const viewerPanelRef = useRef<SessionViewerPanelHandle | null>(null)
  const messages = useMemo(() => (bound ? state.messages : []), [bound, state.messages])
  const streaming = bound && state.isStreaming
  const lastMessage = messages[messages.length - 1]
  const awaitingUserReply = hasPendingAskUser(lastMessage?.events)
  const current = threads.find(item => item.session_id === thread.sessionId)
  const anchorText = blockText(thread.blockId)

  /* ── What a reply can become ──────────────────────────────────────── */
  const insertHere = useCallback(
    (message: MessageItem) => {
      const block = resultBlock(message)
      void noteRequest(`/${pageId}/suggestions`, {
        operation: 'insert',
        // After the line this conversation is about; at the end if it is gone.
        block_id: anchorText === null ? '' : thread.blockId,
        markdown: message.content,
        blocks: block ? [block] : undefined,
        explanation: t('Dito'),
      })
        .then(() => {
          onSuggestions()
          notify(t('Added below the line for your review'))
        })
        .catch(e => setError(String(e)))
    },
    [anchorText, onSuggestions, pageId, t, thread.blockId]
  )
  const saveAsSubpage = useCallback(
    async (message: MessageItem) => {
      try {
        const block = resultBlock(message)
        const doc = await createNote(t('Research notes'), pageId, message.content)
        if (block) await saveNote(doc.id, { blocks: [block], expected_revision: doc.revision })
        setSavedPage(doc.id)
      } catch (err) {
        setError(String(err))
      }
    },
    [pageId, t]
  )
  const replyActions = useCallback(
    (message: MessageItem) => (
      <>
        <RoughActionButton
          icon={FilePlus2}
          label={t('Insert below the line')}
          onClick={() => insertHere(message)}
        />
        <RoughActionButton
          icon={Files}
          label={t('Save as subpage')}
          onClick={() => void saveAsSubpage(message)}
        />
      </>
    ),
    [insertHere, saveAsSubpage, t]
  )

  const submit = useCallback(
    (content: string, make: string | null, again = false) => {
      setError('')
      setSavedPage('')
      if (make) {
        onMake(make, content, again)
        return
      }
      // A turn paused on a question: what was typed is the answer.
      if (awaitingUserReply) {
        void submitUserReply({ text: content })
          .then(sent => {
            if (sent) return
            notify(t(REPLY_SENT_AS_NEW_MESSAGE))
            onSend(content)
          })
          .catch(() => notify(t(COMMAND_CONFIRMATION_FAILED), { tone: 'error' }))
        return
      }
      onSend(content)
    },
    [awaitingUserReply, onMake, onSend, submitUserReply, t]
  )

  /* ── Transcript scrolling: /chat's pin-to-bottom ──────────────────── */
  const { ref: composerBoxRef, height: composerHeight } = useMeasuredHeight<HTMLDivElement>()
  const { containerRef, endRef, shouldAutoScrollRef, handleScroll } = useChatAutoScroll({
    hasMessages: messages.length > 0,
    isStreaming: streaming,
    composerHeight,
    messageCount: messages.length,
    lastMessageContent: lastMessage?.content,
    lastEventCount: lastMessage?.events?.length,
  })
  useEffect(() => {
    if (!streaming) return
    shouldAutoScrollRef.current = true
    const el = containerRef.current
    if (el) el.scrollTop = el.scrollHeight
  }, [containerRef, shouldAutoScrollRef, streaming])

  const activity = useMemo(() => buildSessionActivity(messages), [messages])
  const quote = thread.quote || anchorText || ''
  const anchorKind = blockKind(thread.blockId)
  const starters = thread.quote ? ABOUT_SELECTION : isCard(anchorKind) ? ABOUT_CARD : ABOUT_LINE
  const focusText = focus ? blockText(focus) : null
  const focusTarget =
    focus && focusText !== null
      ? { label: focusText || t('Empty line'), kind: blockKind(focus) }
      : null
  // Opened from a block's "Regenerate…": the first make is that block again.
  const [make, setMake] = useState<string | null>(thread.regenerate?.kind ?? null)
  const [again, setAgain] = useState(Boolean(thread.regenerate))
  return (
    <aside className="dt-note-companion" aria-label={t('Dito')}>
      <header className="dt-note-companion-head">
        <Sparkles
          size={15}
          strokeWidth={1.8}
          className="shrink-0 text-[var(--primary)]"
          aria-hidden
        />
        <div className="min-w-0 flex-1">
          <h2 className="truncate">{current?.title || t('Dito')}</h2>
          <p>
            {streaming
              ? t('Working…')
              : current
                ? relativeTime(current.updated_at, state.language || 'en')
                : t('New conversation')}
          </p>
        </div>
        <ThreadSwitcher
          threads={threads}
          currentId={thread.sessionId}
          blockText={blockText}
          onSelect={onSelect}
        />
        <Tooltip label={t('New conversation at this line')} side="bottom">
          <button
            className="dt-note-icon-button"
            aria-label={t('New conversation at this line')}
            disabled={!messages.length}
            onClick={onNewHere}
          >
            <Plus size={16} strokeWidth={1.7} />
          </button>
        </Tooltip>
        <Tooltip label={t('Fold into the page')} side="bottom">
          <button className="dt-note-icon-button" aria-label={t('Close')} onClick={onClose}>
            <X size={16} strokeWidth={1.7} />
          </button>
        </Tooltip>
      </header>
      <button
        className="dt-note-anchor"
        data-gone={anchorText === null || undefined}
        onClick={onJump}
        disabled={anchorText === null}
      >
        <BlockIcon kind={thread.quote ? null : anchorKind} />
        <span>
          {anchorText === null
            ? t('The line this was about has been deleted')
            : quote || t('Empty line')}
        </span>
      </button>
      <div
        ref={containerRef}
        data-chat-scroll-root="true"
        className="dt-note-companion-thread"
        onScroll={() => {
          const el = containerRef.current
          if (!el) return
          if (el.scrollHeight - el.scrollTop - el.clientHeight < 80)
            shouldAutoScrollRef.current = true
          else if (!streaming) handleScroll()
        }}
        style={{ WebkitMaskImage: COMPOSER_FADE, maskImage: COMPOSER_FADE }}
      >
        {messages.length ? (
          <ChatMessageList
            messages={messages}
            isStreaming={streaming}
            sessionId={state.sessionId}
            language={state.language}
            onCopyAssistantMessage={content => copyText(content)}
            onRegenerateMessage={onRegenerate}
            onDeleteTurn={deleteTurn}
            selectedBranches={state.selectedBranches}
            onEditMessage={editMessage}
            onSwitchBranch={switchBranch}
            onSubmitUserReply={submitUserReply}
            onConfirmOutline={confirmResearchOutline}
            onPreviewAttachment={(attachment: MessageAttachment) => {
              setViewerOpen(true)
              viewerPanelRef.current?.openFileTab(attachment)
            }}
            onLoadMessageTrace={messageId =>
              state.sessionId ? loadMessageTrace(state.sessionId, messageId) : Promise.resolve()
            }
            onReleaseMessageTrace={messageId => {
              if (state.sessionId) releaseMessageTrace(state.sessionId, messageId)
            }}
            showModeBadge={false}
            compactActions
            assistantActions={replyActions}
          />
        ) : (
          <div className="dt-note-companion-welcome">
            <div className="dt-note-starters">
              {starters.map(({ label, prompt, Icon }) => (
                <button key={label} disabled={!bound} onClick={() => submit(t(prompt), null)}>
                  <Icon size={15} strokeWidth={1.7} />
                  {t(label)}
                </button>
              ))}
            </div>
            <p className="dt-note-make-title">{t('Make something here')}</p>
            <div className="dt-note-make-chips">
              {MAKE_KINDS.slice(0, 6).map(kind => (
                <button
                  key={kind.kind}
                  aria-pressed={make === kind.kind}
                  onClick={() => {
                    setMake(kind.kind)
                    setAgain(false)
                  }}
                >
                  <kind.Icon size={13} strokeWidth={1.8} />
                  {t(kind.label)}
                </button>
              ))}
            </div>
          </div>
        )}
        {savedPage && (
          <Link className="dt-note-companion-link" href={`/co-writer/${savedPage}`}>
            {t('Open saved subpage')} →
          </Link>
        )}
        {error && (
          <p role="alert" className="dt-note-companion-error">
            {error}
          </p>
        )}
        <div ref={endRef} className="h-px" />
      </div>
      <div ref={composerBoxRef} className="dt-note-companion-composer">
        <ThreadComposer
          key={thread.key}
          disabled={!bound}
          streaming={streaming}
          awaitingUserReply={awaitingUserReply}
          hasQuote={Boolean(thread.quote)}
          aboutCard={isCard(anchorKind)}
          focus={focusTarget}
          onAskFocus={onAskFocus}
          onDismissFocus={onDismissFocus}
          prefill={prefill}
          make={make}
          again={again && make === thread.regenerate?.kind}
          onMake={kind => {
            setMake(kind)
            if (kind === null) setAgain(false)
          }}
          llmSelection={state.llmSelection}
          onLLMSelectionChange={setLLMSelection}
          onSubmit={(content, kind) => {
            submit(content, kind, again && kind === thread.regenerate?.kind)
            setMake(null)
            setAgain(false)
          }}
          onStop={cancelStreamingTurn}
        />
      </div>
      <SessionViewerPanel
        ref={viewerPanelRef}
        open={viewerOpen}
        sessionId={state.sessionId}
        activity={activity}
        onClose={() => setViewerOpen(false)}
        onAutoOpen={() => setViewerOpen(true)}
      />
      <ChatViewerBridges viewerPanelRef={viewerPanelRef} />
    </aside>
  )
}

/** Every conversation on the page; picking one scrolls the page to its line. */
function ThreadSwitcher({
  threads,
  currentId,
  blockText,
  onSelect,
}: {
  threads: NoteThreadView[]
  currentId: string | null
  blockText: (blockId: string) => string | null
  onSelect: (sessionId: string) => void
}) {
  const { t, i18n } = useTranslation()
  const [open, setOpen] = useState(false)
  const [query, setQuery] = useState('')
  const menu = useMenuPopover<HTMLDivElement>(open, value => {
    setOpen(value)
    if (!value) setQuery('')
  })
  const needle = query.trim().toLowerCase()
  const rows = [...threads]
    .sort((a, b) => b.updated_at - a.updated_at)
    .filter(
      thread =>
        !needle ||
        [thread.label, thread.quote, thread.last_message, blockText(thread.block_id) || '']
          .join(' ')
          .toLowerCase()
          .includes(needle)
    )
  // Positioned against the panel header, not the button: the list must fit
  // inside the panel whatever sits to the button's right.
  return (
    <div ref={menu}>
      <Tooltip label={t('Conversations on this page')} side="bottom" suppressed={open}>
        <button
          className="dt-note-thread-switch"
          aria-haspopup="dialog"
          aria-expanded={open}
          onClick={() => setOpen(!open)}
        >
          <MessagesSquare size={15} strokeWidth={1.7} />
          {threads.length > 0 && <span>{threads.length}</span>}
        </button>
      </Tooltip>
      {open && (
        <div
          className="dt-popover dt-note-thread-list"
          role="dialog"
          aria-label={t('Conversations on this page')}
        >
          <label className="dt-note-thread-search">
            <Search size={13} strokeWidth={1.8} aria-hidden />
            <input
              autoFocus
              value={query}
              placeholder={t('Search conversations on this page…')}
              onChange={e => setQuery(e.target.value)}
            />
          </label>
          <div className="dt-note-thread-list-rows">
            {rows.map(thread => {
              const line = blockText(thread.block_id)
              return (
                <button
                  key={thread.session_id}
                  className="dt-note-thread-row-main"
                  aria-current={thread.session_id === currentId || undefined}
                  onClick={() => {
                    setOpen(false)
                    setQuery('')
                    onSelect(thread.session_id)
                  }}
                >
                  <span className="dt-note-thread-row-head">
                    <span className="dt-note-orb is-static" data-state={thread.state} aria-hidden />
                    <strong>{thread.label}</strong>
                    <time>{relativeTime(thread.updated_at, i18n.language)}</time>
                  </span>
                  <span className="dt-note-thread-row-line">
                    {line === null ? t('Deleted line') : thread.quote || line || t('Empty line')}
                  </span>
                </button>
              )
            })}
            {!rows.length && (
              <p className="dt-note-menu-empty">
                {t(
                  threads.length ? 'No matching conversations' : 'No conversations on this page yet'
                )}
              </p>
            )}
          </div>
        </div>
      )}
    </div>
  )
}

/** The notebook's composer: say what you want here, or make something here. */
function ThreadComposer({
  disabled,
  streaming,
  awaitingUserReply,
  hasQuote,
  aboutCard,
  focus,
  onAskFocus,
  onDismissFocus,
  prefill,
  make,
  again,
  onMake,
  llmSelection,
  onLLMSelectionChange,
  onSubmit,
  onStop,
}: {
  disabled: boolean
  streaming: boolean
  awaitingUserReply: boolean
  hasQuote: boolean
  aboutCard: boolean
  focus: { label: string; kind: string | null } | null
  onAskFocus: (draft: string) => void
  onDismissFocus: () => void
  prefill: { id: number; text: string } | null
  make: string | null
  /** The make fills the block being regenerated, not a new one below. */
  again: boolean
  onMake: (kind: string | null) => void
  llmSelection: LLMSelection | null
  onLLMSelectionChange: (value: LLMSelection | null) => void
  onSubmit: (content: string, make: string | null) => void
  onStop: () => void
}) {
  const { t } = useTranslation()
  const [text, setText] = useState('')
  const input = useRef<HTMLTextAreaElement>(null)
  const [menuOpen, setMenuOpen] = useState(false)
  const menu = useMenuPopover<HTMLDivElement>(menuOpen, setMenuOpen)
  const [options, setOptions] = useState<LLMOption[]>([])
  const [activeDefault, setActiveDefault] = useState<LLMSelection | null>(null)
  const [optionsState, setOptionsState] = useState<'loading' | 'error' | 'ready'>('loading')
  const fetchOptions = useCallback(
    () =>
      listLLMOptions()
        .then(payload => {
          setOptions(payload.options)
          setActiveDefault(payload.active)
          setOptionsState('ready')
        })
        .catch(() => setOptionsState('error')),
    []
  )
  useEffect(() => {
    void fetchOptions()
  }, [fetchOptions])
  // A prompt handed over from the page lands in the box once, to be finished.
  const [prefilled, setPrefilled] = useState<number | null>(null)
  if (prefill && prefill.id !== prefilled) {
    setPrefilled(prefill.id)
    setText(prefill.text)
  }
  useEffect(() => {
    if (prefill) requestAnimationFrame(() => input.current?.focus())
  }, [prefill])
  useEffect(() => {
    if (!disabled) requestAnimationFrame(() => input.current?.focus({ preventScroll: true }))
  }, [disabled])
  useEffect(() => {
    if (make) input.current?.focus()
  }, [make])
  // Grow with the text up to a third of the panel.
  useEffect(() => {
    const el = input.current
    if (!el) return
    el.style.height = 'auto'
    el.style.height = `${Math.min(el.scrollHeight, 220)}px`
  }, [text])
  const target = make ? learningKind(make) : null
  const canSend =
    !disabled && (text.trim().length > 0 || Boolean(make)) && (!streaming || awaitingUserReply)
  const submit = () => {
    if (!canSend) return
    onSubmit(text.trim(), make)
    setText('')
  }
  return (
    <div className="dt-note-composer" data-disabled={disabled || undefined}>
      {focus && !target && (
        <div className="dt-note-composer-focus">
          <button
            className="dt-note-composer-focus-ask"
            onClick={() => {
              onAskFocus(text.trim())
              setText('')
            }}
          >
            <BlockIcon kind={focus.kind} />
            <span className="dt-note-composer-focus-label">{focus.label}</span>
            <span className="dt-note-composer-focus-cta">{t('Ask about this')}</span>
          </button>
          <button aria-label={t('Dismiss')} onClick={onDismissFocus}>
            <X size={12} strokeWidth={2} />
          </button>
        </div>
      )}
      {target && (
        <div className="dt-note-composer-target">
          <target.Icon size={13} strokeWidth={1.8} aria-hidden />
          <span>
            {again
              ? t('Regenerate this {{kind}}', { kind: t(target.label) })
              : t('Make a {{kind}} below this line', { kind: t(target.label) })}
          </span>
          <button aria-label={t('Cancel')} onClick={() => onMake(null)}>
            <X size={12} strokeWidth={2} />
          </button>
        </div>
      )}
      <textarea
        ref={input}
        rows={1}
        value={text}
        disabled={disabled}
        aria-label={t('Message Dito')}
        placeholder={t(
          target
            ? target.placeholder
            : awaitingUserReply
              ? 'Answer Dito…'
              : hasQuote
                ? 'Ask about the selection, or say how to change it…'
                : aboutCard
                  ? 'Ask about this block, or say how to change it…'
                  : 'Ask about this line, or tell Dito what to write…'
        )}
        onChange={e => setText(e.target.value)}
        onKeyDown={e => {
          if (e.key === 'Enter' && !e.shiftKey && !e.nativeEvent.isComposing) {
            e.preventDefault()
            submit()
          }
          if (e.key === 'Backspace' && !text && make) onMake(null)
        }}
      />
      <div className="dt-note-composer-bar">
        <div ref={menu} className="relative">
          <button
            className="dt-note-composer-make"
            aria-haspopup="menu"
            aria-expanded={menuOpen}
            aria-pressed={Boolean(make)}
            disabled={disabled}
            onClick={() => setMenuOpen(!menuOpen)}
          >
            <WandSparkles size={14} strokeWidth={1.8} />
            {t('Make')}
          </button>
          {menuOpen && (
            <div className="dt-popover dt-note-kind-menu is-up" role="menu">
              <p className="dt-note-kind-menu-title">{t('Make below this line')}</p>
              {MAKE_KINDS.map(kind => (
                <button
                  key={kind.kind}
                  role="menuitemradio"
                  aria-checked={make === kind.kind}
                  className="dt-menu-item"
                  onClick={() => {
                    setMenuOpen(false)
                    onMake(kind.kind)
                  }}
                >
                  <kind.Icon size={14} strokeWidth={1.8} />
                  <span className="flex-1">{t(kind.label)}</span>
                  {make === kind.kind && <Check size={13} />}
                </button>
              ))}
            </div>
          )}
        </div>
        <span className="flex-1" />
        <ModelSelector
          options={options}
          activeDefault={activeDefault}
          value={llmSelection}
          loading={optionsState === 'loading'}
          error={optionsState === 'error'}
          onChange={onLLMSelectionChange}
          onRefresh={() => {
            setOptionsState('loading')
            void fetchOptions()
          }}
        />
        {streaming && !awaitingUserReply ? (
          <Tooltip label={t('Stop')}>
            <button
              className="dt-note-composer-send is-stop"
              aria-label={t('Stop')}
              onClick={onStop}
            >
              <Square size={11} fill="currentColor" />
            </button>
          </Tooltip>
        ) : (
          <button
            className="dt-note-composer-send"
            aria-label={t(make ? 'Make' : 'Send')}
            disabled={!canSend}
            onClick={submit}
          >
            {make ? <Sparkles size={14} /> : <ArrowUp size={15} strokeWidth={2} />}
          </button>
        )}
      </div>
    </div>
  )
}