"use client"; import { useState } from "react"; import { Eye } from "lucide-react"; import { Dialog, DialogContent, DialogHeader, DialogTitle, } from "@/components/ui/dialog"; import { Button } from "@/components/ui/button"; import { CopyableId } from "@/components/shared/copyable-id"; import { Table, TableBody, TableCell, TableHead, TableHeader, TableRow, } from "@/components/ui/table"; import { Skeleton } from "@/components/ui/skeleton"; import { RelativeTime } from "@/components/shared/relative-time"; import { useMemoryUnit } from "@/hooks/use-memory-unit"; import { useTaskSourceMessages } from "@/hooks/use-task-source-messages"; import { cn } from "@/lib/utils"; import { useI18n } from "@/i18n/i18n-context"; import type { MessageKey, TranslateFn } from "@/i18n/i18n-context"; import { LOCALE_HTML_LANG, type Locale } from "@/i18n/config"; import { formatTimeOfDay } from "@/lib/format-datetime"; import type { MemoryScope, MemoryTask, MemoryTaskStatus } from "@/types/memory"; interface MemoryTasksTableProps { tasks: MemoryTask[]; memoryStoreName: string; } const STATUS_CLASS: Record = { queued: "bg-info-soft text-info", running: "bg-info-soft text-info", completed: "bg-success-soft text-success", failed: "bg-danger-soft text-danger", needs_reconcile: "bg-warning-soft text-warning", }; const STATUS_LABEL_KEY: Record = { queued: "memory.taskStatus.queued", running: "memory.taskStatus.processing", completed: "memory.taskStatus.completed", failed: "memory.taskStatus.failed", needs_reconcile: "memory.taskStatus.needsFix", }; function StatusPill({ status, t, }: { status: MemoryTaskStatus; t: TranslateFn; }) { const labelKey = STATUS_LABEL_KEY[status]; return ( {labelKey ? t(labelKey) : status} ); } function scopeLabel(scope?: MemoryScope): string { if (!scope) return "-"; return ( [scope.appId, scope.tenantId, scope.agentId, scope.runId] .filter(Boolean) .join(" / ") || "-" ); } function toEpochMs(value: string | number | undefined): number | undefined { if (value === undefined || value === null) return undefined; if (typeof value === "number") return value; const ms = new Date(value).getTime(); return Number.isFinite(ms) ? ms : undefined; } function formatTime(value: string | undefined, locale: Locale = "zh"): string { if (!value) return "-"; const ms = toEpochMs(value); if (ms === undefined) return value; return new Date(ms).toLocaleString(LOCALE_HTML_LANG[locale]); } export function MemoryTasksTable({ tasks, memoryStoreName, }: MemoryTasksTableProps) { const { t } = useI18n(); const [selected, setSelected] = useState(null); const [open, setOpen] = useState(false); if (tasks.length === 0) { return (
{t("memory.tasks.empty")}
); } return ( <>
{t("memory.tasks.tableId")} {t("memory.common.scope")} {t("memory.tasks.tableStatus")} {t("memory.tasks.tableAccepted")} {t("memory.tasks.tableExtracted")} {t("memory.tasks.tableUpdatedAt")} {t("memory.tasks.tableActions")} {tasks.map((task) => { const updatedMs = toEpochMs(task.updatedAt); return ( { setSelected(task); setOpen(true); }} > {scopeLabel(task.scope)} {task.acceptedMessages ?? "-"} {task.derivedUnitIds?.length ?? 0} {updatedMs !== undefined ? ( ) : ( "-" )} e.stopPropagation()} > ); })}
); } // --------------------------------------------------------------------------- // Detail dialog // --------------------------------------------------------------------------- interface TaskDetailDialogProps { task: MemoryTask | null; memoryStoreName: string; open: boolean; onOpenChange: (open: boolean) => void; } function TaskDetailDialog({ task, memoryStoreName, open, onOpenChange, }: TaskDetailDialogProps) { const { t } = useI18n(); if (!task) return null; return ( {t("memory.tasks.detailTitle")}

{task.requestId}

{task.lastError && (

{t("memory.tasks.lastError")}

              {task.lastError}
            
)}
); } function TaskMetaSummary({ task }: { task: MemoryTask }) { const { t, locale } = useI18n(); const extractedCount = task.derivedUnitIds?.length ?? 0; return (
{task.acceptedMessages ?? "-"} → {extractedCount}

{t("memory.tasks.metaConversationKey")}

{task.conversationKey ?? "-"}

); } function OriginalMessagesPanel({ task, memoryStoreName, }: { task: MemoryTask; memoryStoreName: string; }) { const { t, locale } = useI18n(); const { messages, isLoading, precise } = useTaskSourceMessages( memoryStoreName, task, ); const renderable = messages.filter( (m) => typeof m.content === "string" && m.content.length > 0, ); return (

{t("memory.tasks.originalMessages")}

{precise ? t("memory.tasks.preciseSource") : t("memory.tasks.windowSource")}
{isLoading ? (
) : renderable.length === 0 ? (

{precise ? t("memory.tasks.noPreciseSource") : t("memory.tasks.noWindowSource")}

) : (
    {renderable.map((msg, idx) => (
  • {msg.role ?? "-"} {msg.speaker && ( {msg.speaker} )} {msg.timestamp && ( {formatTimeOfDay(msg.timestamp, locale)} )}

    {msg.content}

  • ))}
)}
); } function ExtractedMemoriesPanel({ task, memoryStoreName, }: { task: MemoryTask; memoryStoreName: string; }) { const { t } = useI18n(); const ids = task.derivedUnitIds ?? []; return (

{t("memory.tasks.extractedMemories")}

{t("memory.tasks.extractedCount", { count: ids.length })}
{ids.length === 0 ? (

{task.status === "completed" ? t("memory.tasks.noNewMemory") : t("memory.tasks.notYetExtracted")}

) : (
    {ids.map((id) => ( ))}
)}
); } function ExtractedMemoryRow({ memoryStoreName, memoryId, scope, }: { memoryStoreName: string; memoryId: string; scope: MemoryScope; }) { const { t } = useI18n(); const query = useMemoryUnit(memoryStoreName, memoryId, scope); const memory = query.data?.memory; return (
  • {memoryId} {memory?.unit_type && ( {memory.unit_type} )}
    {query.isLoading ? ( ) : memory?.text ? (

    {memory.text}

    ) : (

    {t("memory.tasks.memoryUnreadable")}

    )}
  • ); } function Field({ label, value, mono, children, }: { label: string; value?: string; mono?: boolean; children?: React.ReactNode; }) { return (

    {label}

    {children ? (
    {children}
    ) : (

    {value ?? "-"}

    )}
    ); }