@vertesia/ui 1.0.0-dev.20260305.083323Z → 1.0.0-dev.20260331.091034Z

package/src/features/agent/chat/VegaLiteChart.tsx

@@ -6,6 +6,7 @@ import { VegaEmbed } from 'react-vega';
 import type { View } from 'vega';
 import type { TopLevelSpec as VisualizationSpec } from 'vega-lite';
 import { cn } from '../../../core/components/libs/utils';
+import { useUITranslation } from '../../../i18n/index.js';
 import { useUserSession } from '@vertesia/ui/session';
 import type { VegaLiteChartSpec } from './AgentChart';
 import { getArtifactCacheKey, getFileCacheKey, useArtifactUrlCache } from './useArtifactUrlCache';
@@ -52,6 +53,7 @@ function FullscreenDialog({
     description?: string;
     children: React.ReactNode;
 }) {
+    const { t } = useUITranslation();
     return (
         <DialogPrimitive.Root open={isOpen} onOpenChange={(open) => !open && onClose()}>
             <DialogPrimitive.Portal>
@@ -67,7 +69,7 @@ function FullscreenDialog({
                         <button
                             onClick={onClose}
                             className="absolute top-3 right-3 z-10 p-2 rounded-lg bg-white/80 dark:bg-gray-800/80 backdrop-blur-sm hover:bg-gray-100 dark:hover:bg-gray-700 transition-colors duration-150 shadow-sm"
-                            aria-label="Close fullscreen"
+                            aria-label={t('agent.closeFullscreen')}
                         >
                             <X className="w-5 h-5 text-gray-600 dark:text-gray-300" />
                         </button>
@@ -80,7 +82,7 @@ function FullscreenDialog({
                     <div className="flex items-center justify-between px-4 sm:px-6 py-3 border-t border-gray-200 dark:border-gray-800 bg-gray-50/50 dark:bg-gray-800/50 rounded-b-xl">
                         <div className="flex flex-col">
                             <DialogPrimitive.Title className="text-base font-semibold text-gray-900 dark:text-gray-100">
-                                {title || 'Dashboard'}
+                                {title || t('agent.dashboard')}
                             </DialogPrimitive.Title>
                             {description && (
                                 <DialogPrimitive.Description className="text-sm text-gray-500 dark:text-gray-400 mt-0.5">
@@ -540,6 +542,7 @@ function getDarkModeConfig(isDark: boolean): Record<string, any> {
 }
 
 export const VegaLiteChart = memo(function VegaLiteChart({ spec, artifactRunId }: VegaLiteChartProps) {
+    const { t } = useUITranslation();
     const { title, description, spec: vegaSpec, options } = spec;
     const [isExporting, setIsExporting] = useState(false);
     const [isCopied, setIsCopied] = useState(false);
@@ -581,6 +584,15 @@ export const VegaLiteChart = memo(function VegaLiteChart({ spec, artifactRunId }
             return;
         }
 
+        if (!artifactRunId) {
+            console.warn('[VegaLiteChart] artifact references found but artifactRunId is missing!', {
+                references: references.map(r => r.artifactPath),
+                artifactRunId,
+            });
+        } else {
+            console.info('[VegaLiteChart] resolving artifacts with runId:', artifactRunId, references.map(r => r.artifactPath));
+        }
+
         let cancelled = false;
         setIsLoadingArtifacts(true);
         setArtifactError(null);
@@ -903,28 +915,28 @@ export const VegaLiteChart = memo(function VegaLiteChart({ spec, artifactRunId }
                 onClick={handleCopy}
                 disabled={isCopied}
                 className="text-xs px-2 py-1 rounded border border-gray-300 dark:border-gray-700 bg-gray-100 dark:bg-gray-800 text-gray-700 dark:text-gray-300 hover:bg-gray-200 dark:hover:bg-gray-700 cursor-pointer transition-colors disabled:opacity-50 flex items-center gap-1"
-                title="Copy to clipboard"
+                title={t('agent.copyToClipboard')}
             >
                 {isCopied ? <Check className="w-3 h-3" /> : <Copy className="w-3 h-3" />}
-                {isCopied ? 'Copied' : 'Copy'}
+                {isCopied ? t('agent.copied') : t('agent.copy')}
             </button>
             <button
                 onClick={handleExport}
                 disabled={isExporting}
                 className="text-xs px-2 py-1 rounded border border-gray-300 dark:border-gray-700 bg-gray-100 dark:bg-gray-800 text-gray-700 dark:text-gray-300 hover:bg-gray-200 dark:hover:bg-gray-700 cursor-pointer transition-colors disabled:opacity-50 disabled:cursor-not-allowed flex items-center gap-1"
-                title="Export as PNG"
+                title={t('agent.exportAsPng')}
             >
                 <Download className="w-3 h-3" />
-                {isExporting ? 'Exporting...' : 'Export'}
+                {isExporting ? t('agent.exporting') : t('agent.export')}
             </button>
             {showFullscreenButton && (
                 <button
                     onClick={toggleFullscreen}
                     className="text-xs px-2 py-1 rounded border border-gray-300 dark:border-gray-700 bg-gray-100 dark:bg-gray-800 text-gray-700 dark:text-gray-300 hover:bg-gray-200 dark:hover:bg-gray-700 cursor-pointer transition-colors flex items-center gap-1"
-                    title={isFullscreen ? "Exit fullscreen" : "Fullscreen"}
+                    title={isFullscreen ? t('agent.exitFullscreen') : t('agent.fullscreen')}
                 >
                     {isFullscreen ? <Minimize2 className="w-3 h-3" /> : <Maximize2 className="w-3 h-3" />}
-                    {isFullscreen ? 'Exit' : 'Fullscreen'}
+                    {isFullscreen ? t('agent.exit') : t('agent.fullscreen')}
                 </button>
             )}
         </div>

package/src/features/agent/chat/hooks/useAgentPlans.ts

@@ -42,11 +42,12 @@ export function useAgentPlans(
             setPlans([]);
             setActivePlanIndex(0);
             setWorkstreamStatusMap(new Map());
-            setShowSlidingPanel(false);
+            // Keep right panel open by default on desktop sessions.
+            setShowSlidingPanel(!isModal);
             lastProcessedIndex.current = -1;
             knownPlanTimestamps.current.clear();
         }
-    }, [messages.length === 0]);
+    }, [messages.length === 0, isModal]);
 
     // Process new messages incrementally
     useEffect(() => {
@@ -157,13 +158,6 @@ export function useAgentPlans(
         }
     }, [plans.length, showSlidingPanel]);
 
-    // Hide panel when there are no plans
-    useEffect(() => {
-        if (plans.length === 0) {
-            setShowSlidingPanel(false);
-        }
-    }, [plans.length]);
-
     // Helper to determine showInput from the latest message
     const updateShowInput = useCallback((msgs: AgentMessage[]) => {
         const lastMessage = msgs[msgs.length - 1];

package/src/features/agent/chat/hooks/useAgentStream.ts

@@ -1,5 +1,5 @@
 import { useCallback, useEffect, useRef, useState } from 'react';
-import { AsyncExecutionResult, VertesiaClient } from '@vertesia/client';
+import { VertesiaClient } from '@vertesia/client';
 import {
     AgentMessage,
     AgentMessageType,
@@ -30,6 +30,8 @@ export interface UseAgentStreamResult {
     removeOptimisticMessages: (predicate: (msg: AgentMessage) => boolean) => void;
     /** Workflow status fetched from API (RUNNING, COMPLETED, FAILED, etc.) */
     workflowStatus: string | null;
+    /** Temporal workflow run ID (first_workflow_run_id from AgentRun) */
+    workflowRunId: string | null;
     /** Server-side file processing status updates (from SYSTEM messages) */
     serverFileUpdates: Map<string, ConversationFile>;
 }
@@ -44,18 +46,19 @@ export interface UseAgentStreamResult {
  * - COMPLETE/IDLE streaming flush
  * - Timestamp-based message dedup and optimistic QUESTION replacement
  * - `isCompleted` derived state
- * - State reset when `run.runId` changes
+ * - State reset when `agentRunId` changes
  *
  * File-processing SYSTEM messages are passed through to the messages array
  * (Option A from the plan) so downstream hooks can react to them.
  */
 export function useAgentStream(
     client: VertesiaClient,
-    run: AsyncExecutionResult,
+    agentRunId: string,
 ): UseAgentStreamResult {
     const [messages, setMessages] = useState<AgentMessage[]>([]);
     const [isCompleted, setIsCompleted] = useState(false);
     const [workflowStatus, setWorkflowStatus] = useState<string | null>(null);
+    const [workflowRunId, setWorkflowRunId] = useState<string | null>(null);
 
     // Server-side file processing status updates
     const [serverFileUpdates, setServerFileUpdates] = useState<Map<string, ConversationFile>>(new Map());
@@ -65,12 +68,24 @@ export function useAgentStream(
 
     // RAF-batched streaming updates
     const pendingStreamingChunks = useRef<Map<string, StreamingData>>(new Map());
-    const streamingFlushScheduled = useRef<number | null>(null);
+    const streamingFlushScheduled = useRef<{ mode: 'raf' | 'timeout'; id: number } | null>(null);
 
     // Debug: visual flash indicator for incoming chunks
     const [debugChunkFlash, setDebugChunkFlash] = useState(false);
     const debugFlashTimeout = useRef<ReturnType<typeof setTimeout> | null>(null);
 
+    const cancelScheduledStreamingFlush = useCallback(() => {
+        const scheduled = streamingFlushScheduled.current;
+        if (!scheduled) return;
+
+        if (scheduled.mode === 'raf') {
+            cancelAnimationFrame(scheduled.id);
+        } else {
+            clearTimeout(scheduled.id);
+        }
+        streamingFlushScheduled.current = null;
+    }, []);
+
     const flushStreamingChunks = useCallback(() => {
         if (pendingStreamingChunks.current.size > 0) {
             setStreamingMessages(new Map(pendingStreamingChunks.current));
@@ -88,22 +103,32 @@ export function useAgentStream(
 
     // Stream messages from the agent
     useEffect(() => {
-        // Reset all state when runId changes (new agent)
+        // Reset all state when agentRunId changes (new agent)
+        console.debug('[useAgentStream] effect:start', { agentRunId });
         setMessages([]);
         setWorkflowStatus(null);
+        setWorkflowRunId(null);
         setStreamingMessages(new Map());
         setServerFileUpdates(new Map());
+        const abortController = new AbortController();
 
-        // Check workflow status
-        client.store.workflows.getRunDetails(run.runId, run.workflowId)
-            .then((statusResult) => {
-                setWorkflowStatus(statusResult.status as string);
+        // Check agent run status
+        client.agents.getInternals(agentRunId)
+            .then((agentRun) => {
+                if (!abortController.signal.aborted) {
+                    setWorkflowStatus(agentRun.status?.toUpperCase() ?? null);
+                    setWorkflowRunId(agentRun.first_workflow_run_id ?? null);
+                }
             })
             .catch((error) => {
-                console.error('Failed to check workflow status:', error);
+                if (!abortController.signal.aborted) {
+                    console.error('Failed to check agent run status:', error);
+                }
             });
 
-        client.store.workflows.streamMessages(run.workflowId, run.runId, (message) => {
+        client.agents.streamMessages(agentRunId, (message) => {
+            if (abortController.signal.aborted) return;
+
             // Handle streaming chunks separately for real-time aggregation
             // PERFORMANCE: Batch updates using RAF instead of immediate state updates
             if (message.type === AgentMessageType.STREAMING_CHUNK) {
@@ -130,7 +155,17 @@ export function useAgentStream(
 
                 // Schedule a flush if not already scheduled (~60 updates/sec max)
                 if (streamingFlushScheduled.current === null) {
-                    streamingFlushScheduled.current = requestAnimationFrame(flushStreamingChunks);
+                    if (document.hidden) {
+                        streamingFlushScheduled.current = {
+                            mode: 'timeout',
+                            id: window.setTimeout(flushStreamingChunks, 16),
+                        };
+                    } else {
+                        streamingFlushScheduled.current = {
+                            mode: 'raf',
+                            id: requestAnimationFrame(flushStreamingChunks),
+                        };
+                    }
                 }
                 return;
             }
@@ -176,7 +211,15 @@ export function useAgentStream(
                 }
             }
 
-            if (message.message) {
+            const hasContent = !!message.message;
+            const isStateMessage = [
+                AgentMessageType.COMPLETE,
+                AgentMessageType.IDLE,
+                AgentMessageType.TERMINATED,
+                AgentMessageType.REQUEST_INPUT,
+            ].includes(message.type);
+
+            if (hasContent || isStateMessage) {
                 setMessages((prev) => {
                     // Check for duplicate by timestamp
                     if (prev.find((m) => m.timestamp === message.timestamp)) {
@@ -196,17 +239,40 @@ export function useAgentStream(
                     return [...prev];
                 });
             }
-        });
+        }, undefined, abortController.signal)
+            .catch((error) => {
+                if (!abortController.signal.aborted) {
+                    console.error('Failed to stream agent messages:', error);
+                }
+            });
 
         return () => {
+            console.debug('[useAgentStream] effect:cleanup', { agentRunId });
+            abortController.abort();
             setMessages([]);
-            if (streamingFlushScheduled.current !== null) {
-                cancelAnimationFrame(streamingFlushScheduled.current);
-                streamingFlushScheduled.current = null;
-            }
+            cancelScheduledStreamingFlush();
             pendingStreamingChunks.current.clear();
+            if (debugFlashTimeout.current) {
+                clearTimeout(debugFlashTimeout.current);
+                debugFlashTimeout.current = null;
+            }
+        };
+    }, [agentRunId, client.agents, flushStreamingChunks, cancelScheduledStreamingFlush]);
+
+    // Flush pending streaming chunks when tab becomes visible.
+    useEffect(() => {
+        const handleVisibilityChange = () => {
+            if (!document.hidden && pendingStreamingChunks.current.size > 0) {
+                cancelScheduledStreamingFlush();
+                flushStreamingChunks();
+            }
+        };
+
+        document.addEventListener('visibilitychange', handleVisibilityChange);
+        return () => {
+            document.removeEventListener('visibilitychange', handleVisibilityChange);
         };
-    }, [run.runId, client.store.workflows, flushStreamingChunks]);
+    }, [flushStreamingChunks, cancelScheduledStreamingFlush]);
 
     // Add an optimistic message to the timeline
     const addOptimisticMessage = useCallback((msg: AgentMessage) => {
@@ -234,6 +300,7 @@ export function useAgentStream(
         addOptimisticMessage,
         removeOptimisticMessages,
         workflowStatus,
+        workflowRunId,
         serverFileUpdates,
     };
 }

package/src/features/agent/chat/hooks/useArtifacts.ts

@@ -0,0 +1,151 @@
+import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
+import { VertesiaClient } from '@vertesia/client';
+
+// ---------------------------------------------------------------------------
+// Tree node type
+// ---------------------------------------------------------------------------
+
+export interface ArtifactTreeNode {
+    /** Display name — e.g. "out", "report.csv" */
+    name: string;
+    /** Full relative path from the run root — e.g. "out/subdir/report.csv" */
+    path: string;
+    isDirectory: boolean;
+    children: ArtifactTreeNode[];
+}
+
+// ---------------------------------------------------------------------------
+// Internal files we never show to the user
+// ---------------------------------------------------------------------------
+
+const INTERNAL_FILE_PATTERNS = [
+    /conversation\.json$/,
+    /-conversation\.json$/,
+    /^tools\.json$/,
+];
+
+function isInternalFile(relativePath: string): boolean {
+    const basename = relativePath.split('/').pop() ?? relativePath;
+    return INTERNAL_FILE_PATTERNS.some((re) => re.test(basename));
+}
+
+// ---------------------------------------------------------------------------
+// Build a tree from a flat list of relative paths
+// ---------------------------------------------------------------------------
+
+function buildTree(paths: string[]): ArtifactTreeNode[] {
+    const root: ArtifactTreeNode = { name: '', path: '', isDirectory: true, children: [] };
+
+    for (const p of paths) {
+        const parts = p.split('/');
+        let current = root;
+        let accumulated = '';
+
+        for (let i = 0; i < parts.length; i++) {
+            const part = parts[i];
+            accumulated = accumulated ? `${accumulated}/${part}` : part;
+            const isLast = i === parts.length - 1;
+
+            let child = current.children.find((c) => c.name === part);
+            if (!child) {
+                child = {
+                    name: part,
+                    path: accumulated,
+                    isDirectory: !isLast,
+                    children: [],
+                };
+                current.children.push(child);
+            }
+            current = child;
+        }
+    }
+
+    // Sort: directories first, then alphabetical
+    const sortChildren = (node: ArtifactTreeNode) => {
+        node.children.sort((a, b) => {
+            if (a.isDirectory !== b.isDirectory) return a.isDirectory ? -1 : 1;
+            return a.name.localeCompare(b.name);
+        });
+        node.children.forEach(sortChildren);
+    };
+    sortChildren(root);
+
+    return root.children;
+}
+
+/**
+ * Extract the run-relative path from an artifact listing entry.
+ * The list API may return paths prefixed with the bucket name
+ * (e.g. "store_dev_.../agents/{runId}/files/foo.txt"), so we search
+ * for the "agents/{runId}/" segment anywhere in the string rather
+ * than assuming it starts at index 0.
+ */
+function stripToRelativePath(fullPath: string, runId: string): string {
+    const prefix = `agents/${runId}/`;
+    const idx = fullPath.indexOf(prefix);
+    if (idx !== -1) return fullPath.slice(idx + prefix.length);
+    return fullPath.split('/').pop() ?? fullPath;
+}
+
+// ---------------------------------------------------------------------------
+// Hook
+// ---------------------------------------------------------------------------
+
+export interface UseArtifactsResult {
+    tree: ArtifactTreeNode[];
+    flatFiles: string[];
+    isLoading: boolean;
+    error: string | null;
+    refresh: () => void;
+}
+
+export function useArtifacts(
+    client: VertesiaClient,
+    runId: string | undefined,
+    refreshKey = 0,
+): UseArtifactsResult {
+    const [flatFiles, setFlatFiles] = useState<string[]>([]);
+    const [isLoading, setIsLoading] = useState(false);
+    const [error, setError] = useState<string | null>(null);
+    const [manualRefreshKey, setManualRefreshKey] = useState(0);
+    const fetchIdRef = useRef(0);
+
+    const fetchArtifacts = useCallback(async () => {
+        if (!runId) return;
+
+        const fetchId = ++fetchIdRef.current;
+        setIsLoading(true);
+        setError(null);
+
+        try {
+            const paths = await client.files.listArtifacts(runId);
+            if (fetchId !== fetchIdRef.current) return; // stale
+
+            const relatives = paths
+                .map((p) => stripToRelativePath(p, runId))
+                .filter((p) => p && !isInternalFile(p));
+
+            setFlatFiles(relatives);
+        } catch (err) {
+            if (fetchId !== fetchIdRef.current) return;
+            setError(err instanceof Error ? err.message : 'Failed to list artifacts');
+            setFlatFiles([]);
+        } finally {
+            if (fetchId === fetchIdRef.current) {
+                setIsLoading(false);
+            }
+        }
+    }, [client, runId]);
+
+    useEffect(() => {
+        fetchArtifacts();
+    }, [fetchArtifacts, refreshKey, manualRefreshKey]);
+
+    const tree = useMemo(() => buildTree(flatFiles), [flatFiles]);
+
+    const refresh = useCallback(() => {
+        setManualRefreshKey((k) => k + 1);
+    }, []);
+
+    return { tree, flatFiles, isLoading, error, refresh };
+}

package/src/features/agent/chat/hooks/useDocumentPanel.ts

@@ -13,6 +13,43 @@ export interface UseDocumentPanelResult {
     openDocInPanel: (docId: string) => void;
 }
 
+function toNonEmptyString(value: unknown): string | undefined {
+    if (typeof value === 'string' && value.trim().length > 0) {
+        return value;
+    }
+    return undefined;
+}
+
+function getRevisionRootId(details: Record<string, unknown>, fallbackId: string): string {
+    const directRootId =
+        toNonEmptyString(details.revision_root_id) ||
+        toNonEmptyString(details.revision_root) ||
+        toNonEmptyString(details.root_document_id) ||
+        toNonEmptyString(details.root_id);
+    if (directRootId) return directRootId;
+
+    const revisionInfo = details.revision_info;
+    if (revisionInfo && typeof revisionInfo === 'object') {
+        const rootFromRevisionInfo = toNonEmptyString((revisionInfo as Record<string, unknown>).root);
+        if (rootFromRevisionInfo) return rootFromRevisionInfo;
+    }
+
+    return fallbackId;
+}
+
+function isSameRevisionChain(existing: OpenDocument, incoming: OpenDocument): boolean {
+    if (existing.revisionRootId && incoming.revisionRootId) {
+        return existing.revisionRootId === incoming.revisionRootId;
+    }
+    if (incoming.revisionRootId) {
+        return existing.id === incoming.revisionRootId;
+    }
+    if (existing.revisionRootId) {
+        return existing.revisionRootId === incoming.id;
+    }
+    return existing.id === incoming.id;
+}
+
 /**
  * Hook that manages the document side panel.
  *
@@ -52,14 +89,37 @@ export function useDocumentPanel(messages: AgentMessage[]): UseDocumentPanelResu
             if (message.type === AgentMessageType.UPDATE && message.details) {
                 const details = message.details as Record<string, unknown>;
                 if (details.event_class === 'document_created' || details.event_class === 'document_updated') {
-                    const docId = details.document_id as string;
+                    const sourceDocId = toNonEmptyString(details.document_id);
+                    const updatedDocId = toNonEmptyString(details.updated_document_id);
+                    const docId = updatedDocId || sourceDocId;
                     const docTitle = details.title as string;
                     if (docId) {
+                        const revisionRootId = getRevisionRootId(details, sourceDocId || docId);
+                        const incomingDoc: OpenDocument = {
+                            id: docId,
+                            title: docTitle || 'Document',
+                            revisionRootId,
+                        };
                         setOpenDocuments(prev => {
-                            if (prev.some(d => d.id === docId)) return prev;
-                            return [...prev, { id: docId, title: docTitle || 'Document' }];
+                            const existingIndex = prev.findIndex(doc => isSameRevisionChain(doc, incomingDoc));
+                            if (existingIndex < 0) {
+                                return [...prev, incomingDoc];
+                            }
+
+                            const existing = prev[existingIndex];
+                            if (
+                                existing.id === incomingDoc.id &&
+                                existing.title === incomingDoc.title &&
+                                existing.revisionRootId === incomingDoc.revisionRootId
+                            ) {
+                                return prev;
+                            }
+
+                            const next = [...prev];
+                            next[existingIndex] = incomingDoc;
+                            return next;
                         });
-                        setActiveDocumentId(docId);
+                        setActiveDocumentId(incomingDoc.id);
                         setIsDocPanelOpen(true);
                         if (details.event_class === 'document_updated') {
                             setDocRefreshKey(k => k + 1);
@@ -99,7 +159,7 @@ export function useDocumentPanel(messages: AgentMessage[]): UseDocumentPanelResu
     const openDocInPanel = useCallback((docId: string) => {
         setOpenDocuments(prev => {
             if (prev.some(d => d.id === docId)) return prev;
-            return [...prev, { id: docId, title: 'Document' }];
+            return [...prev, { id: docId, title: 'Document', revisionRootId: docId }];
         });
         setActiveDocumentId(docId);
         setIsDocPanelOpen(true);

package/src/features/agent/chat/hooks/useFileProcessing.ts

@@ -1,10 +1,11 @@
 import { useCallback, useEffect, useMemo, useState } from 'react';
-import { AsyncExecutionResult, VertesiaClient } from '@vertesia/client';
+import { VertesiaClient } from '@vertesia/client';
 import {
     ConversationFile,
     ConversationFileRef,
     FileProcessingStatus,
 } from '@vertesia/common';
+import { i18nInstance, NAMESPACE } from '../../../../i18n/instance.js';
 
 export interface UseFileProcessingResult {
     processingFiles: Map<string, ConversationFile>;
@@ -20,24 +21,25 @@ type ToastFn = (opts: { status: 'success' | 'error' | 'warning' | 'info'; title:
  * Combines local optimistic upload state with server-side processing
  * status updates (from `useAgentStream.serverFileUpdates`).
  *
- * @param client - Vertesia client for artifact uploads and workflow signals
- * @param run - Current workflow execution
+ * @param client - Vertesia client for artifact uploads and agent signals
+ * @param agentRunId - Stable AgentRun ID
  * @param serverFileUpdates - Server-side file processing updates from useAgentStream
  * @param toast - Toast notification function for error display
  */
 export function useFileProcessing(
     client: VertesiaClient,
-    run: AsyncExecutionResult,
+    agentRunId: string,
     serverFileUpdates: Map<string, ConversationFile>,
     toast: ToastFn,
 ): UseFileProcessingResult {
+    const t = i18nInstance.getFixedT(null, NAMESPACE);
     // Local optimistic file state (uploads initiated from the UI)
     const [localFiles, setLocalFiles] = useState<Map<string, ConversationFile>>(new Map());
 
-    // Reset when run changes
+    // Reset when agentRunId changes
     useEffect(() => {
         setLocalFiles(new Map());
-    }, [run.runId]);
+    }, [agentRunId]);
 
     // Merge local + server state (server takes precedence for same IDs)
     const processingFiles = useMemo(() => {
@@ -72,7 +74,7 @@ export function useFileProcessing(
 
             try {
                 // Upload to artifact storage
-                await client.files.uploadArtifact(run.runId, artifactPath, file);
+                await client.agents.uploadArtifact(agentRunId, artifactPath, file);
 
                 // Update local state to processing
                 setLocalFiles(prev => {
@@ -86,10 +88,9 @@ export function useFileProcessing(
                     return newMap;
                 });
 
-                // Signal workflow that file was uploaded
-                await client.store.workflows.sendSignal(
-                    run.workflowId,
-                    run.runId,
+                // Signal agent that file was uploaded
+                await client.agents.sendSignal(
+                    agentRunId,
                     'FileUploaded',
                     {
                         id: fileId,
@@ -114,13 +115,13 @@ export function useFileProcessing(
 
                 toast({
                     status: 'error',
-                    title: 'Upload Failed',
+                    title: t('agent.uploadFailed'),
                     description: error instanceof Error ? error.message : 'Failed to upload file',
                     duration: 3000,
                 });
             }
         }
-    }, [client, run, toast]);
+    }, [client, agentRunId, toast]);
 
     return { processingFiles, hasProcessingFiles, handleFileUpload };
 }

package/src/features/agent/chat/types/document.ts

@@ -1,4 +1,6 @@
 export interface OpenDocument {
     id: string;
     title: string;
+    /** Revision chain key used to dedupe multiple revisions of the same document. */
+    revisionRootId?: string;
 }

package/src/features/errors/PanelErrorBoundary.tsx

@@ -1,6 +1,7 @@
 import { MessageBox } from '@vertesia/ui/core';
 import { VertesiaErrorBoundary } from './VertesiaErrorBoundary';
 import { ReactNode } from 'react';
+import { useUITranslation } from '../../i18n/index.js';
 
 export function PanelErrorBoundary({ children }: { children: ReactNode }) {
     return (
@@ -11,11 +12,12 @@ export function PanelErrorBoundary({ children }: { children: ReactNode }) {
 }
 
 function PanelErrorFallback({ error }: { error?: Error }) {
+    const { t } = useUITranslation();
     return (
-        <MessageBox status="error" title="Sorry, something went wrong...">
+        <MessageBox status="error" title={t('errors.somethingWentWrong')}>
             <div className='mb-4'>
-                Our team has been notified and will be quickly working on resolving it.
-                If you&apos;d like to escalate or simply contact us, please email us at&nbsp;
+                {t('errors.teamNotifiedLine1')}
+                {' '}{t('errors.teamNotifiedLine2')}&nbsp;
 
                 <a className='text-info' href="mailto:support@vertesiahq.com">support@vertesiahq.com</a>.
             </div>