"use client"; import { forwardRef, useCallback, useEffect, useImperativeHandle, useMemo, useRef, useState, } from "react"; import type { ReactNode } from "react"; import { IconCheck, IconInfoCircle, IconRobot, IconUser } from "@tabler/icons-react"; import ReactMarkdown from "react-markdown"; import { useSortable } from "@dnd-kit/sortable"; import { CSS } from "@dnd-kit/utilities"; import type { DraggableAttributes, DraggableSyntheticListeners } from "@dnd-kit/core"; import { toast } from "@/lib/toast/sonner"; import { useTranslation } from "react-i18next"; import { Button } from "@kandev/ui"; import { Textarea } from "@kandev/ui/textarea"; import { cn } from "@/lib/utils"; import { QueueEntryNotFoundError } from "@/lib/api/domains/queue-api"; import { stripSystemTags } from "@/lib/utils/system-tags"; import { SenderTaskBadge, type SenderTaskInfo, } from "@/components/task/chat/messages/sender-task-badge"; import { WorkflowStepMessageBadge, workflowMessageInfoFromMetadata, type WorkflowStepMessageInfo, } from "@/components/task/chat/messages/workflow-step-message-badge"; import { remarkPlugins } from "@/components/shared/markdown-components"; import type { QueuedMessage } from "@/lib/state/slices/session/types"; import type { EntityReference } from "@/lib/types/entity-reference"; import { entityReferencesFromMetadata, survivingEntityReferences, } from "@/lib/entity-references/message-references"; import { buildEntityReferenceMarkdownComponents } from "@/components/task/chat/messages/entity-reference-chip"; import { QueuedGhostRowActions } from "@/components/task/chat/queued-ghost-row-actions"; import { useQueuedMessageOverflow } from "@/components/task/chat/use-queued-message-overflow"; import { AttachmentRow, type QueuedAttachment } from "@/components/task/chat/queued-attachment-row"; import { t } from "@/lib/i18n"; import { useClarificationEscapeGuard } from "@/hooks/use-clarification-escape-guard"; /** Imperative handle for the ghost row, used by chat input "edit last queued" affordance. */ export type QueuedGhostMessageHandle = { startEdit: () => void; }; type SenderKind = "user" | "agent" | "workflow" | "system"; export function isWorkflowQueuedMessage(entry: QueuedMessage): boolean { return ( entry.queued_by === "workflow" || entry.queued_by === "workflow-auto-start" || workflowMessageInfoFromMetadata(entry.metadata) !== null ); } function senderKindOf(entry: QueuedMessage): SenderKind { if (isWorkflowQueuedMessage(entry)) return "workflow"; if (!entry.queued_by) return "system"; // Inter-task messages dispatched via dispatchTaskMessage hardcode // queued_by="agent"; that's the only signal needed. if (entry.queued_by === "agent") return "agent"; return "user"; } /** A message may serve as a merge source or target only when its sender kind is * "user" or "agent". Server-owned rows (queued_by="server") are reserved * backend rows and are never mergeable. */ export function canMergeEntry(entry: QueuedMessage): boolean { if (entry.queued_by === "server") return false; const kind = senderKindOf(entry); return kind === "user" || kind === "agent"; } /** Two messages may merge when both are mergeable and share the same sender * kind. Agent entries additionally require an identical non-empty * sender_task_id; user entries require both rows to be owned by the caller * identity (callerId defaults to the backend's QueuedByUser, which is what the * SPA sends when it omits user_id). Mirrors the backend's mergeAllowed * predicate so the button never appears for merges the server would reject. */ export function canMergeWithAbove( entry: QueuedMessage, above: QueuedMessage | undefined, callerId = "user", ): boolean { if (!above) return false; if (!canMergeEntry(entry) || !canMergeEntry(above)) return false; if (senderKindOf(entry) !== senderKindOf(above)) return false; if (senderKindOf(entry) === "agent") { const senderTaskId = getSenderTaskInfo(entry)?.id; return senderTaskId !== undefined && senderTaskId === getSenderTaskInfo(above)?.id; } if (senderKindOf(entry) === "user") { return callerId !== "" && entry.queued_by === callerId && above.queued_by === callerId; } return false; } function senderLabel(entry: QueuedMessage): string { const kind = senderKindOf(entry); if (kind === "agent") { const title = entry.metadata?.sender_task_title; const sessionName = entry.metadata?.sender_session_name; const base = typeof title === "string" && title.length > 0 ? t("task:fromTask", { title }) : t("task:fromAgent"); return typeof sessionName === "string" && sessionName.length > 0 ? t("task:senderWithSession", { base, sessionName }) : base; } if (kind === "workflow") return t("task:workflowSender"); if (kind === "system") return t("task:systemSender"); return t("task:you"); } type SenderIconProps = { entry: QueuedMessage }; function senderIconFor(kind: SenderKind): { Icon: typeof IconUser; tone: string } { if (kind === "agent") { return { Icon: IconRobot, tone: "text-amber-500 dark:text-amber-400" }; } if (kind === "system") { return { Icon: IconInfoCircle, tone: "text-muted-foreground" }; } if (kind === "workflow") { return { Icon: IconInfoCircle, tone: "text-muted-foreground" }; } return { Icon: IconUser, tone: "text-blue-500 dark:text-blue-300" }; } function SenderIcon({ entry }: SenderIconProps) { const { Icon, tone } = senderIconFor(senderKindOf(entry)); return ; } /** * Returns the inter-task sender info when this entry was queued by another * task's agent (queued_by="agent" + sender_task_id in metadata). User-typed * entries have no SenderTaskInfo — they render with just the IconUser cue. */ function getSenderTaskInfo(entry: QueuedMessage): SenderTaskInfo | null { if (senderKindOf(entry) !== "agent") return null; const meta = entry.metadata as | { sender_task_id?: string; sender_task_title?: string; sender_session_id?: string; sender_session_name?: string; } | undefined; const id = meta?.sender_task_id; if (typeof id !== "string" || id.length === 0) return null; return { id, snapshotTitle: meta?.sender_task_title ?? "", sessionId: meta?.sender_session_id, sessionName: meta?.sender_session_name, }; } function getWorkflowMessageInfo(entry: QueuedMessage): WorkflowStepMessageInfo | null { const info = workflowMessageInfoFromMetadata(entry.metadata); if (info) return info; return entry.queued_by === "workflow" || entry.queued_by === "workflow-auto-start" ? {} : null; } type EditViewProps = { value: string; saving: boolean; attachments: QueuedAttachment[]; onChange: (v: string) => void; onSave: () => void; onCancel: () => void; textareaRef: React.RefObject; }; function EditView({ value, saving, attachments, onChange, onSave, onCancel, textareaRef, }: EditViewProps) { const { t } = useTranslation(); const onKeyDown = (event: React.KeyboardEvent) => { if (event.key === "Escape") { event.preventDefault(); // Claim the key here: once this edit is cancelled, nothing further up // the tree (e.g. a clarification panel's own Escape-collapses handler) // should also react to the same keypress. event.stopPropagation(); onCancel(); } else if (event.key === "Enter" && (event.metaKey || event.ctrlKey)) { event.preventDefault(); onSave(); } }; return (