Skip to content

OpenRAG is a comprehensive, single package Retrieval-Augmented Generation platform built on Langflow, Docling, and Opensearch.

Python

feat: task ingest dialog and retry flow (#1700)

Wallgau7fbdb56a8d69
diff --git a/frontend/app/api/mutations/useCancelTaskMutation.ts b/frontend/app/api/mutations/useCancelTaskMutation.ts
index 88ea7e0c5..c18bb130c 100644
--- a/frontend/app/api/mutations/useCancelTaskMutation.ts
+++ b/frontend/app/api/mutations/useCancelTaskMutation.ts
@@ -3,6 +3,8 @@ import {
useMutation,
useQueryClient,
} from "@tanstack/react-query";
+import { taskDetailQueryKey } from "@/app/api/queries/useGetTaskQuery";
+import { TASKS_QUERY_KEY } from "@/app/api/queries/useGetTasksQuery";
export interface CancelTaskRequest {
taskId: string;
@@ -36,12 +38,19 @@ export const useCancelTaskMutation = (
return response.json();
}
+ const { onSuccess, onError, onSettled, ...restOptions } = options ?? {};
+
return useMutation({
mutationFn: cancelTask,
- onSuccess: () => {
- // Invalidate tasks query to refresh the list
- queryClient.invalidateQueries({ queryKey: ["tasks"] });
+ ...restOptions,
+ onSuccess: (data, variables, context) => {
+ queryClient.invalidateQueries({ queryKey: [...TASKS_QUERY_KEY] });
+ queryClient.invalidateQueries({
+ queryKey: taskDetailQueryKey(variables.taskId),
+ });
+ onSuccess?.(data, variables, context);
},
- ...options,
+ onError,
+ onSettled,
});
};
diff --git a/frontend/app/api/mutations/useDeleteDocument.ts b/frontend/app/api/mutations/useDeleteDocument.ts
index f4fd9ce41..20039ad07 100644
--- a/frontend/app/api/mutations/useDeleteDocument.ts
+++ b/frontend/app/api/mutations/useDeleteDocument.ts
@@ -13,15 +13,15 @@ interface DeleteDocumentResponse {
message: string;
}
-const deleteDocument = async (
- data: DeleteDocumentRequest,
-): Promise<DeleteDocumentResponse> => {
+export async function deleteDocumentByFilename(
+ filename: string,
+): Promise<DeleteDocumentResponse> {
const response = await fetch("/api/documents/delete-by-filename", {
method: "POST",
headers: {
"Content-Type": "application/json",
},
- body: JSON.stringify(data),
+ body: JSON.stringify({ filename } satisfies DeleteDocumentRequest),
});
if (!response.ok) {
@@ -30,13 +30,14 @@ const deleteDocument = async (
}
return response.json();
-};
+}
export const useDeleteDocument = () => {
const queryClient = useQueryClient();
return useMutation({
- mutationFn: deleteDocument,
+ mutationFn: ({ filename }: DeleteDocumentRequest) =>
+ deleteDocumentByFilename(filename),
onSettled: () => {
// Invalidate and refetch search queries to update the UI
setTimeout(() => {
diff --git a/frontend/app/api/mutations/useRetryTaskMutation.ts b/frontend/app/api/mutations/useRetryTaskMutation.ts
new file mode 100644
index 000000000..04f3b831f
--- /dev/null
+++ b/frontend/app/api/mutations/useRetryTaskMutation.ts
@@ -0,0 +1,84 @@
+import {
+ type UseMutationOptions,
+ useMutation,
+ useQueryClient,
+} from "@tanstack/react-query";
+import { taskDetailQueryKey } from "@/app/api/queries/useGetTaskQuery";
+import { TASKS_QUERY_KEY } from "@/app/api/queries/useGetTasksQuery";
+
+export interface RetryTaskRequest {
+ taskId: string;
+ /** When set, only these task file paths are retried. Omit to retry all failed RETRYABLE files. */
+ filePaths?: string[];
+}
+
+export interface RetryTaskSkippedFile {
+ file_path: string;
+ filename?: string;
+ reason:
+ | "not_retryable"
+ | "source_file_missing"
+ | "file_not_in_task"
+ | "not_failed"
+ | string;
+}
+
+export interface RetryTaskResponse {
+ task_id: string;
+ retried: number;
+ skipped: RetryTaskSkippedFile[];
+ status: string;
+ message?: string;
+ error?: string;
+}
+
+export const useRetryTaskMutation = (
+ options?: Omit<
+ UseMutationOptions<RetryTaskResponse, Error, RetryTaskRequest>,
+ "mutationFn"
+ >,
+) => {
+ const queryClient = useQueryClient();
+
+ async function retryTask(
+ variables: RetryTaskRequest,
+ ): Promise<RetryTaskResponse> {
+ const body = JSON.stringify(
+ variables.filePaths != null ? { file_paths: variables.filePaths } : {},
+ );
+
+ const response = await fetch(`/api/tasks/${variables.taskId}/retry`, {
+ method: "POST",
+ headers: { "Content-Type": "application/json" },
+ body,
+ });
+
+ const payload = (await response
+ .json()
+ .catch(() => ({}))) as RetryTaskResponse;
+
+ if (!response.ok) {
+ throw new Error(
+ payload.message || payload.error || "Failed to retry task files",
+ );
+ }
+
+ return payload;
+ }
+
+ const { onSuccess, onError, onSettled, ...restOptions } = options ?? {};
+
+ return useMutation({
+ mutationFn: retryTask,
+ ...restOptions,
+ onSuccess: (data, variables, context) => {
+ queryClient.invalidateQueries({ queryKey: [...TASKS_QUERY_KEY] });
+ queryClient.invalidateQueries({
+ queryKey: taskDetailQueryKey(variables.taskId),
+ });
+ onSuccess?.(data, variables, context);
+ },
+ onError,
+ onSettled,
+ });
+};
diff --git a/frontend/app/api/queries/useGetTaskQuery.ts b/frontend/app/api/queries/useGetTaskQuery.ts
new file mode 100644
index 000000000..692585782
--- /dev/null
+++ b/frontend/app/api/queries/useGetTaskQuery.ts
@@ -0,0 +1,35 @@
+import { type UseQueryOptions, useQuery } from "@tanstack/react-query";
+import type { Task } from "@/app/api/queries/useGetTasksQuery";
+export const TASK_DETAIL_QUERY_KEY = ["tasks", "detail"] as const;
+
+export function taskDetailQueryKey(taskId: string) {
+ return [...TASK_DETAIL_QUERY_KEY, taskId] as const;
+}
+
+export function useGetTaskQuery(
+ taskId: string | null,
+ options?: Omit<UseQueryOptions<Task | null>, "queryKey" | "queryFn">,
+) {
+ return useQuery({
+ queryKey: taskId
+ ? taskDetailQueryKey(taskId)
+ : [...TASK_DETAIL_QUERY_KEY, "idle"],
+ queryFn: async (): Promise<Task | null> => {
+ if (!taskId) {
+ return null;
+ }
+ const response = await fetch(
+ `/api/tasks/${encodeURIComponent(taskId)}/enhanced`,
+ );
+ if (response.status === 404) {
+ return null;
+ }
+ if (!response.ok) {
+ throw new Error("Failed to fetch task");
+ }
+ return response.json() as Promise<Task>;
+ },
+ ...options,
+ enabled: options?.enabled ?? !!taskId,
+ });
+}
diff --git a/frontend/app/api/queries/useGetTasksQuery.ts b/frontend/app/api/queries/useGetTasksQuery.ts
index bcdfa9d14..d871007e6 100644
--- a/frontend/app/api/queries/useGetTasksQuery.ts
+++ b/frontend/app/api/queries/useGetTasksQuery.ts
@@ -4,6 +4,25 @@ import {
useQueryClient,
} from "@tanstack/react-query";
+/** Component that failed, from GET /tasks/enhanced file metadata. */
+export type TaskFailureComponent =
+ | "docling"
+ | "openrag"
+ | "langflow"
+ | "opensearch";
+
+/** Pipeline or validation step where failure occurred. */
+export type TaskFailurePhase =
+ | "parsing"
+ | "chunking"
+ | "embedding"
+ | "indexing"
+ | "file_validation"
+ | "unknown";
+
+/** Who can resolve the failure (enhanced API). */
+export type TaskActionableBy = "USER_ACTIONABLE" | "RETRYABLE";
+
export interface TaskFileEntry {
status?:
| "pending"
@@ -21,7 +40,14 @@ export interface TaskFileEntry {
filename?: string;
embedding_model?: string;
embedding_dimensions?: number;
- [key: string]: unknown;
+ phase?: "docling" | "langflow" | "complete" | string;
+ docling_status?: string;
+ docling_task_id?: string;
+ /** Present on failed files when the enhanced API can classify the failure. */
+ component?: TaskFailureComponent;
+ failure_phase?: TaskFailurePhase;
+ user_facing_message?: string;
+ actionable_by?: TaskActionableBy;
}
export interface Task {
@@ -51,13 +77,15 @@ export interface TasksResponse {
tasks: Task[];
}
+export const TASKS_QUERY_KEY = ["tasks", "enhanced"] as const;
+
export const useGetTasksQuery = (
options?: Omit<UseQueryOptions<Task[]>, "queryKey" | "queryFn">,
) => {
const queryClient = useQueryClient();
async function getTasks(): Promise<Task[]> {
- const response = await fetch("/api/tasks");
+ const response = await fetch("/api/tasks/enhanced");
if (!response.ok) {
throw new Error("Failed to fetch tasks");
@@ -69,13 +97,12 @@ export const useGetTasksQuery = (
const queryResult = useQuery(
{
- queryKey: ["tasks"],
+ queryKey: [...TASKS_QUERY_KEY],
queryFn: getTasks,
refetchInterval: (query) => {
- // Only poll if there are tasks with pending or running status
const data = query.state.data;
if (!data || data.length === 0) {
- return false; // Stop polling if no tasks
+ return false;
}
const hasActiveTasks = data.some(
@@ -85,11 +112,11 @@ export const useGetTasksQuery = (
task.status === "processing",
);
- return hasActiveTasks ? 3000 : false; // Poll every 3 seconds if active tasks exist
+ return hasActiveTasks ? 3000 : false;
},
refetchIntervalInBackground: true,
- staleTime: 0, // Always consider data stale to ensure fresh updates
- gcTime: 5 * 60 * 1000, // Keep in cache for 5 minutes
+ staleTime: 0,
+ gcTime: 5 * 60 * 1000,
...options,
},
queryClient,
diff --git a/frontend/app/globals.css b/frontend/app/globals.css
index 770721c4a..8375f9b67 100644
--- a/frontend/app/globals.css
+++ b/frontend/app/globals.css
@@ -31,6 +31,17 @@
--placeholder-foreground: 240 5% 65%;
/* App-level UI tokens (safe defaults, override per brand/theme) */
+ --canvas: 0 0% 100%;
+ --border-subtle-background-contextual: var(--border);
+ /* Task dialog layout (file row indent = px + checkbox + gaps + chevron) */
+ --task-dialog-width: 40rem;
+ --task-dialog-max-height: 60vh;
+ --task-dialog-file-type-width: 10rem;
+ --task-dialog-error-indent: 4.5rem;
+ --task-dialog-error-indent-cloud: 4.75rem;
+ --task-dialog-oss-bg: var(--background);
+ --task-dialog-oss-selected: var(--muted);
+ --z-task-dialog-menu: 100;
--layered-select-bg: hsl(var(--muted) / 0.5);
--chat-surface-gradient: rgba(69, 137, 255, 0.16);
--chat-input-border: hsl(var(--input));
@@ -118,6 +129,10 @@
--placeholder-foreground: 240 4% 46%;
/* App-level UI tokens (safe defaults, override per brand/theme) */
+ --canvas: 0 0% 3.9%; /* #0A0A0A */
+ --border-subtle-background-contextual: var(--border);
+ --task-dialog-oss-bg: 0 0% 9.02%; /* #171717 */
+ --task-dialog-oss-selected: 0 0% 13.73%; /* #232323 */
--layered-select-bg: hsl(var(--muted) / 0.5);
--chat-surface-gradient: rgba(69, 137, 255, 0.16);
--chat-input-border: hsl(var(--input));
@@ -236,6 +251,7 @@
--layered-select-bg: rgba(131, 131, 131, 0.24);
--chat-input-border: #f4f4f4;
--icon-disabled: #525252;
+ --border-subtle-background-contextual: 0 0% 82%;
/* Contextual layer (~Gray 100); use hsl(var(--layer-contextual)) */
/* Layer / contextual surfaces (IBM Gray 10 light, Gray 100 dark) */
--layer-contextual: 0 0% 96%;
@@ -336,6 +352,7 @@
--icon-primary: 0 0% 96%; /* #f4f4f4*/
--placeholder: 0 0% 44%; /* #6F6F6F */
+ --border-subtle-background-contextual: 0 0% 22.4%; /* #393939 */
--layer-contextual: 0 0% 15%;
--layer-contextual-foreground: 0 0% 96%;
--text-text-01: 0 0% 96%;
diff --git a/frontend/app/knowledge/page.tsx b/frontend/app/knowledge/page.tsx
index ea5f9af27..b03e2f492 100644
--- a/frontend/app/knowledge/page.tsx
+++ b/frontend/app/knowledge/page.tsx
@@ -12,7 +12,7 @@ import {
import { AgGridReact, type CustomCellRendererProps } from "ag-grid-react";
import { AlertTriangle, Cloud, FileIcon, Globe, RefreshCw } from "lucide-react";
import { useRouter } from "next/navigation";
-import { useCallback, useEffect, useRef, useState } from "react";
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
import { KnowledgeDropdown } from "@/components/knowledge-dropdown";
import { ProtectedRoute } from "@/components/protected-route";
import { Banner, BannerIcon, BannerTitle } from "@/components/ui/banner";
@@ -64,6 +64,42 @@ import {
useSyncAllConnectorsPreview,
} from "../api/mutations/useSyncConnector";
+function sameFileSelection(a: File[], b: File[]): boolean {
+ if (a.length !== b.length) {
+ return false;
+ }
+ const identities = new Set(b.map((row) => getKnowledgeFileIdentity(row)));
+ return a.every((row) => identities.has(getKnowledgeFileIdentity(row)));
+}
+
+/** Failed overlays can stay selected after they lose their checkbox (processing → failed). */
+function syncGridSelectionToDeletableRows(
+ api: NonNullable<AgGridReact<File>["api"]>,
+ isDeletable: (file?: File) => boolean,
+): File[] {
+ api.forEachNode((node) => {
+ if (node.isSelected() && !isDeletable(node.data)) {
+ node.setSelected(false);
+ }
+ });
+ return api.getSelectedRows().filter(isDeletable);
+}
+
+/** Deselect non-deletable rows in the grid only; returns whether anything changed. */
+function pruneNonDeletableGridSelection(
+ api: NonNullable<AgGridReact<File>["api"]>,
+ isDeletable: (file?: File) => boolean,
+): boolean {
+ let pruned = false;
+ api.forEachNode((node) => {
+ if (node.isSelected() && !isDeletable(node.data)) {
+ node.setSelected(false);
+ pruned = true;
+ }
+ });
+ return pruned;
+}
+
/** List-files uses term filters; "*" means "any" in the UI — do not send it literally. */
function listFilesFilterParam(values?: string[]): string | undefined {
const raw = values?.[0]?.trim();
@@ -327,6 +363,21 @@ function SearchPage() {
return getKnowledgeFileIdentity(file);
}, []);
+ const isDeletableKnowledgeRow = useCallback((file?: File) => {
+ return (file?.status || "active") === "active";
+ }, []);
+
+ const resolveDeleteFilename = useCallback(
+ (row: File) => {
+ const identity = getKnowledgeFileIdentity(row);
+ const indexed = effectiveData.find(
+ (file) => getKnowledgeFileIdentity(file) === identity,
+ );
+ return indexed?.filename ?? row.filename;
+ },
+ [effectiveData],
+ );
+
const getOwnerLabel = useCallback((file?: File): string => {
return file?.owner_name?.trim() || file?.owner_email?.trim() || "—";
}, []);
@@ -417,6 +468,29 @@ function SearchPage() {
const gridRows = fileResults;
const gridRef = useRef<AgGridReact>(null);
+ // Re-run only when row identity/status changes, not on every list poll reference.
+ const gridRowsSelectionKey = useMemo(
+ () =>
+ gridRows
+ .map(
+ (row) => `${getKnowledgeFileIdentity(row)}:${row.status ?? "active"}`,
+ )
+ .join("\0"),
+ [gridRows],
+ );
+
+ useEffect(() => {
+ const api = gridRef.current?.api;
+ if (!api) {
+ return;
+ }
+ pruneNonDeletableGridSelection(api, isDeletableKnowledgeRow);
+ const nextSelected = api.getSelectedRows().filter(isDeletableKnowledgeRow);
+ setSelectedRows((current) =>
+ sameFileSelection(current, nextSelected) ? current : nextSelected,
+ );
+ }, [gridRowsSelectionKey, isDeletableKnowledgeRow]);
+
const columnDefs: ColDef<File>[] = [
{
field: "filename",
@@ -436,7 +510,7 @@ function SearchPage() {
return sourceA < sourceB ? -1 : 1;
},
checkboxSelection: (params: CheckboxSelectionCallbackParams<File>) =>
- (params?.data?.status || "active") === "active",
+ isDeletableKnowledgeRow(params?.data),
headerCheckboxSelection: true,
...(isCloudBrand
? { flex: 2.2, minWidth: 260 }
@@ -685,51 +759,81 @@ function SearchPage() {
};
const onSelectionChanged = useCallback(() => {
- if (gridRef.current) {
- const selectedNodes = gridRef.current.api.getSelectedRows();
- setSelectedRows(selectedNodes);
+ if (!gridRef.current) {
+ return;
}
- }, []);
+ const nextSelected = syncGridSelectionToDeletableRows(
+ gridRef.current.api,
+ isDeletableKnowledgeRow,
+ );
+ setSelectedRows((current) =>
+ sameFileSelection(current, nextSelected) ? current : nextSelected,
+ );
+ }, [isDeletableKnowledgeRow]);
const handleBulkDelete = async () => {
- if (selectedRows.length === 0) return;
+ const rowsToDelete = selectedRows.filter(isDeletableKnowledgeRow);
+ if (rowsToDelete.length === 0) return;
try {
- // Delete each file individually since the API expects one filename at a time
- const deletePromises = selectedRows.map((row) =>
- deleteDocumentMutation.mutateAsync({ filename: row.filename }),
+ const deleteResults = await Promise.allSettled(
+ rowsToDelete.map((row) =>
+ deleteDocumentMutation.mutateAsync({
+ filename: resolveDeleteFilename(row),
+ }),
+ ),
);
- const deleteResults = await Promise.all(deletePromises);
await refreshTasks();
await queryClient.invalidateQueries({ queryKey: ["search"] });
+ await queryClient.invalidateQueries({ queryKey: ["listFiles"] });
await queryClient.refetchQueries({ queryKey: ["search"] });
+ await queryClient.refetchQueries({ queryKey: ["listFiles"] });
- const totalDeletedChunks = deleteResults.reduce(
- (sum, result) => sum + (result.deleted_chunks || 0),
- 0,
+ const deleted = deleteResults.filter(
+ (
+ result,
+ ): result is PromiseFulfilledResult<
+ Awaited<ReturnType<typeof deleteDocumentMutation.mutateAsync>>
+ > =>
+ result.status === "fulfilled" &&
+ (result.value.deleted_chunks || 0) > 0,
);
- const filesWithNoDeletion = deleteResults.filter(
- (result) => (result.deleted_chunks || 0) === 0,
+ const noChunks = deleteResults.filter(
+ (result) =>
+ result.status === "fulfilled" &&
+ (result.value.deleted_chunks || 0) === 0,
+ );
+ const failed = deleteResults.filter(
+ (result): result is PromiseRejectedResult =>
+ result.status === "rejected",
);
- if (totalDeletedChunks > 0) {
+ if (deleted.length > 0) {
toast.success(
- `Successfully deleted ${selectedRows.length} document${
- selectedRows.length > 1 ? "s" : ""
- }`,
+ `Deleted ${deleted.length} document${deleted.length > 1 ? "s" : ""}`,
);
- } else {
+ } else if (failed.length === 0) {
toast.warning(
- "No document chunks were deleted. Files may be owned by another context or already removed.",
+ "No document chunks were deleted. Files may be missing or not deletable in your current context.",
);
}
- if (filesWithNoDeletion.length > 0 && totalDeletedChunks > 0) {
+ if (noChunks.length > 0 && deleted.length > 0) {
toast.warning(
- `${filesWithNoDeletion.length} selected file${
- filesWithNoDeletion.length > 1 ? "s were" : " was"
- } not deleted (0 chunks matched).`,
+ `${noChunks.length} selected file${noChunks.length > 1 ? "s had" : " had"} no matching chunks.`,
+ );
+ }
+
+ if (failed.length > 0) {
+ toast.error(
+ `${failed.length} document${failed.length > 1 ? "s" : ""} could not be deleted`,
+ {
+ description:
+ failed[0].reason instanceof Error
+ ? failed[0].reason.message
+ : undefined,
+ },
);
}
setSelectedRows([]);
@@ -919,6 +1023,7 @@ function SearchPage() {
getRowId={(params: GetRowIdParams<File>) =>
getFileIdentity(params.data)
}
+ isRowSelectable={(params) => isDeletableKnowledgeRow(params.data)}
domLayout="normal"
onSelectionChanged={onSelectionChanged}
pagination={pagination}
@@ -952,6 +1057,7 @@ function SearchPage() {
getRowId={(params: GetRowIdParams<File>) =>
getFileIdentity(params.data)
}
+ isRowSelectable={(params) => isDeletableKnowledgeRow(params.data)}
domLayout="normal"
onSelectionChanged={onSelectionChanged}
pagination={pagination}
diff --git a/frontend/components/task-dialog/category-chips.tsx b/frontend/components/task-dialog/category-chips.tsx
new file mode 100644
index 000000000..a726ddd6e
--- /dev/null
+++ b/frontend/components/task-dialog/category-chips.tsx
@@ -0,0 +1,73 @@
+"use client";
+
+import { useIsCloudBrand } from "@/contexts/brand-context";
+import {
+ ALL_TASK_STATUS_CATEGORIES,
+ type TaskFileStatusCategory,
+} from "@/lib/task-utils";
+import { cn } from "@/lib/utils";
+import { CATEGORY_CHIPS } from "./constants";
+
+interface TaskDialogCategoryChipsProps {
+ counts: Record<TaskFileStatusCategory, number> | null;
+ statusCategory: string;
+ onStatusCategoryChange: (value: string) => void;
+}
+
+export function TaskDialogCategoryChips({
+ counts,
+ statusCategory,
+ onStatusCategoryChange,
+}: TaskDialogCategoryChipsProps) {
+ const isCloudBrand = useIsCloudBrand();
+ if (!counts) return null;
+
+ const visibleChips = CATEGORY_CHIPS.filter((chip) => counts[chip.id] > 0);
+ if (visibleChips.length === 0) return null;
+
+ return (
+ <div
+ className={cn(
+ "flex flex-wrap items-center",
+ isCloudBrand ? "gap-2 px-4" : "gap-1.5",
+ )}
+ >
+ {visibleChips.map((chip) => {
+ const Icon = chip.icon;
+ const isActive = statusCategory === chip.id;
+ const count = counts[chip.id];
+
+ return (
+ <button
+ key={chip.id}
+ type="button"
+ aria-pressed={isActive}
+ onClick={() =>
+ onStatusCategoryChange(
+ isActive ? ALL_TASK_STATUS_CATEGORIES : chip.id,
+ )
+ }
+ className={cn(
+ "inline-flex min-h-10 items-center gap-2 border text-sm transition-colors",
+ isCloudBrand ? "px-4" : "px-3",
+ isCloudBrand ? "rounded-full" : "rounded-lg",
+ isCloudBrand
+ ? isActive
+ ? "border-[var(--border-border-interactive)] bg-[#333333] text-foreground"
+ : "border-border-subtle-contextual bg-[#333333] text-layer-contextual-foreground hover:bg-[#333333] hover:text-foreground"
+ : isActive
+ ? "border-border bg-task-dialog-oss-selected text-foreground"
+ : "border-border bg-muted hover:bg-badge hover:text-badge-foreground",
+ )}
+ >
+ <Icon className={cn("size-4 shrink-0", chip.iconClassName)} />
+ <span>{chip.label}</span>
+ <span className="rounded-md bg-muted px-1.5 py-0.5 text-xs font-medium tabular-nums">
+ {count}
+ </span>
+ </button>
+ );
+ })}
+ </div>
+ );
+}
diff --git a/frontend/components/task-dialog/constants.ts b/frontend/components/task-dialog/constants.ts
new file mode 100644
index 000000000..881f08f5d
--- /dev/null
+++ b/frontend/components/task-dialog/constants.ts
@@ -0,0 +1,28 @@
+import { AlertCircle, CheckCircle, Clock, type LucideIcon } from "lucide-react";
+import type { TaskFileStatusCategory } from "@/lib/task-utils";
+
+export const CATEGORY_CHIPS: Array<{
+ id: TaskFileStatusCategory;
+ label: string;
+ icon: LucideIcon;
+ iconClassName: string;
+}> = [
+ {
+ id: "completed",
+ label: "Completed",
+ icon: CheckCircle,
+ iconClassName: "text-emerald-500",
+ },
+ {
+ id: "system_error",
+ label: "System error",
+ icon: AlertCircle,
+ iconClassName: "text-destructive",
+ },
+ {
+ id: "indexing",
+ label: "Indexing",
+ icon: Clock,
+ iconClassName: "text-muted-foreground",
+ },
+];
diff --git a/frontend/components/task-dialog/file-error-details.tsx b/frontend/components/task-dialog/file-error-details.tsx
new file mode 100644
index 000000000..1c5a10b4c
--- /dev/null
+++ b/frontend/components/task-dialog/file-error-details.tsx
@@ -0,0 +1,127 @@
+"use client";
+
+import { Ban, Check, Flag } from "lucide-react";
+import type { TaskFileEntry } from "@/app/api/queries/useGetTasksQuery";
+import { useIsCloudBrand } from "@/contexts/brand-context";
+import {
+ analyzeTaskFileIngestionFailure,
+ type TaskFileIngestionFailureAnalysis,
+} from "@/lib/task-error-display";
+import { cn } from "@/lib/utils";
+
+interface TaskDialogFileErrorDetailsProps {
+ fileInfo: TaskFileEntry;
+ taskError?: string;
+ analysis?: TaskFileIngestionFailureAnalysis;
+}
+
+export function TaskDialogFileErrorDetails({
+ fileInfo,
+ taskError,
+ analysis: analysisProp,
+}: TaskDialogFileErrorDetailsProps) {
+ const isCloudBrand = useIsCloudBrand();
+ const analysis =
+ analysisProp ?? analyzeTaskFileIngestionFailure(fileInfo, taskError);
+
+ return (
+ <div
+ className={cn(
+ isCloudBrand
+ ? "pl-task-dialog-error-indent-cloud"
+ : "pl-task-dialog-error-indent",
+ "pr-4 pb-4",
+ isCloudBrand
+ ? "flex flex-col gap-3"
+ : "flex flex-col gap-1 border-t border-muted/60 py-2 pr-3",
+ )}
+ >
+ <div className="flex flex-col">
+ {analysis.pipelineSteps.map((step, index) => {
+ const isFailed = step.status === "failed";
+ const isLast = index === analysis.pipelineSteps.length - 1;
+ const showComponentTags =
+ isFailed && analysis.componentTags.length > 0;
+ const contentRowCount =
+ 1 + (isFailed ? 2 + (showComponentTags ? 1 : 0) : 0);
+
+ return (
+ <div
+ key={step.id}
+ className={cn(
+ "grid grid-cols-[theme(spacing.4)_minmax(0,1fr)] items-start gap-x-3 gap-y-1",
+ isFailed && (isCloudBrand ? "gap-y-2" : "gap-y-1"),
+ )}
+ >
+ <div
+ className="flex flex-col items-center"
+ style={{ gridRow: `1 / span ${contentRowCount}` }}
+ >
+ {step.status === "completed" ? (
+ <Check
+ className="h-4 w-4 shrink-0 text-emerald-600 dark:text-emerald-400"
+ aria-hidden
+ />
+ ) : (
+ <Ban
+ className="h-4 w-4 shrink-0 text-destructive"
+ aria-hidden
+ />
+ )}
+ {!isLast && (
+ <span
+ className={cn(
+ "my-1 w-px flex-1 min-h-3",
+ step.status === "completed"
+ ? "bg-emerald-500/40"
+ : "bg-destructive/40",
+ )}
+ />
+ )}
+ </div>
+
+ <p
+ className={cn(
+ "col-start-2 text-sm",
+ isFailed
+ ? "text-muted-foreground"
+ : "text-muted-foreground/80",
+ !isLast && (isCloudBrand ? "pb-3" : "pb-1.5"),
+ )}
+ >
+ {step.label}
+ </p>
+
+ {isFailed && (
+ <>
+ <p className="col-start-2 whitespace-pre-wrap break-words text-sm text-foreground/90">
+ {analysis.resolvedError}
+ </p>
+ <p className="col-start-2 text-xs text-muted-foreground">
+ {analysis.failureSummary}
+ </p>
+ {showComponentTags && (
+ <div className="col-start-2 flex flex-wrap items-center gap-x-2 gap-y-1">
+ <Flag
+ className="size-3 shrink-0 text-destructive"
+ aria-hidden
+ />
+ {analysis.componentTags.map((tag) => (
+ <span
+ key={tag}
+ className="text-xs text-failure-component-cause"
+ >
+ {tag}
+ </span>
+ ))}
+ </div>
+ )}
+ </>
+ )}
+ </div>
+ );
+ })}
+ </div>
+ </div>
+ );
+}
diff --git a/frontend/components/task-dialog/file-list.tsx b/frontend/components/task-dialog/file-list.tsx
new file mode 100644
index 000000000..2107b3ad8
--- /dev/null
+++ b/frontend/components/task-dialog/file-list.tsx
@@ -0,0 +1,395 @@
+"use client";
+
+import { ArrowUpAZ, ChevronDown, FileText } from "lucide-react";
+import { useEffect, useMemo, useState } from "react";
+import type { TaskFileEntry } from "@/app/api/queries/useGetTasksQuery";
+import { useIsCloudBrand } from "@/contexts/brand-context";
+import type { Task } from "@/contexts/task-context";
+import { analyzeTaskFileIngestionFailure } from "@/lib/task-error-display";
+import {
+ getTaskFileDialogStatusLabel,
+ getTaskFileName,
+ isTaskFileFailed,
+ isTaskFileRetryable,
+ type TaskFileNameSort,
+} from "@/lib/task-utils";
+import { cn } from "@/lib/utils";
+import { TaskDialogFileErrorDetails } from "./file-error-details";
+
+type TaskDialogFileListTab = "task-ingestions" | "retry-ingestions";
+
+interface TaskDialogFileListProps {
+ task: Task;
+ entries: Array<[string, TaskFileEntry]>;
+ retryIngestionEntries: Array<[string, TaskFileEntry]>;
+ totalSourceCount: number;
+ totalSourceCountAll?: number;
+ nameSort: TaskFileNameSort;
+ onToggleNameSort: () => void;
+ expandedPath: string | null;
+ onExpandedPathChange: (path: string | null) => void;
+ retryIngestionCount?: number;
+ selectablePaths: string[];
+ selectedPaths: Set<string>;
+ allSelectableSelected: boolean;
+ onToggleSelectedPath: (filePath: string) => void;
+ onToggleSelectAllVisible: () => void;
+ allRetryIngestionsSelected: boolean;
+ onToggleSelectAllRetryIngestions: () => void;
+ selectedCount: number;
+ retryIngestionSelectedCount: number;
+ retryingTarget?: "all" | "selected" | string | null;
+}
+
+export function TaskDialogFileList({
+ task,
+ entries,
+ retryIngestionEntries,
+ totalSourceCount,
+ totalSourceCountAll,
+ nameSort,
+ onToggleNameSort,
+ expandedPath,
+ onExpandedPathChange,
+ retryIngestionCount = 0,
+ selectablePaths,
+ selectedPaths,
+ allSelectableSelected,
+ onToggleSelectedPath,
+ onToggleSelectAllVisible,
+ allRetryIngestionsSelected,
+ onToggleSelectAllRetryIngestions,
+ selectedCount,
+ retryIngestionSelectedCount,
+ retryingTarget = null,
+}: TaskDialogFileListProps) {
+ const isCloudBrand = useIsCloudBrand();
+ const [activeTab, setActiveTab] =
+ useState<TaskDialogFileListTab>("task-ingestions");
+
+ const showRetryIngestionsTab = retryIngestionCount > 0;
+
+ useEffect(() => {
+ if (!showRetryIngestionsTab && activeTab === "retry-ingestions") {
+ setActiveTab("task-ingestions");
+ }
+ }, [showRetryIngestionsTab, activeTab]);
+
+ const analysisByPath = useMemo(() => {
+ const map = new Map<
+ string,
+ ReturnType<typeof analyzeTaskFileIngestionFailure>
+ >();
+ const allEntries = [...entries, ...retryIngestionEntries];
+ const seen = new Set<string>();
+ for (const [filePath, fileInfo] of allEntries) {
+ if (seen.has(filePath)) continue;
+ seen.add(filePath);
+ if (isTaskFileFailed(fileInfo)) {
+ map.set(
+ filePath,
+ analyzeTaskFileIngestionFailure(fileInfo, task.error),
+ );
+ }
+ }
+ return map;
+ }, [entries, retryIngestionEntries, task.error]);
+
+ const containerClass = cn(
+ "flex min-h-0 flex-1 flex-col overflow-hidden",
+ isCloudBrand
+ ? "rounded-md border-x border-b bg-layer-contextual"
+ : "border-b border-muted bg-task-dialog-oss",
+ );
+
+ const taskIngestionsTabCount =
+ totalSourceCountAll != null && totalSourceCountAll > totalSourceCount
+ ? `${totalSourceCount} of ${totalSourceCountAll}`
+ : String(totalSourceCount);
+
+ const isTabActive = (tab: TaskDialogFileListTab) => activeTab === tab;
+
+ const tabTriggerClass = (tab: TaskDialogFileListTab) => {
+ const isActive = isTabActive(tab);
+ return cn(
+ "inline-flex w-fit max-w-fit min-h-10 shrink-0 items-center px-4 text-sm font-medium transition-colors",
+ isCloudBrand
+ ? cn(
+ "rounded-none border-0 border-b-2",
+ isActive
+ ? "border-[var(--border-border-interactive)] bg-muted text-foreground"
+ : "border-transparent bg-transparent text-muted-foreground hover:border-[var(--border-border-interactive)]",
+ )
+ : cn(
+ "border-0",
+ isActive
+ ? "rounded-none rounded-t-lg bg-task-dialog-oss-selected text-foreground"
+ : "rounded-none bg-transparent text-muted-foreground hover:text-foreground",
+ ),
+ );
+ };
+
+ const listScrollClass = "min-h-0 flex-1 overflow-y-auto overscroll-contain";
+
+ const rowGridClass =
+ "grid min-h-10 grid-cols-[auto_auto_1fr_auto] items-center gap-3";
+
+ const renderFileRows = (listEntries: Array<[string, TaskFileEntry]>) =>
+ listEntries.map(([filePath, fileInfo]) => {
+ const fileName = getTaskFileName(filePath, fileInfo);
+ const failed = isTaskFileFailed(fileInfo);
+ const analysis = analysisByPath.get(filePath);
+ const rowStatusLabel = failed
+ ? (analysis?.rowStatusLabel ?? "Failed")
+ : getTaskFileDialogStatusLabel(fileInfo, task.error);
+ const isExpanded = expandedPath === filePath;
+ const retryable = isTaskFileRetryable(fileInfo);
+ const isSelected = selectedPaths.has(filePath);
+ const isRowRetrying =
+ retryingTarget === "all" ||
+ retryingTarget === filePath ||
+ (retryingTarget === "selected" && isSelected);
+ const retryAttempts = fileInfo.retry_count ?? 0;
+ const statusLabel =
+ retryable && retryAttempts > 0
+ ? `${rowStatusLabel} · Retry ${retryAttempts}`
+ : rowStatusLabel;
+
+ return (
+ <div
+ key={filePath}
+ className={cn(
+ "border-b last:border-b-0",
+ isCloudBrand ? "border-border" : "border-muted",
+ isSelected && (isCloudBrand ? "bg-muted" : "bg-muted/30"),
+ )}
+ >
+ <div
+ className={cn(
+ rowGridClass,
+ isCloudBrand ? "px-4 hover:bg-muted" : "px-3 hover:bg-muted/30",
+ isSelected &&
+ (isCloudBrand ? "hover:bg-muted" : "hover:bg-muted/40"),
+ )}
+ >
+ {retryable ? (
+ <input
+ type="checkbox"
+ className="h-4 w-4 shrink-0 rounded border-border accent-primary"
+ checked={isSelected}
+ disabled={isRowRetrying}
+ aria-label={`Select ${fileName}`}
+ onChange={() => onToggleSelectedPath(filePath)}
+ />
+ ) : (
+ <span className="h-4 w-4 shrink-0" aria-hidden />
+ )}
+ {failed ? (
+ <button
+ type="button"
+ aria-label={isExpanded ? "Collapse error" : "Expand error"}
+ aria-expanded={isExpanded}
+ onClick={() =>
+ onExpandedPathChange(isExpanded ? null : filePath)
+ }
+ className="inline-flex h-5 w-5 items-center justify-center text-muted-foreground hover:text-foreground"
+ >
+ <ChevronDown
+ className={cn(
+ "h-4 w-4 transition-transform",
+ isExpanded && "rotate-180",
+ )}
+ />
+ </button>
+ ) : (
+ <span className="h-5 w-5" aria-hidden />
+ )}
+ <button
+ type="button"
+ className={cn(
+ "flex min-w-0 items-center gap-2 text-left",
+ failed && "cursor-pointer",
+ )}
+ onClick={() => {
+ if (!failed) return;
+ onExpandedPathChange(isExpanded ? null : filePath);
+ }}
+ disabled={!failed}
+ >
+ <FileText className="h-4 w-4 shrink-0 text-muted-foreground" />
+ <span
+ className={cn("truncate text-sm", failed && "text-foreground")}
+ title={fileName}
+ >
+ {fileName}
+ </span>
+ </button>
+ <span
+ className={cn(
+ "shrink-0 text-sm",
+ failed
+ ? "text-destructive"
+ : rowStatusLabel === "Complete"
+ ? "text-emerald-600 dark:text-emerald-400"
+ : "text-muted-foreground",
+ )}
+ >
+ {statusLabel}
+ </span>
+ </div>
+
+ {failed && isExpanded && analysis && (
+ <TaskDialogFileErrorDetails
+ fileInfo={fileInfo}
+ taskError={task.error}
+ analysis={analysis}
+ />
+ )}
+ </div>
+ );
+ });
+
+ const renderListHeader = ({
+ showSelectAll,
+ allSelected,
+ onToggleSelectAll,
+ selectedLabel,
+ }: {
+ showSelectAll: boolean;
+ allSelected: boolean;
+ onToggleSelectAll: () => void;
+ selectedLabel?: string;
+ }) => (
+ <div
+ className={cn(
+ "flex min-h-10 shrink-0 items-center gap-3 text-sm font-medium text-muted-foreground",
+ isCloudBrand ? "bg-muted px-4" : "bg-task-dialog-oss-selected px-3",
+ )}
+ >
+ {showSelectAll ? (
+ <input
+ type="checkbox"
+ className="h-4 w-4 shrink-0 rounded border-border accent-primary"
+ checked={allSelected}
+ disabled={retryingTarget != null}
+ aria-label="Select all retryable files"
+ onChange={onToggleSelectAll}
+ />
+ ) : null}
+ <button
+ type="button"
+ className="inline-flex min-w-0 flex-1 items-center gap-1 hover:text-foreground"
+ onClick={onToggleNameSort}
+ >
+ <span>Source</span>
+ <ArrowUpAZ
+ className={cn(
+ "h-3.5 w-3.5",
+ isCloudBrand ? "opacity-70" : "opacity-50",
+ nameSort === "desc" && "rotate-180",
+ )}
+ aria-hidden
+ />
+ <span className="sr-only">
+ Sort by name {nameSort === "asc" ? "A to Z" : "Z to A"}
+ </span>
+ </button>
+ {selectedLabel ? (
+ <span className="shrink-0 text-xs tabular-nums">{selectedLabel}</span>
+ ) : null}
+ </div>
+ );
+
+ const renderEmptyPanel = (message: string) => (
+ <p
+ className={cn(
+ "text-center text-sm text-muted-foreground",
+ isCloudBrand ? "py-6" : "px-4 py-4",
+ )}
+ >
+ {message}
+ </p>
+ );
+
+ return (
+ <div className={containerClass}>
+ <div
+ className="flex w-fit max-w-fit shrink-0 items-end gap-1 p-0"
+ role="tablist"
+ aria-label="Task file views"
+ >
+ <button
+ type="button"
+ role="tab"
+ id="task-dialog-tab-task-ingestions"
+ aria-selected={isTabActive("task-ingestions")}
+ aria-controls="task-dialog-panel-task-ingestions"
+ className={tabTriggerClass("task-ingestions")}
+ onClick={() => setActiveTab("task-ingestions")}
+ >
+ Task ingestions ({taskIngestionsTabCount})
+ </button>
+ {showRetryIngestionsTab && (
+ <button
+ type="button"
+ role="tab"
+ id="task-dialog-tab-retry-ingestions"
+ aria-selected={isTabActive("retry-ingestions")}
+ aria-controls="task-dialog-panel-retry-ingestions"
+ className={tabTriggerClass("retry-ingestions")}
+ onClick={() => setActiveTab("retry-ingestions")}
+ >
+ Retry ingestions ({retryIngestionCount})
+ </button>
+ )}
+ </div>
+
+ <div className="flex min-h-0 flex-1 flex-col overflow-hidden">
+ {isTabActive("task-ingestions")
+ ? renderListHeader({
+ showSelectAll: selectablePaths.length > 0,
+ allSelected: allSelectableSelected,
+ onToggleSelectAll: onToggleSelectAllVisible,
+ selectedLabel:
+ selectedCount > 0 ? `${selectedCount} selected` : undefined,
+ })
+ : null}
+ {isTabActive("retry-ingestions")
+ ? renderListHeader({
+ showSelectAll: true,
+ allSelected: allRetryIngestionsSelected,
+ onToggleSelectAll: onToggleSelectAllRetryIngestions,
+ selectedLabel:
+ retryIngestionSelectedCount > 0
+ ? `${retryIngestionSelectedCount} selected`
+ : undefined,
+ })
+ : null}
+ <div
+ id="task-dialog-panel-task-ingestions"
+ role="tabpanel"
+ aria-labelledby="task-dialog-tab-task-ingestions"
+ hidden={!isTabActive("task-ingestions")}
+ className={listScrollClass}
+ >
+ {entries.length === 0
+ ? renderEmptyPanel("No files match your filters.")
+ : renderFileRows(entries)}
+ </div>
+ {showRetryIngestionsTab ? (
+ <div
+ id="task-dialog-panel-retry-ingestions"
+ role="tabpanel"
+ aria-labelledby="task-dialog-tab-retry-ingestions"
+ hidden={!isTabActive("retry-ingestions")}
+ className={listScrollClass}
+ >
+ {retryIngestionEntries.length === 0
+ ? renderEmptyPanel("No retryable files in this task.")
+ : renderFileRows(retryIngestionEntries)}
+ </div>
+ ) : null}
+ </div>
+ </div>
+ );
+}
diff --git a/frontend/components/task-dialog/filters.tsx b/frontend/components/task-dialog/filters.tsx
new file mode 100644
index 000000000..0e7d38001
--- /dev/null
+++ b/frontend/components/task-dialog/filters.tsx
@@ -0,0 +1,195 @@
+"use client";
+
+import { ChevronDown, ChevronUp, Search } from "lucide-react";
+import { useState } from "react";
+import { Button } from "@/components/ui/button";
+import {
+ DropdownMenu,
+ DropdownMenuContent,
+ DropdownMenuItem,
+ DropdownMenuTrigger,
+} from "@/components/ui/dropdown-menu";
+import { Input } from "@/components/ui/input";
+import { useIsCloudBrand } from "@/contexts/brand-context";
+import { ALL_TASK_FILE_TYPES, formatTaskFileTypeLabel } from "@/lib/task-utils";
+import { cn } from "@/lib/utils";
+
+interface TaskDialogFiltersProps {
+ search: string;
+ onSearchChange: (value: string) => void;
+ fileType: string;
+ onFileTypeChange: (value: string) => void;
+ fileTypes: string[];
+ fileTypeLabel: string;
+ searchDisabled: boolean;
+ fileTypeDisabled: boolean;
+}
+
+function FileTypeMenu({
+ fileType,
+ onFileTypeChange,
+ fileTypes,
+ allTypesLabel,
+ fileTypeLabel,
+ disabled,
+}: {
+ fileType: string;
+ onFileTypeChange: (value: string) => void;
+ fileTypes: string[];
+ allTypesLabel: string;
+ fileTypeLabel: string;
+ disabled: boolean;
+}) {
+ const isCloudBrand = useIsCloudBrand();
+ const [open, setOpen] = useState(false);
+ const options = [
+ { value: ALL_TASK_FILE_TYPES, label: allTypesLabel },
+ ...fileTypes.map((type) => ({
+ value: type,
+ label: formatTaskFileTypeLabel(type),
+ })),
+ ];
+
+ const ChevronIcon = open ? ChevronUp : ChevronDown;
+ const triggerContent = (
+ <>
+ <span className="truncate">{fileTypeLabel}</span>
+ <ChevronIcon
+ className={cn(
+ "h-4 w-4 shrink-0",
+ isCloudBrand ? "opacity-70" : "ml-2 opacity-50",
+ )}
+ aria-hidden
+ />
+ </>
+ );
+
+ return (
+ <DropdownMenu modal={false} open={open} onOpenChange={setOpen}>
+ <DropdownMenuTrigger asChild>
+ {isCloudBrand ? (
+ <button
+ type="button"
+ disabled={disabled}
+ className="inline-flex min-h-10 w-task-dialog-file-type shrink-0 items-center justify-between gap-2 bg-layer-contextual px-4 text-sm text-muted-foreground transition-colors hover:text-foreground disabled:pointer-events-none disabled:opacity-50"
+ >
+ {triggerContent}
+ </button>
+ ) : (
+ <Button
+ type="button"
+ variant="outline"
+ disabled={disabled}
+ className="min-h-10 h-10 w-task-dialog-file-type shrink-0 justify-between font-normal"
+ >
+ {triggerContent}
+ </Button>
+ )}
+ </DropdownMenuTrigger>
+ <DropdownMenuContent
+ align="end"
+ className={cn(
+ "z-task-dialog-menu w-task-dialog-file-type",
+ isCloudBrand &&
+ "border-border-subtle-contextual bg-layer-contextual text-layer-contextual-foreground",
+ )}
+ onCloseAutoFocus={(event) => event.preventDefault()}
+ >
+ {options.map(({ value, label }) => (
+ <DropdownMenuItem
+ key={value}
+ onSelect={() => onFileTypeChange(value)}
+ className={cn(
+ "px-2",
+ isCloudBrand &&
+ "bg-layer-contextual text-layer-contextual-foreground hover:bg-muted focus:bg-muted data-[highlighted]:bg-muted",
+ fileType === value &&
+ "bg-muted text-foreground focus:bg-muted data-[highlighted]:bg-muted",
+ )}
+ >
+ {label}
+ </DropdownMenuItem>
+ ))}
+ </DropdownMenuContent>
+ </DropdownMenu>
+ );
+}
+
+function TaskDialogSearchField({
+ search,
+ onSearchChange,
+ disabled,
+}: {
+ search: string;
+ onSearchChange: (value: string) => void;
+ disabled: boolean;
+}) {
+ const isCloudBrand = useIsCloudBrand();
+ const input = (
+ <Input
+ type="search"
+ autoComplete="off"
+ placeholder="Search files..."
+ value={search}
+ onChange={(e) => onSearchChange(e.target.value)}
+ disabled={disabled}
+ icon={<Search className="h-4 w-4" aria-hidden />}
+ inputClassName={
+ isCloudBrand
+ ? "h-10 min-w-0 !rounded-none !border-0 bg-layer-contextual text-layer-contextual-foreground placeholder:text-muted-foreground focus:outline-none disabled:cursor-not-allowed disabled:opacity-50"
+ : "h-10 rounded-md !bg-canvas"
+ }
+ />
+ );
+
+ return (
+ <div
+ className={
+ isCloudBrand
+ ? "min-w-0 flex-1 border-r border-border-subtle-contextual bg-layer-contextual"
+ : "relative min-w-0 flex-1"
+ }
+ >
+ {input}
+ </div>
+ );
+}
+
+export function TaskDialogFilters({
+ search,
+ onSearchChange,
+ fileType,
+ onFileTypeChange,
+ fileTypes,
+ fileTypeLabel,
+ searchDisabled,
+ fileTypeDisabled,
+}: TaskDialogFiltersProps) {
+ const isCloudBrand = useIsCloudBrand();
+ const fileTypeMenuProps = {
+ fileType,
+ onFileTypeChange,
+ fileTypes,
+ allTypesLabel: isCloudBrand ? "All categories" : "All file types",
+ fileTypeLabel,
+ disabled: fileTypeDisabled,
+ };
+
+ return (
+ <div
+ className={cn(
+ "flex min-h-10",
+ isCloudBrand
+ ? "items-stretch border-y border-border bg-layer-contextual [&_input]:min-h-10"
+ : "items-center gap-2",
+ )}
+ >
+ <TaskDialogSearchField
+ search={search}
+ onSearchChange={onSearchChange}
+ disabled={searchDisabled}
+ />
+ <FileTypeMenu {...fileTypeMenuProps} />
+ </div>
+ );
+}
diff --git a/frontend/components/task-dialog/header.tsx b/frontend/components/task-dialog/header.tsx
new file mode 100644
index 000000000..d04277de7
--- /dev/null
+++ b/frontend/components/task-dialog/header.tsx
@@ -0,0 +1,99 @@
+"use client";
+
+import { DialogHeader, DialogTitle } from "@/components/ui/dialog";
+import { useIsCloudBrand } from "@/contexts/brand-context";
+import {
+ ALL_TASK_FILE_TYPES,
+ formatTaskFileTypeLabel,
+ type TaskFileStatusCategory,
+} from "@/lib/task-utils";
+import { cn } from "@/lib/utils";
+import { TaskDialogCategoryChips } from "./category-chips";
+import { TaskDialogFilters } from "./filters";
+
+interface TaskDialogHeaderProps {
+ taskId: string;
+ search: string;
+ onSearchChange: (value: string) => void;
+ fileType: string;
+ onFileTypeChange: (value: string) => void;
+ fileTypes: string[];
+ statusCategory: string;
+ onStatusCategoryChange: (value: string) => void;
+ categoryCounts: Record<TaskFileStatusCategory, number> | null;
+ filtersDisabled: boolean;
+ fileTypeDisabled: boolean;
+}
+
+export function TaskDialogHeader({
+ taskId,
+ search,
+ onSearchChange,
+ fileType,
+ onFileTypeChange,
+ fileTypes,
+ statusCategory,
+ onStatusCategoryChange,
+ categoryCounts,
+ filtersDisabled,
+ fileTypeDisabled,
+}: TaskDialogHeaderProps) {
+ const isCloudBrand = useIsCloudBrand();
+ const allTypesLabel = isCloudBrand ? "All categories" : "All file types";
+ const fileTypeLabel =
+ fileType === ALL_TASK_FILE_TYPES
+ ? allTypesLabel
+ : formatTaskFileTypeLabel(fileType);
+
+ return (
+ <header
+ className={cn(
+ "shrink-0 flex-none",
+ isCloudBrand
+ ? "border-b border-border bg-layer-contextual"
+ : "border-b-0",
+ )}
+ >
+ <DialogHeader
+ className={cn(
+ "space-y-0 border-b-0 text-left",
+ isCloudBrand
+ ? "bg-layer-contextual px-6 pt-4 pb-3"
+ : "pt-3 pb-2 pr-12",
+ )}
+ >
+ <DialogTitle
+ className={cn(
+ "py-2 text-base font-semibold leading-snug",
+ !isCloudBrand && "px-4",
+ )}
+ >
+ Task {taskId}
+ </DialogTitle>
+ </DialogHeader>
+
+ <div
+ className={cn(
+ "flex flex-col gap-2 border-b-0",
+ isCloudBrand ? "bg-layer-contextual gap-3 px-0 pb-4" : "px-4 pb-3",
+ )}
+ >
+ <TaskDialogFilters
+ search={search}
+ onSearchChange={onSearchChange}
+ fileType={fileType}
+ onFileTypeChange={onFileTypeChange}
+ fileTypes={fileTypes}
+ fileTypeLabel={fileTypeLabel}
+ searchDisabled={filtersDisabled}
+ fileTypeDisabled={fileTypeDisabled}
+ />
+ <TaskDialogCategoryChips
+ counts={categoryCounts}
+ statusCategory={statusCategory}
+ onStatusCategoryChange={onStatusCategoryChange}
+ />
+ </div>
+ </header>
+ );
+}
diff --git a/frontend/components/task-dialog/index.ts b/frontend/components/task-dialog/index.ts
new file mode 100644
index 000000000..5d29db243
--- /dev/null
+++ b/frontend/components/task-dialog/index.ts
@@ -0,0 +1 @@
+export { default } from "./task-dialog";
diff --git a/frontend/components/task-dialog/task-dialog.tsx b/frontend/components/task-dialog/task-dialog.tsx
new file mode 100644
index 000000000..e20d75ac4
--- /dev/null
+++ b/frontend/components/task-dialog/task-dialog.tsx
@@ -0,0 +1,207 @@
+"use client";
+
+import { Button } from "@/components/ui/button";
+import { Dialog, DialogContent, DialogFooter } from "@/components/ui/dialog";
+import { useIsCloudBrand } from "@/contexts/brand-context";
+import { cn } from "@/lib/utils";
+import { TaskDialogFileList } from "./file-list";
+import { TaskDialogHeader } from "./header";
+import { useTaskDialog } from "./use-task-dialog";
+
+interface TaskDialogProps {
+ open: boolean;
+ task_id: string;
+ onOpenChange: (open: boolean) => void;
+ onClose: () => void;
+}
+
+function TaskDialogContent({
+ open,
+ task_id,
+ onClose,
+}: Pick<TaskDialogProps, "open" | "task_id" | "onClose">) {
+ const isCloudBrand = useIsCloudBrand();
+ const {
+ task,
+ isLoading,
+ isError,
+ fileEntries,
+ fileTypes,
+ categoryCounts,
+ sortedEntries,
+ retryIngestionEntries,
+ retryIngestionSelectedCount,
+ allRetryIngestionsSelected,
+ toggleSelectAllRetryIngestions,
+ search,
+ setSearch,
+ fileType,
+ setFileType,
+ statusCategory,
+ setStatusCategory,
+ expandedPath,
+ setExpandedPath,
+ nameSort,
+ toggleNameSort,
+ retryableCount,
+ selectedCount,
+ selectedPaths,
+ selectablePaths,
+ allSelectableSelected,
+ toggleSelectedPath,
+ toggleSelectAllVisible,
+ isRetrying,
+ retryingTarget,
+ handleRetryAll,
+ handleRetrySelected,
+ } = useTaskDialog(open, task_id);
+
+ const filtersDisabled = !task;
+ // Always offer "All file types"; only disable while task data is loading.
+ const fileTypeDisabled = !task;
+ const showRetryActions = retryableCount > 0;
+
+ return (
+ <div
+ className={cn(
+ "flex h-full min-h-0 flex-col overflow-hidden",
+ isCloudBrand
+ ? "bg-layer-contextual font-ibm-plex-sans"
+ : "bg-task-dialog-oss",
+ )}
+ >
+ <TaskDialogHeader
+ taskId={task_id}
+ search={search}
+ onSearchChange={setSearch}
+ fileType={fileType}
+ onFileTypeChange={setFileType}
+ fileTypes={fileTypes}
+ statusCategory={statusCategory}
+ onStatusCategoryChange={setStatusCategory}
+ categoryCounts={categoryCounts}
+ filtersDisabled={filtersDisabled}
+ fileTypeDisabled={fileTypeDisabled}
+ />
+
+ <div
+ className={cn(
+ "flex min-h-0 flex-1 flex-col overflow-hidden",
+ isCloudBrand ? "bg-layer-contextual" : "bg-task-dialog-oss px-4",
+ )}
+ >
+ {isLoading ? (
+ <p className="text-sm text-muted-foreground">Loading task…</p>
+ ) : isError || !task ? (
+ <p className="text-sm text-muted-foreground">Task not found.</p>
+ ) : fileEntries.length === 0 && retryableCount === 0 ? (
+ <p className="text-sm text-muted-foreground">
+ No files in this task.
+ </p>
+ ) : (
+ <TaskDialogFileList
+ task={task}
+ entries={sortedEntries}
+ retryIngestionEntries={retryIngestionEntries}
+ totalSourceCount={sortedEntries.length}
+ totalSourceCountAll={fileEntries.length}
+ nameSort={nameSort}
+ onToggleNameSort={toggleNameSort}
+ expandedPath={expandedPath}
+ onExpandedPathChange={setExpandedPath}
+ retryIngestionCount={retryableCount}
+ selectablePaths={selectablePaths}
+ selectedPaths={selectedPaths}
+ allSelectableSelected={allSelectableSelected}
+ onToggleSelectedPath={toggleSelectedPath}
+ onToggleSelectAllVisible={toggleSelectAllVisible}
+ allRetryIngestionsSelected={allRetryIngestionsSelected}
+ onToggleSelectAllRetryIngestions={toggleSelectAllRetryIngestions}
+ selectedCount={selectedCount}
+ retryIngestionSelectedCount={retryIngestionSelectedCount}
+ retryingTarget={retryingTarget}
+ />
+ )}
+ </div>
+
+ <DialogFooter
+ className={cn(
+ "w-full shrink-0 flex-row items-stretch sm:justify-normal sm:space-x-0",
+ isCloudBrand
+ ? "gap-0 border-t bg-layer-contextual p-0"
+ : "gap-2 border-t bg-task-dialog-oss px-6 py-4",
+ )}
+ >
+ <Button
+ type="button"
+ variant="ghost"
+ className={cn(
+ showRetryActions && "min-w-0 flex-1",
+ isCloudBrand &&
+ showRetryActions &&
+ "justify-start rounded-none px-4 text-left",
+ )}
+ onClick={onClose}
+ disabled={isRetrying}
+ >
+ {isCloudBrand ? "Cancel" : "Close"}
+ </Button>
+ {showRetryActions && selectedCount > 0 ? (
+ <Button
+ type="button"
+ className={cn(
+ "min-w-0 flex-1",
+ isCloudBrand && "justify-start rounded-none px-4 text-left",
+ )}
+ disabled={isRetrying || !task}
+ onClick={() => void handleRetrySelected()}
+ >
+ {isRetrying ? "Retrying…" : `Retry selected (${selectedCount})`}
+ </Button>
+ ) : null}
+ {showRetryActions && selectedCount === 0 ? (
+ <Button
+ type="button"
+ className={cn(
+ "min-w-0 flex-1",
+ isCloudBrand && "justify-start rounded-none px-4 text-left",
+ )}
+ disabled={isRetrying || !task}
+ onClick={() => void handleRetryAll()}
+ >
+ {isRetrying ? "Retrying…" : "Retry all"}
+ </Button>
+ ) : null}
+ </DialogFooter>
+ </div>
+ );
+}
+
+export default function TaskDialog({
+ open,
+ onOpenChange,
+ task_id,
+ onClose,
+}: TaskDialogProps) {
+ const isCloudBrand = useIsCloudBrand();
+
+ return (
+ <Dialog open={open} onOpenChange={onOpenChange}>
+ <DialogContent
+ className={cn(
+ "flex h-task-dialog max-h-task-dialog w-task-dialog max-w-task-dialog flex-col gap-0 overflow-hidden p-0 sm:rounded-lg",
+ isCloudBrand
+ ? "bg-layer-contextual font-ibm-plex-sans"
+ : "bg-task-dialog-oss",
+ )}
+ >
+ <TaskDialogContent
+ key={task_id}
+ open={open}
+ task_id={task_id}
+ onClose={onClose}
+ />
+ </DialogContent>
+ </Dialog>
+ );
+}
diff --git a/frontend/components/task-dialog/use-task-dialog.ts b/frontend/components/task-dialog/use-task-dialog.ts
new file mode 100644
index 000000000..0d87275de
--- /dev/null
+++ b/frontend/components/task-dialog/use-task-dialog.ts
@@ -0,0 +1,384 @@
+"use client";
+
+import { useCallback, useEffect, useMemo, useState } from "react";
+import { toast } from "sonner";
+import {
+ type RetryTaskResponse,
+ useRetryTaskMutation,
+} from "@/app/api/mutations/useRetryTaskMutation";
+import { useGetTaskQuery } from "@/app/api/queries/useGetTaskQuery";
+import { useTask } from "@/contexts/task-context";
+import {
+ ALL_TASK_FILE_TYPES,
+ ALL_TASK_STATUS_CATEGORIES,
+ countRetryIngestionFiles,
+ countTaskFileEntriesByCategory,
+ filterTaskFileEntries,
+ getRetryableFileEntries,
+ getRetryableFilePaths,
+ getTaskFileEntries,
+ getTaskFileTypes,
+ isTaskInProgressStatus,
+ sortTaskFileEntries,
+ type TaskFileNameSort,
+ TaskFileStatusCategory,
+} from "@/lib/task-utils";
+
+function showRetryResultToast(result: RetryTaskResponse) {
+ if (result.skipped.length > 0) {
+ const missingSources = result.skipped.filter(
+ (entry) => entry.reason === "source_file_missing",
+ ).length;
+ if (missingSources > 0) {
+ toast.warning("Some files could not be retried", {
+ description: `${result.retried} file(s) queued. ${missingSources} need to be uploaded again.`,
+ });
+ return;
+ }
+ }
+
+ if (result.retried > 0) {
+ toast.success("Retry started", {
+ description: `${result.retried} file(s) queued for ingestion`,
+ });
+ return;
+ }
+
+ toast.warning("No files were retried", {
+ description: result.message ?? "Selected files could not be retried",
+ });
+}
+
+export function useTaskDialog(open: boolean, taskId: string) {
+ const { markTaskFilesProcessing, refreshTasks } = useTask();
+
+ const [selectedPaths, setSelectedPaths] = useState<Set<string>>(
+ () => new Set(),
+ );
+
+ const [retryingTarget, setRetryingTarget] = useState<
+ "all" | "selected" | string | null
+ >(null);
+
+ const retryMutation = useRetryTaskMutation();
+
+ const {
+ data: task,
+ isLoading,
+ isError,
+ refetch: refetchTask,
+ } = useGetTaskQuery(taskId, {
+ enabled: open && !!taskId,
+ refetchOnMount: "always",
+ refetchInterval: (query) => {
+ if (!open) {
+ return false;
+ }
+ if (retryingTarget != null) {
+ return 2000;
+ }
+ const data = query.state.data;
+ if (!data) {
+ return false;
+ }
+ if (isTaskInProgressStatus(data.status)) {
+ return 2000;
+ }
+ return getTaskFileEntries(data).some(([, fileInfo]) => {
+ const status = fileInfo.status ?? "pending";
+ return (
+ status === "pending" ||
+ status === "running" ||
+ status === "processing"
+ );
+ })
+ ? 2000
+ : false;
+ },
+ });
+
+ const retryableCount = useMemo(
+ () => (task ? countRetryIngestionFiles(task) : 0),
+ [task],
+ );
+
+ const [search, setSearch] = useState("");
+ const [fileType, setFileType] = useState(ALL_TASK_FILE_TYPES);
+ const [statusCategory, setStatusCategory] = useState(
+ ALL_TASK_STATUS_CATEGORIES,
+ );
+ const [expandedPath, setExpandedPath] = useState<string | null>(null);
+ const [nameSort, setNameSort] = useState<TaskFileNameSort>("asc");
+
+ useEffect(() => {
+ if (!open) {
+ setSelectedPaths(new Set());
+ }
+ }, [open]);
+
+ const fileEntries = useMemo(
+ () => (task ? getTaskFileEntries(task) : []),
+ [task],
+ );
+
+ const fileTypes = useMemo(() => (task ? getTaskFileTypes(task) : []), [task]);
+
+ const activeFileType =
+ fileType === ALL_TASK_FILE_TYPES || fileTypes.includes(fileType)
+ ? fileType
+ : ALL_TASK_FILE_TYPES;
+
+ const categoryCounts = useMemo(() => {
+ if (!task) {
+ return null;
+ }
+ const scopedEntries = filterTaskFileEntries(fileEntries, {
+ search,
+ fileType: activeFileType,
+ statusCategory: ALL_TASK_STATUS_CATEGORIES,
+ });
+ return countTaskFileEntriesByCategory(scopedEntries);
+ }, [task, fileEntries, search, activeFileType]);
+
+ useEffect(() => {
+ if (
+ !categoryCounts ||
+ statusCategory === ALL_TASK_STATUS_CATEGORIES ||
+ (categoryCounts[statusCategory as TaskFileStatusCategory] ?? 0) > 0
+ ) {
+ return;
+ }
+ setStatusCategory(ALL_TASK_STATUS_CATEGORIES);
+ }, [categoryCounts, statusCategory]);
+
+ const filteredEntries = useMemo(
+ () =>
+ filterTaskFileEntries(fileEntries, {
+ search,
+ fileType: activeFileType,
+ statusCategory: statusCategory as TaskFileStatusCategory,
+ task: task ?? undefined,
+ }),
+ [fileEntries, search, activeFileType, statusCategory, task],
+ );
+
+ const sortedEntries = useMemo(
+ () => sortTaskFileEntries(filteredEntries, nameSort),
+ [filteredEntries, nameSort],
+ );
+
+ const retryIngestionEntries = useMemo(
+ () =>
+ task ? sortTaskFileEntries(getRetryableFileEntries(task), nameSort) : [],
+ [task, nameSort],
+ );
+
+ const retryIngestionPaths = useMemo(
+ () => retryIngestionEntries.map(([filePath]) => filePath),
+ [retryIngestionEntries],
+ );
+
+ const selectablePaths = useMemo(
+ () => getRetryableFilePaths(sortedEntries),
+ [sortedEntries],
+ );
+
+ const allRetryablePaths = useMemo(
+ () => (task ? getRetryableFilePaths(getRetryableFileEntries(task)) : []),
+ [task],
+ );
+
+ const selectedCount = useMemo(() => {
+ let count = 0;
+ for (const path of selectablePaths) {
+ if (selectedPaths.has(path)) {
+ count += 1;
+ }
+ }
+ return count;
+ }, [selectablePaths, selectedPaths]);
+
+ const allSelectableSelected =
+ selectablePaths.length > 0 && selectedCount === selectablePaths.length;
+
+ const retryIngestionSelectedCount = useMemo(() => {
+ let count = 0;
+ for (const path of retryIngestionPaths) {
+ if (selectedPaths.has(path)) {
+ count += 1;
+ }
+ }
+ return count;
+ }, [retryIngestionPaths, selectedPaths]);
+
+ const allRetryIngestionsSelected =
+ retryIngestionPaths.length > 0 &&
+ retryIngestionSelectedCount === retryIngestionPaths.length;
+
+ const selectedRetryablePaths = useMemo(
+ () => allRetryablePaths.filter((path) => selectedPaths.has(path)),
+ [allRetryablePaths, selectedPaths],
+ );
+
+ const runRetry = useCallback(
+ async (filePaths?: string[]) => {
+ if (!taskId) {
+ return;
+ }
+ if (!filePaths && retryableCount === 0) {
+ return;
+ }
+ if (filePaths && filePaths.length === 0) {
+ return;
+ }
+
+ const pathsToRetry =
+ filePaths ??
+ (task ? getRetryableFilePaths(getRetryableFileEntries(task)) : []);
+
+ setRetryingTarget(
+ filePaths
+ ? filePaths.length === 1
+ ? filePaths[0]
+ : "selected"
+ : "all",
+ );
+
+ if (pathsToRetry.length > 0) {
+ markTaskFilesProcessing(taskId, pathsToRetry);
+ }
+
+ try {
+ const result = await retryMutation.mutateAsync({
+ taskId,
+ ...(filePaths ? { filePaths } : {}),
+ });
+ await refetchTask();
+ showRetryResultToast(result);
+ if (result.retried > 0) {
+ setSelectedPaths(new Set());
+ }
+ } catch (error) {
+ await refreshTasks();
+ toast.error("Retry failed", {
+ description:
+ error instanceof Error ? error.message : "Could not retry files",
+ });
+ } finally {
+ setRetryingTarget(null);
+ }
+ },
+ [
+ task,
+ taskId,
+ retryableCount,
+ retryMutation,
+ refetchTask,
+ markTaskFilesProcessing,
+ refreshTasks,
+ ],
+ );
+
+ const handleRetryAll = useCallback(() => runRetry(), [runRetry]);
+
+ const handleRetrySelected = useCallback(
+ () => runRetry(selectedRetryablePaths),
+ [runRetry, selectedRetryablePaths],
+ );
+
+ const toggleSelectedPath = useCallback((filePath: string) => {
+ setSelectedPaths((current) => {
+ const next = new Set(current);
+ if (next.has(filePath)) {
+ next.delete(filePath);
+ } else {
+ next.add(filePath);
+ }
+ return next;
+ });
+ }, []);
+
+ const toggleSelectAllVisible = useCallback(() => {
+ setSelectedPaths((current) => {
+ const visible = new Set(selectablePaths);
+ const allSelected =
+ selectablePaths.length > 0 &&
+ selectablePaths.every((path) => current.has(path));
+
+ if (allSelected) {
+ const next = new Set(current);
+ for (const path of visible) {
+ next.delete(path);
+ }
+ return next;
+ }
+
+ const next = new Set(current);
+ for (const path of visible) {
+ next.add(path);
+ }
+ return next;
+ });
+ }, [selectablePaths]);
+
+ const toggleSelectAllRetryIngestions = useCallback(() => {
+ setSelectedPaths((current) => {
+ const allSelected =
+ retryIngestionPaths.length > 0 &&
+ retryIngestionPaths.every((path) => current.has(path));
+
+ if (allSelected) {
+ const next = new Set(current);
+ for (const path of retryIngestionPaths) {
+ next.delete(path);
+ }
+ return next;
+ }
+
+ const next = new Set(current);
+ for (const path of retryIngestionPaths) {
+ next.add(path);
+ }
+ return next;
+ });
+ }, [retryIngestionPaths]);
+
+ const toggleNameSort = () => {
+ setNameSort((current) => (current === "asc" ? "desc" : "asc"));
+ };
+
+ return {
+ task: task ?? undefined,
+ isLoading,
+ isError,
+ retryableCount,
+ selectedCount,
+ selectedPaths,
+ selectablePaths,
+ allSelectableSelected,
+ toggleSelectedPath,
+ toggleSelectAllVisible,
+ isRetrying: retryMutation.isPending,
+ retryingTarget,
+ handleRetryAll,
+ handleRetrySelected,
+ fileEntries,
+ fileTypes,
+ categoryCounts,
+ sortedEntries,
+ retryIngestionEntries,
+ retryIngestionSelectedCount,
+ allRetryIngestionsSelected,
+ toggleSelectAllRetryIngestions,
+ search,
+ setSearch,
+ fileType: activeFileType,
+ setFileType,
+ statusCategory,
+ setStatusCategory,
+ expandedPath,
+ setExpandedPath,
+ nameSort,
+ toggleNameSort,
+ };
+}
diff --git a/frontend/components/task-error-content.tsx b/frontend/components/task-error-content.tsx
index fbd291403..c03d9fe44 100644
--- a/frontend/components/task-error-content.tsx
+++ b/frontend/components/task-error-content.tsx
@@ -1,21 +1,26 @@
"use client";
+import * as AccordionPrimitive from "@radix-ui/react-accordion";
import { AlertCircle, ChevronDown, Flag, XCircle } from "lucide-react";
import { useMemo, useState } from "react";
import { IncidentReporterIcon } from "@/components/icons/incident-reporter-icon";
+import TaskDialog from "@/components/task-dialog";
import {
Accordion,
AccordionContent,
AccordionItem,
- AccordionTrigger,
} from "@/components/ui/accordion";
import { useIsCloudBrand } from "@/contexts/brand-context";
import { type Task } from "@/contexts/task-context";
-import { displayFileTaskError } from "@/lib/task-error-display";
+import {
+ formatApiComponent,
+ resolveTaskFileError,
+} from "@/lib/task-error-display";
import {
getFailedFileCount,
getFailedFileEntries,
getSuccessfulFileCount,
+ getTaskFileName,
isCompletedTotalFailure,
isTerminalFailedTask,
} from "@/lib/task-utils";
@@ -41,6 +46,7 @@ export function TaskErrorContent({
const [accordionValue, setAccordionValue] = useState(
defaultExpanded ? "failed-files" : "",
);
+ const [isTaskDialogOpen, setIsTaskDialogOpen] = useState(false);
const isExpanded = accordionValue === "failed-files";
const failedEntries = useMemo(() => getFailedFileEntries(task), [task]);
@@ -70,29 +76,45 @@ export function TaskErrorContent({
const ossIconColumn = showHeader && !isCloudBrand;
- const accordionTrigger = (
- <div className="flex w-full min-w-0 items-center justify-between gap-2">
- <div className="flex min-w-0 items-center gap-1">
- <span className="text-xs">
- {successCount} success · {failedCount} failed
- </span>
- <ChevronDown className="size-4 shrink-0 transition-transform group-data-[state=open]:rotate-180" />
- </div>
- <button
- type="button"
- aria-label="Report incident"
- className="inline-flex shrink-0 items-center justify-center text-muted-foreground hover:text-foreground"
- onClick={(event) => {
- event.preventDefault();
- event.stopPropagation();
- }}
- onPointerDown={(event) => event.stopPropagation()}
- >
- <IncidentReporterIcon className="size-4" />
- </button>
+ const accordionSummary = (
+ <div className="flex min-w-0 flex-1 items-center gap-1">
+ <span className="text-xs">
+ {successCount} success · {failedCount} failed
+ </span>
+ <ChevronDown className="size-4 shrink-0 transition-transform group-data-[state=open]:rotate-180" />
</div>
);
+ const openTaskDialogButton = (
+ <button
+ type="button"
+ aria-label="Open task details"
+ className="inline-flex shrink-0 items-center justify-center text-muted-foreground hover:text-foreground"
+ onClick={() => setIsTaskDialogOpen(true)}
+ >
+ <IncidentReporterIcon className="size-4" />
+ </button>
+ );
+
+ const accordionHeader = (
+ <AccordionPrimitive.Header
+ className={cn(
+ "flex w-full min-w-0 items-center gap-2",
+ ossIconColumn && "gap-2.5",
+ )}
+ >
+ {ossIconColumn ? <div className="size-5 shrink-0" aria-hidden /> : null}
+ <AccordionPrimitive.Trigger
+ className={cn(
+ "group inline-flex min-w-0 flex-1 items-center justify-start gap-1 px-0 py-0 text-sm text-muted-foreground transition-colors hover:text-foreground",
+ )}
+ >
+ {accordionSummary}
+ </AccordionPrimitive.Trigger>
+ {openTaskDialogButton}
+ </AccordionPrimitive.Header>
+ );
+
return (
<div
className={cn(
@@ -150,27 +172,13 @@ export function TaskErrorContent({
}
>
<AccordionItem value="failed-files" className="border-0 rounded-none">
- <AccordionTrigger className="group px-0 py-0 text-sm text-muted-foreground hover:text-foreground transition-colors [&>svg:first-child]:hidden">
- {ossIconColumn ? (
- <div className="flex w-full min-w-0 gap-2.5">
- <div className="size-5 shrink-0" aria-hidden />
- <div className="min-w-0 flex-1">{accordionTrigger}</div>
- </div>
- ) : (
- accordionTrigger
- )}
- </AccordionTrigger>
+ {accordionHeader}
<AccordionContent className="w-full p-0 pt-2">
<div className="flex w-full flex-col gap-2">
{failedEntries.map(([filePath, fileInfo], index) => {
- const fileName =
- fileInfo.filename || filePath.split("/").pop() || filePath;
- const rawError =
- typeof fileInfo.error === "string" && fileInfo.error.trim()
- ? fileInfo.error.trim()
- : task.error;
- const { line, componentCause } =
- displayFileTaskError(rawError);
+ const fileName = getTaskFileName(filePath, fileInfo);
+ const line = resolveTaskFileError(fileInfo, task.error);
+ const componentCause = formatApiComponent(fileInfo.component);
return (
<div
@@ -199,7 +207,7 @@ export function TaskErrorContent({
? "text-muted-foreground"
: "text-failure-message",
)}
- title={rawError}
+ title={line}
>
{line}
</p>
@@ -229,6 +237,13 @@ export function TaskErrorContent({
</AccordionItem>
</Accordion>
</div>
+
+ <TaskDialog
+ open={isTaskDialogOpen}
+ onOpenChange={setIsTaskDialogOpen}
+ task_id={task.task_id}
+ onClose={() => setIsTaskDialogOpen(false)}
+ />
</div>
);
}
diff --git a/frontend/components/tasks_details.tsx b/frontend/components/tasks_details.tsx
index f6f923453..8a9d2f3ae 100644
--- a/frontend/components/tasks_details.tsx
+++ b/frontend/components/tasks_details.tsx
@@ -2,18 +2,15 @@ import { useEffect, useMemo, useState } from "react";
import { TaskCollapsibleSection } from "@/components/task-collapsible-section";
import { TaskErrorContent } from "@/components/task-error-content";
import { TaskPanelHeader } from "@/components/task-panel-header";
-import { useIsCloudBrand } from "@/contexts/brand-context";
import { useKnowledgeFilter } from "@/contexts/knowledge-filter-context";
import { type Task } from "@/contexts/task-context";
import { parseTimestampMs } from "@/lib/time-utils";
-import { cn } from "@/lib/utils";
interface FailedTasksInfoProps {
failedTasks: Task[];
}
export const FailedTasksInfo = ({ failedTasks }: FailedTasksInfoProps) => {
- const isCloudBrand = useIsCloudBrand();
const [openSections, setOpenSections] = useState<
Record<"recent" | "past", boolean>
>({
@@ -79,12 +76,7 @@ export const FailedTasksInfo = ({ failedTasks }: FailedTasksInfoProps) => {
);
return (
- <div
- className={cn(
- "h-full bg-background border-l overflow-y-auto",
- isCloudBrand && "ibm-tasks-panel",
- )}
- >
+ <div className="h-full bg-background border-l overflow-y-auto">
<TaskPanelHeader onClose={closePanelOnly} />
{failedTasks.length === 0 ? (
@@ -106,12 +98,6 @@ export const FailedTasksInfo = ({ failedTasks }: FailedTasksInfoProps) => {
}))
}
emptyText={section.emptyText}
- contentClassName={cn(
- "flex flex-col",
- isCloudBrand
- ? "p-0 [&>*:last-child]:border-b [&>*:last-child]:border-muted"
- : "gap-2 p-4",
- )}
renderItem={(task) => (
<TaskErrorContent
key={`${section.sectionKey}-${task.task_id}`}
diff --git a/frontend/contexts/task-context.tsx b/frontend/contexts/task-context.tsx
index 838e3760b..ba904933a 100644
--- a/frontend/contexts/task-context.tsx
+++ b/frontend/contexts/task-context.tsx
@@ -12,18 +12,27 @@ import {
} from "react";
import { toast } from "sonner";
import { useCancelTaskMutation } from "@/app/api/mutations/useCancelTaskMutation";
+import type { SearchResult } from "@/app/api/queries/useGetSearchQuery";
import {
+ TASKS_QUERY_KEY,
type Task,
type TaskFileEntry,
useGetTasksQuery,
} from "@/app/api/queries/useGetTasksQuery";
+import type { ListFilesResponse } from "@/app/api/queries/useListFiles";
import { useAuth } from "@/contexts/auth-context";
import { useOnboardingState } from "@/hooks/use-onboarding-state";
import { trackProcessFailure, trackProcessSuccess } from "@/lib/analytics";
+import { getKnowledgeFileIdentity } from "@/lib/knowledge-table-state";
import {
+ didTaskReachCompleted,
+ finalizeProcessingOverlaysForEnhancedTask,
+ findTaskFileOverlayIndex,
+ getEnhancedListDisappearedFilePaths,
getFailedFileCount,
getSuccessfulFileCount,
hasFailedFileEntries,
+ isTaskInProgressStatus,
isTerminalFailedTask,
} from "@/lib/task-utils";
@@ -49,6 +58,8 @@ interface TaskContextType {
files: TaskFile[];
addTask: (taskId: string) => void;
addFiles: (files: Partial<TaskFile>[], taskId: string) => void;
+ /** Mark knowledge-table overlays as processing when a retry starts. */
+ markTaskFilesProcessing: (taskId: string, sourceUrls: string[]) => void;
refreshTasks: () => Promise<void>;
cancelTask: (taskId: string) => Promise<void>;
isPolling: boolean;
@@ -102,10 +113,13 @@ export function TaskProvider({ children }: { children: React.ReactNode }) {
const cancelTaskMutation = useCancelTaskMutation({
onSuccess: (_data, variables) => {
// Immediately remove from React Query cache
- queryClient.setQueryData(["tasks"], (oldTasks: Task[] | undefined) => {
- if (!oldTasks) return [];
- return oldTasks.filter((task) => task.task_id !== variables.taskId);
- });
+ queryClient.setQueryData(
+ [...TASKS_QUERY_KEY],
+ (oldTasks: Task[] | undefined) => {
+ if (!oldTasks) return [];
+ return oldTasks.filter((task) => task.task_id !== variables.taskId);
+ },
+ );
// Update file to display as cancelled
setFiles((prevFiles) =>
@@ -141,6 +155,33 @@ export function TaskProvider({ children }: { children: React.ReactNode }) {
});
}, [queryClient]);
+ const markTaskFilesProcessing = useCallback(
+ (taskId: string, sourceUrls: string[]) => {
+ const paths = new Set(sourceUrls);
+ if (paths.size === 0) {
+ return;
+ }
+ const now = new Date().toISOString();
+ setFiles((prevFiles) => {
+ let changed = false;
+ const updated = prevFiles.map((file) => {
+ if (file.task_id !== taskId || !paths.has(file.source_url)) {
+ return file;
+ }
+ changed = true;
+ return {
+ ...file,
+ status: "processing" as const,
+ error: undefined,
+ updated_at: now,
+ };
+ });
+ return changed ? updated : prevFiles;
+ });
+ },
+ [],
+ );
+
const addFiles = useCallback(
(newFiles: Partial<TaskFile>[], taskId: string) => {
const now = new Date().toISOString();
@@ -178,11 +219,7 @@ export function TaskProvider({ children }: { children: React.ReactNode }) {
(prev) => prev.task_id === currentTask.task_id,
);
- // Check if task is in progress
- const isTaskInProgress =
- currentTask.status === "pending" ||
- currentTask.status === "running" ||
- currentTask.status === "processing";
+ const isTaskInProgress = isTaskInProgressStatus(currentTask.status);
// On initial load, previousTasksRef is empty, so we need to process all in-progress tasks
const isInitialLoad = previousTasksRef.current.length === 0;
@@ -249,8 +286,11 @@ export function TaskProvider({ children }: { children: React.ReactNode }) {
})();
setFiles((prevFiles) => {
- const existingFileIndex = prevFiles.findIndex(
- (f) => f.source_url === filePath,
+ const existingFileIndex = findTaskFileOverlayIndex(
+ prevFiles,
+ currentTask.task_id,
+ filePath,
+ fileName,
);
// Detect connector type based on file path or other indicators
@@ -302,28 +342,28 @@ export function TaskProvider({ children }: { children: React.ReactNode }) {
});
}
- if (isTaskInProgress && previousTask?.files) {
- const currentFileKeys = new Set(Object.keys(currentTask.files ?? {}));
- const disappearedFilePaths = Object.keys(previousTask.files).filter(
- (fp) => !currentFileKeys.has(fp),
+ if (previousTask?.files) {
+ const disappearedFilePaths = getEnhancedListDisappearedFilePaths(
+ currentTask,
+ previousTask,
);
-
- if (disappearedFilePaths.length > 0) {
- setFiles((prevFiles) => {
- let changed = false;
- const updated = prevFiles.map((f) => {
- if (
- f.task_id === currentTask.task_id &&
- f.status === "processing" &&
- disappearedFilePaths.includes(f.source_url)
- ) {
- changed = true;
- return { ...f, status: "active" as TaskFile["status"] };
- }
- return f;
- });
- return changed ? updated : prevFiles;
- });
+ const taskJustCompleted = didTaskReachCompleted(
+ previousTask,
+ currentTask,
+ );
+ const shouldFinalizeDisappeared =
+ disappearedFilePaths.length > 0 &&
+ (isTaskInProgress || taskJustCompleted);
+ const shouldFinalizeAllProcessing = taskJustCompleted;
+
+ if (shouldFinalizeDisappeared || shouldFinalizeAllProcessing) {
+ setFiles((prevFiles) =>
+ finalizeProcessingOverlaysForEnhancedTask(
+ prevFiles,
+ currentTask,
+ shouldFinalizeAllProcessing ? undefined : disappearedFilePaths,
+ ),
+ );
refetchSearch();
}
}
@@ -417,12 +457,62 @@ export function TaskProvider({ children }: { children: React.ReactNode }) {
e,
);
} finally {
+ const indexedIdentities = new Set<string>();
+ const indexedFilenames = new Set<string>();
+ for (const [
+ ,
+ data,
+ ] of queryClient.getQueriesData<ListFilesResponse>({
+ queryKey: ["listFiles"],
+ })) {
+ for (const indexed of data?.files ?? []) {
+ indexedIdentities.add(getKnowledgeFileIdentity(indexed));
+ if (indexed.filename?.trim()) {
+ indexedFilenames.add(indexed.filename.trim());
+ }
+ }
+ }
+ for (const [, data] of queryClient.getQueriesData<SearchResult>({
+ queryKey: ["search"],
+ })) {
+ for (const indexed of data?.files ?? []) {
+ indexedIdentities.add(getKnowledgeFileIdentity(indexed));
+ if (indexed.filename?.trim()) {
+ indexedFilenames.add(indexed.filename.trim());
+ }
+ }
+ }
+
setFiles((prevFiles) =>
- prevFiles.filter(
- (file) =>
- file.task_id !== currentTask.task_id ||
- (completedHasFailures && file.status === "failed"),
- ),
+ prevFiles.filter((file) => {
+ if (file.task_id !== currentTask.task_id) {
+ return true;
+ }
+ if (file.status === "failed") {
+ return completedHasFailures;
+ }
+ if (file.status === "processing") {
+ return false;
+ }
+ if (file.status === "active") {
+ const identity = getKnowledgeFileIdentity({
+ filename: file.filename,
+ source_url: file.source_url,
+ });
+ if (identity && indexedIdentities.has(identity)) {
+ return false;
+ }
+ const sourceUrl = file.source_url?.trim();
+ if (!sourceUrl || !identity) {
+ const filename = file.filename?.trim();
+ if (filename && indexedFilenames.has(filename)) {
+ return false;
+ }
+ }
+ return true;
+ }
+ return false;
+ }),
);
}
}
@@ -531,6 +621,7 @@ export function TaskProvider({ children }: { children: React.ReactNode }) {
files,
addTask,
addFiles,
+ markTaskFilesProcessing,
refreshTasks,
cancelTask,
isPolling,
diff --git a/frontend/lib/task-error-display.ts b/frontend/lib/task-error-display.ts
index 782b40502..bbe2e8277 100644
--- a/frontend/lib/task-error-display.ts
+++ b/frontend/lib/task-error-display.ts
@@ -1,33 +1,65 @@
-// Will update when backend is ready (error_summary, failing_step, component_cause).
+import type {
+ TaskFailureComponent,
+ TaskFailurePhase,
+ TaskFileEntry,
+} from "@/app/api/queries/useGetTasksQuery";
export const FILE_ERROR_MAX_LINE_LENGTH = 80;
-export type TaskErrorComponentCause = "OpenSearch" | "Docling" | "Langflow";
-
-const COMPONENT_CAUSES: ReadonlyArray<{
- keyword: string;
- label: TaskErrorComponentCause;
-}> = [
- { keyword: "opensearch", label: "OpenSearch" },
- { keyword: "docling", label: "Docling" },
- { keyword: "langflow", label: "Langflow" },
-];
+export type TaskErrorComponentCause =
+ | "OpenSearch"
+ | "Docling"
+ | "Langflow"
+ | "OpenRAG";
+
+export type TaskPipelineStepId =
+ | "parsing"
+ | "chunking"
+ | "embedding"
+ | "indexing"
+ | "file_validation"
+ | "unknown";
+
+export interface IngestionPipelineStep {
+ id: TaskPipelineStepId;
+ label: string;
+ status: "completed" | "failed";
+}
-export interface FileTaskErrorDisplay {
- line: string;
+export interface TaskFileIngestionFailureAnalysis {
+ resolvedError: string;
+ failedStep: TaskPipelineStepId;
+ pipelineSteps: IngestionPipelineStep[];
+ rowStatusLabel: string;
+ failureSummary: string;
componentCause?: TaskErrorComponentCause;
+ componentTags: string[];
+ summaryLine: string;
}
-function normalizeErrorText(raw: string): string {
- return raw.replace(/\s+/g, " ").trim();
-}
+const PIPELINE_STEP_ORDER: TaskPipelineStepId[] = [
+ "parsing",
+ "chunking",
+ "embedding",
+ "indexing",
+];
-function stripNoisePrefixes(text: string): string {
- return text
- .replace(/^Error running graph:\s*/i, "")
- .replace(/^Error building Component [^:]+:\s*/i, "")
- .trim();
-}
+const PIPELINE_STEP_LABELS: Record<TaskPipelineStepId, string> = {
+ parsing: "Parsing",
+ chunking: "Chunking",
+ embedding: "Embedding",
+ indexing: "Indexing",
+ file_validation: "File validation",
+ unknown: "Ingestion",
+};
+
+const COMPONENT_LABELS: Record<TaskFailureComponent, TaskErrorComponentCause> =
+ {
+ docling: "Docling",
+ openrag: "OpenRAG",
+ langflow: "Langflow",
+ opensearch: "OpenSearch",
+ };
function truncateLine(
text: string,
@@ -39,55 +71,105 @@ function truncateLine(
return `${text.slice(0, maxLength - 1).trimEnd()}…`;
}
-/** Prefer a short clause from long, nested error strings. */
-function extractReadableLine(text: string): string {
- const beforeCausedBy = text.split(/\s+caused by:/i)[0]?.trim() ?? text;
-
- if (beforeCausedBy.length <= FILE_ERROR_MAX_LINE_LENGTH) {
- return beforeCausedBy;
+export function formatApiComponent(
+ component?: TaskFailureComponent,
+): TaskErrorComponentCause | undefined {
+ if (!component) {
+ return undefined;
}
+ return COMPONENT_LABELS[component];
+}
- const colonParts = beforeCausedBy.split(":");
- const lastClause = colonParts[colonParts.length - 1]?.trim();
- if (
- lastClause &&
- lastClause.length >= 10 &&
- lastClause.length <= FILE_ERROR_MAX_LINE_LENGTH
- ) {
- return lastClause;
+export function normalizeFailurePhase(
+ phase?: string,
+): TaskPipelineStepId | undefined {
+ if (!phase) {
+ return undefined;
}
-
- return beforeCausedBy;
+ if (phase in PIPELINE_STEP_LABELS) {
+ return phase as TaskPipelineStepId;
+ }
+ return undefined;
}
-export function detectComponentCause(
- raw: string,
-): TaskErrorComponentCause | undefined {
- const lower = raw.toLowerCase();
- for (const { keyword, label } of COMPONENT_CAUSES) {
- if (lower.includes(keyword)) {
- return label;
- }
+export function buildRowStatusLabel(failedStep: TaskPipelineStepId): string {
+ if (failedStep === "file_validation") {
+ return "File validation issue";
}
- return undefined;
+ if (failedStep === "unknown") {
+ return "Failed";
+ }
+ return `${PIPELINE_STEP_LABELS[failedStep]} issue`;
}
-export function displayFileTaskError(
- raw: string | undefined | null,
-): FileTaskErrorDisplay {
- if (!raw?.trim()) {
- return { line: "Unknown error" };
+export function buildFailureSummary(failedStep: TaskPipelineStepId): string {
+ return `Failed at ${PIPELINE_STEP_LABELS[failedStep].toLowerCase()}`;
+}
+
+export function buildPipelineStepsFromFailurePhase(
+ failurePhase: TaskPipelineStepId,
+): IngestionPipelineStep[] {
+ if (failurePhase === "file_validation" || failurePhase === "unknown") {
+ return [
+ {
+ id: failurePhase,
+ label: PIPELINE_STEP_LABELS[failurePhase],
+ status: "failed",
+ },
+ ];
}
- const normalized = normalizeErrorText(raw);
- const componentCause = detectComponentCause(normalized);
+ const failedIndex = PIPELINE_STEP_ORDER.indexOf(failurePhase);
+ if (failedIndex < 0) {
+ return [
+ { id: "unknown", label: PIPELINE_STEP_LABELS.unknown, status: "failed" },
+ ];
+ }
- let line = stripNoisePrefixes(normalized);
- line = truncateLine(extractReadableLine(line));
+ return PIPELINE_STEP_ORDER.slice(0, failedIndex + 1).map((id, index) => ({
+ id,
+ label: PIPELINE_STEP_LABELS[id],
+ status: index < failedIndex ? "completed" : "failed",
+ }));
+}
- if (!line) {
- line = "Unknown error";
+export function resolveTaskFileError(
+ fileInfo: TaskFileEntry,
+ taskError?: string,
+): string {
+ if (typeof fileInfo.user_facing_message === "string") {
+ const message = fileInfo.user_facing_message.trim();
+ if (message) {
+ return message;
+ }
}
+ if (typeof fileInfo.error === "string" && fileInfo.error.trim()) {
+ return fileInfo.error.trim();
+ }
+ if (typeof taskError === "string" && taskError.trim()) {
+ return taskError.trim();
+ }
+ return "Unknown error";
+}
- return componentCause ? { line, componentCause } : { line };
+export function analyzeTaskFileIngestionFailure(
+ fileInfo: TaskFileEntry,
+ taskError?: string,
+): TaskFileIngestionFailureAnalysis {
+ const resolvedError = resolveTaskFileError(fileInfo, taskError);
+ const failedStep = normalizeFailurePhase(fileInfo.failure_phase) ?? "unknown";
+ const pipelineSteps = buildPipelineStepsFromFailurePhase(failedStep);
+ const componentCause = formatApiComponent(fileInfo.component);
+ const componentTags = componentCause ? [componentCause] : [];
+
+ return {
+ resolvedError,
+ failedStep,
+ pipelineSteps,
+ rowStatusLabel: buildRowStatusLabel(failedStep),
+ failureSummary: buildFailureSummary(failedStep),
+ componentCause,
+ componentTags,
+ summaryLine: truncateLine(resolvedError),
+ };
}
diff --git a/frontend/lib/task-utils.ts b/frontend/lib/task-utils.ts
index 8f22468d5..7618661c2 100644
--- a/frontend/lib/task-utils.ts
+++ b/frontend/lib/task-utils.ts
@@ -1,11 +1,220 @@
import type { Task, TaskFileEntry } from "@/app/api/queries/useGetTasksQuery";
+import {
+ buildRowStatusLabel,
+ normalizeFailurePhase,
+} from "@/lib/task-error-display";
+
+export const ALL_TASK_FILE_TYPES = "__all__";
+export const ALL_TASK_STATUS_CATEGORIES = "__all__";
+
+export type TaskFileStatusCategory = "completed" | "system_error" | "indexing";
+
+export type TaskFileNameSort = "asc" | "desc";
+
+export type TaskFileFilterOptions = {
+ search?: string;
+ fileType?: string | typeof ALL_TASK_FILE_TYPES;
+ statusCategory?: TaskFileStatusCategory | typeof ALL_TASK_STATUS_CATEGORIES;
+ task?: Task;
+};
+
+export function isTaskFileCompleted(fileInfo: TaskFileEntry): boolean {
+ return fileInfo.status === "completed";
+}
+
+export function isTaskFileFailed(fileInfo: TaskFileEntry): boolean {
+ return fileInfo.status === "failed" || fileInfo.status === "error";
+}
+
+export function getTaskFileDialogStatusLabel(
+ fileInfo: TaskFileEntry,
+ taskError?: string,
+): string {
+ if (isTaskFileFailed(fileInfo)) {
+ const failurePhase = normalizeFailurePhase(fileInfo.failure_phase);
+ if (failurePhase) {
+ return buildRowStatusLabel(failurePhase);
+ }
+ if (fileInfo.user_facing_message?.trim()) {
+ return "Failed";
+ }
+ return buildRowStatusLabel("unknown");
+ }
+ if (isTaskFileCompleted(fileInfo)) {
+ return "Complete";
+ }
+ return "Processing";
+}
+
+export function getTaskFileName(
+ filePath: string,
+ fileInfo: TaskFileEntry,
+): string {
+ return fileInfo.filename || filePath.split("/").pop() || filePath;
+}
+
+/** Lowercase extension without dot, or empty string when none. */
+export function getFileExtensionFromName(filename: string): string {
+ const trimmed = filename.trim();
+ const dotIndex = trimmed.lastIndexOf(".");
+ if (dotIndex <= 0 || dotIndex === trimmed.length - 1) {
+ return "";
+ }
+ return trimmed.slice(dotIndex + 1).toLowerCase();
+}
+
+export function getTaskFileTypeKey(
+ filePath: string,
+ fileInfo: TaskFileEntry,
+): string {
+ const extension = getFileExtensionFromName(
+ getTaskFileName(filePath, fileInfo),
+ );
+ return extension || "unknown";
+}
+
+export function getTaskFileEntries(task: Task): Array<[string, TaskFileEntry]> {
+ return Object.entries(task.files || {});
+}
+
+export function getTaskFileTypes(task: Task): string[] {
+ const types = new Set(
+ getTaskFileEntries(task).map(([path, entry]) =>
+ getTaskFileTypeKey(path, entry),
+ ),
+ );
+ return Array.from(types).sort((a, b) => a.localeCompare(b));
+}
+
+export function formatTaskFileTypeLabel(fileType: string): string {
+ if (fileType === "unknown") {
+ return "Unknown";
+ }
+ return fileType.toUpperCase();
+}
+
+export function isTaskFileRetryable(fileInfo: TaskFileEntry): boolean {
+ return fileInfo.actionable_by === "RETRYABLE";
+}
+
+export function getRetryableFileEntries(
+ task: Task,
+): Array<[string, TaskFileEntry]> {
+ return getTaskFileEntries(task).filter(([, fileInfo]) =>
+ isTaskFileRetryable(fileInfo),
+ );
+}
+
+export function getRetryableFilePaths(
+ entries: Array<[string, TaskFileEntry]>,
+): string[] {
+ return entries
+ .filter(([, fileInfo]) => isTaskFileRetryable(fileInfo))
+ .map(([filePath]) => filePath);
+}
+
+export function countRetryIngestionFiles(task: Task): number {
+ return getTaskFileEntries(task).filter(([, fileInfo]) =>
+ isTaskFileRetryable(fileInfo),
+ ).length;
+}
+
+/** Maps a file to a dialog filter chip bucket (aligned with per-file status labels). */
+export function getTaskFileStatusCategory(
+ fileInfo: TaskFileEntry,
+): TaskFileStatusCategory {
+ if (isTaskFileFailed(fileInfo)) {
+ return "system_error";
+ }
+
+ const status = fileInfo.status ?? "pending";
+ if (status === "pending" || status === "running" || status === "processing") {
+ return "indexing";
+ }
+
+ if (status === "completed") {
+ return "completed";
+ }
+
+ return "indexing";
+}
+
+export function countTaskFileEntriesByCategory(
+ entries: Array<[string, TaskFileEntry]>,
+): Record<TaskFileStatusCategory, number> {
+ const counts: Record<TaskFileStatusCategory, number> = {
+ completed: 0,
+ system_error: 0,
+ indexing: 0,
+ };
+
+ for (const [, fileInfo] of entries) {
+ const category = getTaskFileStatusCategory(fileInfo);
+ counts[category] += 1;
+ }
+
+ return counts;
+}
+
+export function countTaskFilesByCategory(
+ task: Task,
+): Record<TaskFileStatusCategory, number> {
+ return countTaskFileEntriesByCategory(getTaskFileEntries(task));
+}
+
+export function sortTaskFileEntries(
+ entries: Array<[string, TaskFileEntry]>,
+ direction: TaskFileNameSort = "asc",
+): Array<[string, TaskFileEntry]> {
+ const sorted = [...entries].sort(([pathA, infoA], [pathB, infoB]) =>
+ getTaskFileName(pathA, infoA).localeCompare(
+ getTaskFileName(pathB, infoB),
+ undefined,
+ { sensitivity: "base" },
+ ),
+ );
+ return direction === "asc" ? sorted : sorted.reverse();
+}
+
+export function filterTaskFileEntries(
+ entries: Array<[string, TaskFileEntry]>,
+ options: TaskFileFilterOptions,
+): Array<[string, TaskFileEntry]> {
+ const query = options.search?.trim().toLowerCase() ?? "";
+ const fileType = options.fileType ?? ALL_TASK_FILE_TYPES;
+ const statusCategory = options.statusCategory ?? ALL_TASK_STATUS_CATEGORIES;
+
+ return entries.filter(([filePath, fileInfo]) => {
+ if (fileType !== ALL_TASK_FILE_TYPES) {
+ const typeKey = getTaskFileTypeKey(filePath, fileInfo);
+ if (typeKey !== fileType) {
+ return false;
+ }
+ }
+
+ if (
+ statusCategory !== ALL_TASK_STATUS_CATEGORIES &&
+ getTaskFileStatusCategory(fileInfo) !== statusCategory
+ ) {
+ return false;
+ }
+
+ if (query) {
+ const name = getTaskFileName(filePath, fileInfo);
+ if (!name.toLowerCase().includes(query)) {
+ return false;
+ }
+ }
+
+ return true;
+ });
+}
export function getFailedFileEntries(
task: Task,
): Array<[string, TaskFileEntry]> {
- return Object.entries(task.files || {}).filter(
- ([, fileInfo]) =>
- fileInfo?.status === "failed" || fileInfo?.status === "error",
+ return Object.entries(task.files || {}).filter(([, fileInfo]) =>
+ isTaskFileFailed(fileInfo),
);
}
@@ -48,3 +257,121 @@ export function isCompletedTotalFailure(task: Task): boolean {
export function isFailureLikeTask(task: Task): boolean {
return isTerminalFailedTask(task) || isCompletedWithFailures(task);
}
+
+export function isTaskInProgressStatus(status: Task["status"]): boolean {
+ return (
+ status === "pending" || status === "running" || status === "processing"
+ );
+}
+
+/** True when a task has just transitioned to completed. */
+export function didTaskReachCompleted(
+ previousTask: Task | undefined,
+ currentTask: Task,
+): boolean {
+ return (
+ !!previousTask &&
+ previousTask.status !== "completed" &&
+ currentTask.status === "completed"
+ );
+}
+
+/**
+ * File paths present on the previous enhanced-list payload but omitted now.
+ * The enhanced list drops completed files from `files` while a task is still running.
+ */
+/** Stable overlay key before the backend temp path is known. */
+export function pendingTaskFileSourceUrl(
+ taskId: string,
+ filename: string,
+): string {
+ return `pending:${taskId}:${filename}`;
+}
+
+export function isPendingTaskFileSourceUrl(sourceUrl: string): boolean {
+ return sourceUrl.startsWith("pending:");
+}
+
+export function findTaskFileOverlayIndex(
+ files: Array<{ task_id: string; source_url: string; filename: string }>,
+ taskId: string,
+ filePath: string,
+ fileName: string,
+): number {
+ const pendingUrl = pendingTaskFileSourceUrl(taskId, fileName);
+ return files.findIndex(
+ (f) =>
+ f.task_id === taskId &&
+ (f.source_url === filePath ||
+ f.source_url === pendingUrl ||
+ (f.filename === fileName && isPendingTaskFileSourceUrl(f.source_url))),
+ );
+}
+
+export function getEnhancedListDisappearedFilePaths(
+ currentTask: Task,
+ previousTask: Task,
+): string[] {
+ const currentKeys = new Set(Object.keys(currentTask.files ?? {}));
+ return Object.keys(previousTask.files ?? {}).filter(
+ (filePath) => !currentKeys.has(filePath),
+ );
+}
+
+interface ProcessingFileOverlay {
+ task_id: string;
+ source_url: string;
+ status: "active" | "failed" | "processing";
+ error?: string;
+}
+
+/**
+ * Promote local processing overlays when the enhanced list omits completed files.
+ * Pass `disappearedPaths` while the task is in progress; omit it when the task completes
+ * to finalize every remaining processing file for that task.
+ */
+export function finalizeProcessingOverlaysForEnhancedTask<
+ T extends ProcessingFileOverlay,
+>(prevFiles: T[], currentTask: Task, disappearedPaths?: string[]): T[] {
+ const pathsFilter =
+ disappearedPaths === undefined ? null : new Set(disappearedPaths);
+ let changed = false;
+
+ const updated = prevFiles.map((file) => {
+ if (file.task_id !== currentTask.task_id) {
+ return file;
+ }
+ if (pathsFilter !== null && !pathsFilter.has(file.source_url)) {
+ return file;
+ }
+ // Overlays can still be "failed" until the list poll sees a retry as running.
+ if (file.status !== "processing" && file.status !== "failed") {
+ return file;
+ }
+
+ const entry = currentTask.files?.[file.source_url];
+ if (entry && isTaskFileFailed(entry)) {
+ if (file.status === "failed") {
+ const error =
+ typeof entry.error === "string" && entry.error.trim().length > 0
+ ? entry.error.trim()
+ : file.error;
+ if (error === file.error) {
+ return file;
+ }
+ }
+ changed = true;
+ const error =
+ typeof entry.error === "string" && entry.error.trim().length > 0
+ ? entry.error.trim()
+ : file.error;
+ return { ...file, status: "failed" as const, error };
+ }
+
+ // Left the enhanced list (completed files are omitted) or task finished.
+ changed = true;
+ return { ...file, status: "active" as const, error: undefined };
+ });
+
+ return changed ? (updated as T[]) : prevFiles;
+}
diff --git a/frontend/tailwind.config.ts b/frontend/tailwind.config.ts
index b50d0e638..d6e37d9c8 100644
--- a/frontend/tailwind.config.ts
+++ b/frontend/tailwind.config.ts
@@ -24,6 +24,20 @@ const config = {
extend: {
maxWidth: {
content: "960px",
+ "task-dialog": "var(--task-dialog-width)",
+ },
+ height: {
+ "task-dialog": "var(--task-dialog-max-height)",
+ },
+ maxHeight: {
+ "task-dialog": "var(--task-dialog-max-height)",
+ },
+ width: {
+ "task-dialog": "var(--task-dialog-width)",
+ "task-dialog-file-type": "var(--task-dialog-file-type-width)",
+ },
+ zIndex: {
+ "task-dialog-menu": "var(--z-task-dialog-menu)",
},
screens: {
xl: "1200px",
@@ -157,9 +171,14 @@ const config = {
DEFAULT: "hsl(var(--card))",
foreground: "hsl(var(--card-foreground))",
},
+ canvas: "hsl(var(--canvas))",
"layer-contextual": "hsl(var(--layer-contextual))",
+ "task-dialog-oss": "hsl(var(--task-dialog-oss-bg))",
+ "task-dialog-oss-selected": "hsl(var(--task-dialog-oss-selected))",
"layer-contextual-foreground":
"hsl(var(--layer-contextual-foreground))",
+ "border-subtle-contextual":
+ "hsl(var(--border-subtle-background-contextual))",
"text-text-01": "hsl(var(--text-text-01))",
"link-primary": "hsl(var(--link-primary))",
"button-tertiary": "hsl(var(--button-tertiary))",
@@ -215,6 +234,9 @@ const config = {
},
spacing: {
mmd: "13px",
+ "task-dialog-error-indent": "var(--task-dialog-error-indent)",
+ "task-dialog-error-indent-cloud":
+ "var(--task-dialog-error-indent-cloud)",
},
borderRadius: {
lg: "var(--radius)",
diff --git a/frontend/tests/core/tasks-unified-panel.spec.ts b/frontend/tests/core/tasks-unified-panel.spec.ts
index 7bb57146a..3d6797a29 100644
--- a/frontend/tests/core/tasks-unified-panel.spec.ts
+++ b/frontend/tests/core/tasks-unified-panel.spec.ts
@@ -64,7 +64,11 @@ const buildTask = (
const wireTasksState = async (page: Page, initialTasks: MockTask[]) => {
let currentTasks = initialTasks;
- await page.route("**/api/tasks", async (route: Route) => {
+ await page.route("**/api/tasks**", async (route: Route) => {
+ if (route.request().method() !== "GET") {
+ await route.continue();
+ return;
+ }
await route.fulfill({
status: 200,
contentType: "application/json",
diff --git a/src/api/schemas/tasks.py b/src/api/schemas/tasks.py
new file mode 100644
index 000000000..de2d45138
--- /dev/null
+++ b/src/api/schemas/tasks.py
@@ -0,0 +1,22 @@
+from pydantic import BaseModel, Field
+
+
+class ErrorResponse(BaseModel):
+ error: str
+ message: str | None = None
+ task_id: str | None = None
+
+
+class TaskRetrySkippedFile(BaseModel):
+ file_path: str
+ filename: str | None = None
+ reason: str | None = None
+
+
+class TaskRetryResponse(BaseModel):
+ task_id: str
+ retried: int = 0
+ skipped: list[TaskRetrySkippedFile] = Field(default_factory=list)
+ status: str
+ message: str | None = None
+ error: str | None = None
diff --git a/src/api/tasks.py b/src/api/tasks.py
index c5c779ce7..8e695c8d2 100644
--- a/src/api/tasks.py
+++ b/src/api/tasks.py
@@ -1,5 +1,6 @@
-from fastapi import Depends
+from fastapi import Body, Depends
from fastapi.responses import JSONResponse
+from pydantic import BaseModel, Field
from dependencies import get_current_user, get_task_service
from session_manager import User
@@ -50,6 +51,41 @@ async def all_tasks_enhanced(
return JSONResponse({"tasks": tasks})
+class RetryTaskBody(BaseModel):
+ file_paths: list[str] | None = Field(
+ default=None,
+ description=(
+ "Optional subset of task file paths to retry. Omit to retry all failed RETRYABLE files."
+ ),
+ )
+
+
+async def retry_task(
+ task_id: str,
+ body: RetryTaskBody = Body(default_factory=RetryTaskBody),
+ task_service=Depends(get_task_service),
+ user: User = Depends(get_current_user),
+):
+ """Re-run ingestion for failed RETRYABLE files in an existing task."""
+ result = await task_service.retry_failed_files(
+ user.user_id, task_id, file_paths=body.file_paths
+ )
+ if result is None:
+ return JSONResponse({"error": "Task not found"}, status_code=404)
+
+ if result.get("error") == "task_in_progress":
+ return JSONResponse(result, status_code=409)
+
+ if result.get("error") == "no_processor":
+ return JSONResponse(result, status_code=400)
+
+ if result.get("status") == "no_op":
+ return JSONResponse(result, status_code=400)
+
+ await TelemetryClient.send_event(Category.TASK_OPERATIONS, MessageId.ORB_TASK_RETRIED)
+ return JSONResponse(result, status_code=202)
+
+
async def cancel_task(
task_id: str,
task_service=Depends(get_task_service),
diff --git a/src/app/routes/internal.py b/src/app/routes/internal.py
index 1b0a64f35..299f05016 100644
--- a/src/app/routes/internal.py
+++ b/src/app/routes/internal.py
@@ -6,7 +6,7 @@ Auth and service injection are handled inside each handler via FastAPI
Depends, not here. This module only wires URL → handler.
"""
-from fastapi import FastAPI
+from fastapi import FastAPI, status
from api import (
auth,
@@ -30,6 +30,7 @@ from api import (
)
from api import keys as api_keys
from api.health import health_check, opensearch_health_ready
+from api.schemas.tasks import ErrorResponse, TaskRetryResponse
from connectors.aws_s3.api import (
s3_bucket_status,
s3_configure,
@@ -91,6 +92,20 @@ def register_internal_routes(app: FastAPI):
tags=["internal"],
)
app.add_api_route("/tasks", tasks.all_tasks, methods=["GET"], tags=["internal"])
+ app.add_api_route(
+ "/tasks/{task_id}/retry",
+ tasks.retry_task,
+ methods=["POST"],
+ tags=["internal"],
+ status_code=status.HTTP_202_ACCEPTED,
+ response_model=TaskRetryResponse,
+ responses={
+ 400: {"model": ErrorResponse},
+ 404: {"model": ErrorResponse},
+ 409: {"model": ErrorResponse},
+ 500: {"model": ErrorResponse},
+ },
+ )
app.add_api_route(
"/tasks/{task_id}/cancel",
tasks.cancel_task,
diff --git a/src/config/settings.py b/src/config/settings.py
index d4227310b..6e9e4f4d9 100644
--- a/src/config/settings.py
+++ b/src/config/settings.py
@@ -276,6 +276,8 @@ UPLOAD_BATCH_SIZE = get_env_int("UPLOAD_BATCH_SIZE", 25)
# Default: 40 minutes total, 40 minutes read timeout
LANGFLOW_TIMEOUT = get_env_float("LANGFLOW_TIMEOUT", 2400.0) # 40 minutes
LANGFLOW_CONNECT_TIMEOUT = get_env_float("LANGFLOW_CONNECT_TIMEOUT", 30.0) # 30 seconds
+# Retries for transient Langflow HTTP failures (disconnects, 502/503/504).
+LANGFLOW_REQUEST_RETRIES = get_env_int("LANGFLOW_REQUEST_RETRIES", 2)
# Per-file processing timeout for document ingestion tasks (in seconds)
# Should be >= LANGFLOW_TIMEOUT to allow long-running ingestion to complete
@@ -342,7 +344,6 @@ INDEX_BODY = {
"embedding_model": {"type": "keyword"},
"source_url": {"type": "keyword"},
"connector_type": {"type": "keyword"},
- "connector_file_id": {"type": "keyword"},
"owner": {"type": "keyword"},
"allowed_users": {"type": "keyword"},
"allowed_groups": {"type": "keyword"},
@@ -878,42 +879,113 @@ class AppClients:
async def langflow_request(self, method: str, endpoint: str, **kwargs):
"""Central method for all Langflow API requests.
- Retries once with a fresh API key on auth failures (401/403).
+ Retries transient transport/server errors and once with a fresh API key on
+ auth failures (401/403).
"""
- api_key = await get_langflow_api_key()
- if not api_key:
- raise ValueError("No Langflow API key available")
+ _TRANSIENT_STATUS_CODES = {408, 429, 500, 502, 503, 504}
+ max_attempts = max(1, LANGFLOW_REQUEST_RETRIES + 1)
+ last_error: Exception | None = None
+ auth_retry_attempted = False
+ request_kwargs = dict(kwargs)
+ passed_headers = request_kwargs.pop("headers", {}) or {}
- # Merge headers properly - passed headers take precedence over defaults
- default_headers = {"x-api-key": api_key, "Content-Type": "application/json"}
- existing_headers = kwargs.pop("headers", {})
- headers = {**default_headers, **existing_headers}
+ for attempt in range(max_attempts):
+ api_key = await get_langflow_api_key()
+ if not api_key:
+ raise ValueError("No Langflow API key available")
- # Remove Content-Type if explicitly set to None (for file uploads)
- if headers.get("Content-Type") is None:
- headers.pop("Content-Type", None)
+ # Merge headers properly - passed headers take precedence over defaults
+ default_headers = {"x-api-key": api_key, "Content-Type": "application/json"}
+ headers = {**default_headers, **passed_headers}
- url = f"{LANGFLOW_URL}{endpoint}"
+ # Remove Content-Type if explicitly set to None (for file uploads)
+ if headers.get("Content-Type") is None:
+ headers.pop("Content-Type", None)
- response = await self.langflow_http_client.request(
- method=method, url=url, headers=headers, **kwargs
- )
+ url = f"{LANGFLOW_URL}{endpoint}"
- # Retry once with a fresh API key on auth failure
- if response.status_code in (401, 403):
- logger.warning(
- "Langflow request auth failed, regenerating API key and retrying",
- status_code=response.status_code,
- endpoint=endpoint,
- )
- api_key = await get_langflow_api_key(force_regenerate=True)
- if api_key:
- headers["x-api-key"] = api_key
+ try:
response = await self.langflow_http_client.request(
- method=method, url=url, headers=headers, **kwargs
+ method=method, url=url, headers=headers, **request_kwargs
+ )
+ except httpx.RequestError as exc:
+ last_error = exc
+ if attempt + 1 < max_attempts:
+ delay = min(2**attempt, 4)
+ logger.warning(
+ "Langflow request transport error, retrying",
+ endpoint=endpoint,
+ attempt=attempt + 1,
+ max_attempts=max_attempts,
+ error=str(exc),
+ retry_in_seconds=delay,
+ )
+ await asyncio.sleep(delay)
+ continue
+ raise
+
+ # Retry once with a fresh API key on auth failure
+ if response.status_code in (401, 403) and not auth_retry_attempted:
+ logger.warning(
+ "Langflow request auth failed, regenerating API key and retrying",
+ status_code=response.status_code,
+ endpoint=endpoint,
+ )
+ auth_retry_attempted = True
+ api_key = await get_langflow_api_key(force_regenerate=True)
+ if api_key:
+ headers["x-api-key"] = api_key
+ try:
+ response = await self.langflow_http_client.request(
+ method=method, url=url, headers=headers, **request_kwargs
+ )
+ except httpx.RequestError as exc:
+ last_error = exc
+ if attempt + 1 < max_attempts:
+ delay = min(2**attempt, 4)
+ logger.warning(
+ "Langflow auth retry transport error, retrying",
+ endpoint=endpoint,
+ attempt=attempt + 1,
+ max_attempts=max_attempts,
+ error=str(exc),
+ retry_in_seconds=delay,
+ )
+ await asyncio.sleep(delay)
+ continue
+ raise
+
+ if response.status_code in (401, 403) and attempt + 1 < max_attempts:
+ delay = min(2**attempt, 4)
+ logger.warning(
+ "Langflow auth failure persists, retrying request",
+ endpoint=endpoint,
+ status_code=response.status_code,
+ attempt=attempt + 1,
+ max_attempts=max_attempts,
+ retry_in_seconds=delay,
)
+ await asyncio.sleep(delay)
+ continue
+
+ if response.status_code in _TRANSIENT_STATUS_CODES and attempt + 1 < max_attempts:
+ delay = min(2**attempt, 4)
+ logger.warning(
+ "Langflow request returned transient status, retrying",
+ endpoint=endpoint,
+ status_code=response.status_code,
+ attempt=attempt + 1,
+ max_attempts=max_attempts,
+ retry_in_seconds=delay,
+ )
+ await asyncio.sleep(delay)
+ continue
+
+ return response
- return response
+ if last_error is not None:
+ raise last_error
+ raise RuntimeError("Langflow request failed without a response")
async def _create_langflow_global_variable(self, name: str, value: str, modify: bool = False):
"""Create a global variable in Langflow via API"""
diff --git a/src/models/processors.py b/src/models/processors.py
index 4d4a06093..e12081bd1 100644
--- a/src/models/processors.py
+++ b/src/models/processors.py
@@ -548,10 +548,9 @@ class ConnectorFileProcessor(TaskProcessor):
except (FileNotFoundError, ValueError) as e:
msg = str(e).lower()
if "not found" in msg or "404" in msg:
- # File gone at source — remove indexed chunks by connector_file_id
- # so they stop appearing in search/chat. Chunks are indexed with
- # document_id=file_hash (SHA of content), not file_id, so we must
- # query the dedicated connector_file_id field set at index time.
+ # File gone at source — remove indexed chunks by document_id
+ # (= connector file_id) so it stops appearing in search/chat.
+ # Filename rename (e.g. .txt → .md) is irrelevant here.
deleted_chunks = 0
try:
from api.documents import delete_chunks_by_document_ids
@@ -562,10 +561,7 @@ class ConnectorFileProcessor(TaskProcessor):
)
)
deleted_chunks = await delete_chunks_by_document_ids(
- [file_id],
- opensearch_client,
- get_index_name(),
- field="connector_file_id",
+ [file_id], opensearch_client, get_index_name()
)
except Exception as cleanup_err:
logger.error(
diff --git a/src/services/task_service.py b/src/services/task_service.py
index 20604ff84..48a590a87 100644
--- a/src/services/task_service.py
+++ b/src/services/task_service.py
@@ -17,6 +17,107 @@ T = TypeVar("T")
logger = get_logger(__name__)
+# Substrings that indicate a permanent file/content problem (not worth retrying).
+_NON_RETRYABLE_FILE_ERROR_MARKERS = (
+ "corrupt",
+ "corrupted",
+ "corruption",
+ "invalid file",
+ "invalid document",
+ "unsupported format",
+ "unsupported file",
+ "malformed",
+ "damaged",
+ "not a zip file",
+ "bad zipfile",
+ "failed to parse",
+ "could not be parsed",
+ "cannot parse",
+ "no text content could be extracted",
+ "empty or unreadable",
+ "unreadable",
+ "validationerror",
+)
+
+# Docling polling errors that are transient (service/timeout), not bad file content.
+_DOCLING_TRANSIENT_ERROR_MARKERS = (
+ "(timeout)",
+ "timed out",
+ "polling exceeded",
+ "polling timed out",
+)
+
+# Connector/download/network failures seen while file is still in Docling phase.
+# These are infrastructure/transient and should be retryable.
+_TRANSIENT_CONNECTIVITY_ERROR_MARKERS = (
+ "all connection attempts failed",
+ "connection refused",
+ "connection reset",
+ "temporary failure in name resolution",
+ "name or service not known",
+ "service unavailable",
+ "network is unreachable",
+ "server disconnected",
+ "disconnected without sending a response",
+ "remote protocol error",
+ "broken pipe",
+)
+
+
+def _is_non_retryable_file_error(error: str) -> bool:
+ lowered = error.lower()
+ return any(marker in lowered for marker in _NON_RETRYABLE_FILE_ERROR_MARKERS)
+
+
+def _is_transient_connectivity_error(error: str) -> bool:
+ lowered = error.lower()
+ return any(marker in lowered for marker in _TRANSIENT_CONNECTIVITY_ERROR_MARKERS)
+
+
+def _is_docling_transient_error(error: str) -> bool:
+ lowered = error.lower()
+ # Legacy timeout messages emitted by Docling polling path.
+ if "docling conversion did not complete" in lowered:
+ return any(marker in lowered for marker in _DOCLING_TRANSIENT_ERROR_MARKERS)
+
+ # Connector-originated transient network failures can still surface while
+ # file phase is DOCLING (before conversion can complete).
+ return _is_transient_connectivity_error(error)
+
+
+def _transient_connectivity_user_message(error: str) -> str:
+ lowered = error.lower()
+ if any(
+ marker in lowered
+ for marker in (
+ "disconnect",
+ "without sending a response",
+ "connection refused",
+ "connection reset",
+ "broken pipe",
+ "remote protocol",
+ )
+ ):
+ return "Ingestion service connection was lost. Please retry ingestion."
+ if any(marker in lowered for marker in ("timeout", "timed out")):
+ return "Document processing timed out. Please retry ingestion."
+ return "Ingestion service was temporarily unavailable. Please retry ingestion."
+
+
+def _is_langflow_transport_failure(error: str) -> bool:
+ """HTTP client / Langflow transport failures on the connector ingest path."""
+ lowered = error.lower()
+ return any(
+ marker in lowered
+ for marker in (
+ "server disconnected",
+ "disconnected without sending a response",
+ "remote protocol error",
+ "read error",
+ "write error",
+ )
+ )
+
class IngestionTimeoutError(Exception):
"""Raised when file processing exceeds the configured timeout"""
@@ -590,6 +691,171 @@ class TaskService:
return self.task_store[candidate_user_id][task_id]
return None
+ def _resolve_upload_task_store(
+ self, user_id: str, task_id: str
+ ) -> tuple[str, UploadTask] | None:
+ """Return (store_user_id, upload_task) for a task visible to this user."""
+ if not task_id:
+ return None
+ for candidate_user_id in [user_id, AnonymousUser().user_id]:
+ if (
+ candidate_user_id in self.task_store
+ and task_id in self.task_store[candidate_user_id]
+ ):
+ return candidate_user_id, self.task_store[candidate_user_id][task_id]
+ return None
+
+ async def retry_failed_files(
+ self,
+ user_id: str,
+ task_id: str,
+ *,
+ file_paths: list[str] | None = None,
+ retryable_only: bool = True,
+ ) -> dict | None:
+ """Re-queue failed files for ingestion when their source paths still exist.
+
+ Only files classified as RETRYABLE are retried when *retryable_only* is
+ True (the default). When *file_paths* is set, only those task paths are
+ considered; paths missing from the task or not in a failed state are
+ reported in *skipped*. This reuses the task's original processor — it
+ does not accept new uploads from the client.
+
+ Connector tasks often use provider IDs (not local absolute paths) as
+ ``file_path`` keys. For those non-absolute identifiers, skip local
+ filesystem existence checks and let the connector processor re-fetch.
+ """
+ resolved = self._resolve_upload_task_store(user_id, task_id)
+ if resolved is None:
+ return None
+
+ store_user_id, upload_task = resolved
+
+ paths_to_retry: list[str] = []
+ skipped: list[dict] = []
+ requested_paths = set(file_paths) if file_paths is not None else None
+
+ # Keep status checks, candidate selection, and state transitions inside
+ # one lock to avoid concurrent retry requests enqueueing duplicates.
+ async with self._get_task_lock(task_id):
+ processor = upload_task.processor
+ if upload_task.status == TaskStatus.RUNNING:
+ return {
+ "error": "task_in_progress",
+ "message": "Task is still running",
+ "task_id": task_id,
+ }
+
+ if processor is None:
+ return {
+ "error": "no_processor",
+ "message": "Cannot retry: task processor is no longer available",
+ "task_id": task_id,
+ }
+
+ if requested_paths is not None:
+ for path in requested_paths:
+ file_task = upload_task.file_tasks.get(path)
+ if file_task is None:
+ skipped.append({"file_path": path, "reason": "file_not_in_task"})
+ elif file_task.status != TaskStatus.FAILED:
+ skipped.append(
+ {
+ "file_path": path,
+ "filename": file_task.filename,
+ "reason": "not_failed",
+ }
+ )
+
+ # Build retry candidates before mutating shared task/file state.
+ retry_candidates: list[tuple[str, FileTask]] = []
+ for file_path, file_task in list(upload_task.file_tasks.items()):
+ if requested_paths is not None and file_path not in requested_paths:
+ continue
+ if file_task.status != TaskStatus.FAILED:
+ continue
+
+ if retryable_only:
+ metadata = self._infer_failure_metadata(file_task)
+ if not metadata or metadata.get("actionable_by") != "RETRYABLE":
+ skipped.append(
+ {
+ "file_path": file_path,
+ "filename": file_task.filename,
+ "reason": "not_retryable",
+ }
+ )
+ continue
+
+ # Only enforce local source-file existence for absolute paths.
+ # Connector-backed tasks typically store remote IDs as file_path.
+ if os.path.isabs(file_path) and not os.path.isfile(file_path):
+ skipped.append(
+ {
+ "file_path": file_path,
+ "filename": file_task.filename,
+ "reason": "source_file_missing",
+ }
+ )
+ continue
+
+ retry_candidates.append((file_path, file_task))
+
+ now = time.time()
+ for file_path, file_task in retry_candidates:
+ if upload_task.failed_files > 0:
+ upload_task.failed_files -= 1
+ if upload_task.processed_files > 0:
+ upload_task.processed_files -= 1
+
+ file_task.status = TaskStatus.PENDING
+ file_task.error = None
+ file_task.result = None
+ file_task.retry_count += 1
+ file_task.docling_task_id = None
+ # Connector tasks use remote IDs as file_path and ingest via Langflow.
+ if os.path.isabs(file_path):
+ file_task.docling_status = DoclingPhaseStatus.PENDING
+ file_task.phase = IngestionPhase.DOCLING
+ else:
+ file_task.docling_status = DoclingPhaseStatus.PENDING
+ file_task.phase = IngestionPhase.LANGFLOW
+ file_task.updated_at = now
+ paths_to_retry.append(file_path)
+
+ if paths_to_retry:
+ upload_task.status = TaskStatus.RUNNING
+ upload_task.updated_at = now
+
+ if not paths_to_retry:
+ return {
+ "task_id": task_id,
+ "retried": 0,
+ "skipped": skipped,
+ "status": "no_op",
+ "message": "No retryable files with available source data",
+ }
+
+ background_task = asyncio.create_task(
+ self.background_custom_processor(store_user_id, task_id, paths_to_retry, processor)
+ )
+ upload_task.background_task = background_task
+ self.background_tasks.add(background_task)
+
+ def _clear_retry_background_task(done_task: asyncio.Task) -> None:
+ self.background_tasks.discard(done_task)
+ if upload_task.background_task is done_task:
+ upload_task.background_task = None
+
+ background_task.add_done_callback(_clear_retry_background_task)
+
+ return {
+ "task_id": task_id,
+ "retried": len(paths_to_retry),
+ "skipped": skipped,
+ "status": "accepted",
+ }
+
def _serialize_file_task(self, file_task: FileTask) -> dict:
"""Serialize a FileTask to the standard dict shape."""
return {
@@ -613,35 +879,51 @@ class TaskService:
actionable_by when the failure can be classified, or None when the cause
is unknown and no fields should be emitted.
- Priority order: docling_status enum first (stable), error string patterns
- second (fallback for edge cases like polling timeout).
+ Priority order: transient / retryable docling outcomes (expired, polling
+ timeout) before generic docling FAILED, which indicates conversion failure.
"""
docling_status = file_task.docling_status
phase = file_task.phase
error = file_task.error or ""
- if docling_status == DoclingPhaseStatus.FAILED:
+ if docling_status == DoclingPhaseStatus.EXPIRED:
return {
"component": "docling",
"failure_phase": "parsing",
"user_facing_message": (
- "The file could not be processed into readable document content."
+ "The document processing result could not be found. "
+ "The task may have expired. Please retry ingestion."
),
- "actionable_by": "USER_ACTIONABLE",
+ "actionable_by": "RETRYABLE",
}
- if docling_status == DoclingPhaseStatus.EXPIRED:
+ if _is_non_retryable_file_error(error):
+ if phase == IngestionPhase.LANGFLOW:
+ component = "langflow"
+ failure_phase = "unknown"
+ else:
+ component = "docling"
+ failure_phase = "parsing"
return {
- "component": "docling",
- "failure_phase": "parsing",
+ "component": component,
+ "failure_phase": failure_phase,
"user_facing_message": (
- "The document processing result could not be found. "
- "The task may have expired. Please retry ingestion."
+ "The file appears corrupted or invalid and cannot be processed. "
+ "Upload a valid file."
),
+ "actionable_by": "USER_ACTIONABLE",
+ }
+
+ if phase == IngestionPhase.DOCLING and _is_docling_transient_error(error):
+ langflow_transport = _is_langflow_transport_failure(error)
+ return {
+ "component": "langflow" if langflow_transport else "docling",
+ "failure_phase": "unknown" if langflow_transport else "parsing",
+ "user_facing_message": _transient_connectivity_user_message(error),
"actionable_by": "RETRYABLE",
}
- if phase == IngestionPhase.DOCLING and "Docling conversion did not complete" in error:
+ if phase == IngestionPhase.DOCLING and docling_status == DoclingPhaseStatus.PROCESSING:
return {
"component": "docling",
"failure_phase": "parsing",
@@ -649,12 +931,14 @@ class TaskService:
"actionable_by": "RETRYABLE",
}
- if phase == IngestionPhase.DOCLING and docling_status == DoclingPhaseStatus.PROCESSING:
+ if docling_status == DoclingPhaseStatus.FAILED:
return {
"component": "docling",
"failure_phase": "parsing",
- "user_facing_message": "Document processing timed out. Please retry ingestion.",
- "actionable_by": "RETRYABLE",
+ "user_facing_message": (
+ "The file could not be processed into readable document content."
+ ),
+ "actionable_by": "USER_ACTIONABLE",
}
if "already exists" in error:
@@ -665,7 +949,28 @@ class TaskService:
"actionable_by": "USER_ACTIONABLE",
}
+ if _is_transient_connectivity_error(error) or _is_langflow_transport_failure(error):
+ return {
+ "component": "langflow",
+ "failure_phase": "unknown",
+ "user_facing_message": _transient_connectivity_user_message(error),
+ "actionable_by": "RETRYABLE",
+ }
+
if phase == IngestionPhase.LANGFLOW:
+ error_lower = error.lower()
+ if any(
+ marker in error_lower
+ for marker in ("timeout", "timed out", "unavailable", "connection refused")
+ ):
+ return {
+ "component": "langflow",
+ "failure_phase": "unknown",
+ "user_facing_message": (
+ "Ingestion timed out or the service was unavailable. Please retry."
+ ),
+ "actionable_by": "RETRYABLE",
+ }
return {
"component": "langflow",
"failure_phase": "unknown",
diff --git a/src/utils/telemetry/message_id.py b/src/utils/telemetry/message_id.py
index 0a3b050a4..07121ad9a 100644
--- a/src/utils/telemetry/message_id.py
+++ b/src/utils/telemetry/message_id.py
@@ -149,6 +149,8 @@ class MessageId:
ORB_TASK_COMPLETE = "ORB_TASK_COMPLETE"
# Message: Task failed
ORB_TASK_FAILED = "ORB_TASK_FAILED"
+ # Message: Task retry requested
+ ORB_TASK_RETRIED = "ORB_TASK_RETRIED"
# Message: Task cancelled
ORB_TASK_CANCELLED = "ORB_TASK_CANCELLED"
# Message: Task cancellation failed
diff --git a/tests/unit/test_task_service_get_task_status2.py b/tests/unit/test_task_service_get_task_status2.py
index 01b54321b..8d7a4c082 100644
--- a/tests/unit/test_task_service_get_task_status2.py
+++ b/tests/unit/test_task_service_get_task_status2.py
@@ -87,6 +87,52 @@ class TestInferFailureMetadata:
assert meta["failure_phase"] == "parsing"
assert meta["actionable_by"] == "RETRYABLE"
+ def test_docling_polling_timeout_sets_failed_status(self, task_service):
+ """Backend polling marks TIMEOUT as docling_status=FAILED; still retryable."""
+ ft = _make_file_task(
+ phase=IngestionPhase.DOCLING,
+ docling_status=DoclingPhaseStatus.FAILED,
+ error=(
+ "Docling conversion did not complete (timeout): Docling polling timed out after 10s"
+ ),
+ )
+ meta = task_service._infer_failure_metadata(ft)
+ assert meta is not None
+ assert meta["actionable_by"] == "RETRYABLE"
+
+ def test_docling_conversion_failed_not_retryable(self, task_service):
+ """Permanent conversion failure (e.g. corrupt file) is not retryable."""
+ ft = _make_file_task(
+ phase=IngestionPhase.DOCLING,
+ docling_status=DoclingPhaseStatus.FAILED,
+ error=("Docling conversion did not complete (failed): Docling reported failure"),
+ )
+ meta = task_service._infer_failure_metadata(ft)
+ assert meta is not None
+ assert meta["actionable_by"] == "USER_ACTIONABLE"
+
+ def test_corrupt_docx_bad_zip_not_retryable(self, task_service):
+ ft = _make_file_task(
+ phase=IngestionPhase.DOCLING,
+ docling_status=DoclingPhaseStatus.FAILED,
+ error=(
+ "Docling conversion did not complete (failed): BadZipFile: File is not a zip file"
+ ),
+ )
+ meta = task_service._infer_failure_metadata(ft)
+ assert meta is not None
+ assert meta["actionable_by"] == "USER_ACTIONABLE"
+
+ def test_langflow_empty_content_not_retryable(self, task_service):
+ ft = _make_file_task(
+ phase=IngestionPhase.LANGFLOW,
+ docling_status=DoclingPhaseStatus.SUCCESS,
+ error="No text content could be extracted from document",
+ )
+ meta = task_service._infer_failure_metadata(ft)
+ assert meta is not None
+ assert meta["actionable_by"] == "USER_ACTIONABLE"
+
def test_docling_phase_still_processing(self, task_service):
ft = _make_file_task(
phase=IngestionPhase.DOCLING,
diff --git a/tests/unit/test_task_service_retry_failed_files.py b/tests/unit/test_task_service_retry_failed_files.py
new file mode 100644
index 000000000..811374efb
--- /dev/null
+++ b/tests/unit/test_task_service_retry_failed_files.py
@@ -0,0 +1,247 @@
+"""Unit tests for TaskService.retry_failed_files."""
+
+from unittest.mock import AsyncMock, Mock, patch
+
+import pytest
+
+from models.tasks import DoclingPhaseStatus, FileTask, IngestionPhase, TaskStatus, UploadTask
+from services.task_service import TaskService
+
+
+def task_service():
+ return TaskService(document_service=Mock(), ingestion_timeout=2)
+
+
+def _retryable_failed_file(
+ file_path: str = "/data/doc.pdf",
+ *,
+ error: str = "Docling conversion did not complete (timeout)",
+) -> FileTask:
+ ft = FileTask(file_path=file_path, filename="doc.pdf")
+ ft.status = TaskStatus.FAILED
+ ft.phase = IngestionPhase.DOCLING
+ ft.docling_status = DoclingPhaseStatus.FAILED
+ ft.error = error
+ return ft
+
+
+def _store_task(
+ task_service: TaskService,
+ user_id: str,
+ upload_task: UploadTask,
+) -> None:
+ task_service.task_store.setdefault(user_id, {})[upload_task.task_id] = upload_task
+
+
+async def test_retry_all_failed_retryable_files(task_service):
+ processor = Mock()
+ ft_a = _retryable_failed_file("/data/a.pdf")
+ ft_b = _retryable_failed_file("/data/b.pdf")
+ task = UploadTask(
+ task_id="task-1",
+ total_files=2,
+ file_tasks={"/data/a.pdf": ft_a, "/data/b.pdf": ft_b},
+ status=TaskStatus.FAILED,
+ failed_files=2,
+ processor=processor,
+ )
+ _store_task(task_service, "user1", task)
+
+ with (
+ patch("os.path.isfile", return_value=True),
+ patch.object(
+ task_service,
+ "background_custom_processor",
+ new_callable=AsyncMock,
+ ) as mock_bg,
+ patch("asyncio.create_task", return_value=Mock()),
+ ):
+ result = await task_service.retry_failed_files("user1", "task-1")
+
+ assert result is not None
+ assert result["retried"] == 2
+ assert result["status"] == "accepted"
+ assert ft_a.status == TaskStatus.PENDING
+ assert ft_b.status == TaskStatus.PENDING
+ mock_bg.assert_called_once()
+ assert set(mock_bg.call_args[0][2]) == {"/data/a.pdf", "/data/b.pdf"}
+
+
+async def test_retry_subset_by_file_paths(task_service):
+ processor = Mock()
+ ft_a = _retryable_failed_file("/data/a.pdf")
+ ft_b = _retryable_failed_file("/data/b.pdf")
+ task = UploadTask(
+ task_id="task-1",
+ total_files=2,
+ file_tasks={"/data/a.pdf": ft_a, "/data/b.pdf": ft_b},
+ status=TaskStatus.FAILED,
+ failed_files=2,
+ processor=processor,
+ )
+ _store_task(task_service, "user1", task)
+
+ with (
+ patch("os.path.isfile", return_value=True),
+ patch.object(
+ task_service,
+ "background_custom_processor",
+ new_callable=AsyncMock,
+ ) as mock_bg,
+ patch("asyncio.create_task", return_value=Mock()),
+ ):
+ result = await task_service.retry_failed_files(
+ "user1",
+ "task-1",
+ file_paths=["/data/a.pdf"],
+ )
+
+ assert result is not None
+ assert result["retried"] == 1
+ assert ft_a.status == TaskStatus.PENDING
+ assert ft_b.status == TaskStatus.FAILED
+ mock_bg.assert_called_once()
+ assert mock_bg.call_args[0][2] == ["/data/a.pdf"]
+
+
+async def test_retry_unknown_path_is_skipped(task_service):
+ processor = Mock()
+ ft_a = _retryable_failed_file("/data/a.pdf")
+ task = UploadTask(
+ task_id="task-1",
+ total_files=1,
+ file_tasks={"/data/a.pdf": ft_a},
+ status=TaskStatus.FAILED,
+ failed_files=1,
+ processor=processor,
+ )
+ _store_task(task_service, "user1", task)
+
+ with patch("os.path.isfile", return_value=True):
+ result = await task_service.retry_failed_files(
+ "user1",
+ "task-1",
+ file_paths=["/data/missing.pdf"],
+ )
+
+ assert result is not None
+ assert result["retried"] == 0
+ assert result["status"] == "no_op"
+ assert result["skipped"] == [{"file_path": "/data/missing.pdf", "reason": "file_not_in_task"}]
+ assert ft_a.status == TaskStatus.FAILED
+
+
+async def test_retry_connector_connectivity_error_is_retryable(task_service):
+ processor = Mock()
+ ft = FileTask(file_path="/data/connector.pdf", filename="connector.pdf")
+ ft.status = TaskStatus.FAILED
+ ft.phase = IngestionPhase.DOCLING
+ ft.docling_status = DoclingPhaseStatus.PENDING
+ ft.error = "All connection attempts failed"
+ task = UploadTask(
+ task_id="task-connector",
+ total_files=1,
+ file_tasks={"/data/connector.pdf": ft},
+ status=TaskStatus.FAILED,
+ failed_files=1,
+ processor=processor,
+ )
+ _store_task(task_service, "user1", task)
+
+ with (
+ patch("os.path.isfile", return_value=True),
+ patch.object(
+ task_service,
+ "background_custom_processor",
+ new_callable=AsyncMock,
+ ) as mock_bg,
+ patch("asyncio.create_task", return_value=Mock()),
+ ):
+ result = await task_service.retry_failed_files("user1", "task-connector")
+
+ assert result is not None
+ assert result["retried"] == 1
+ assert result["status"] == "accepted"
+ assert ft.status == TaskStatus.PENDING
+ mock_bg.assert_called_once()
+
+
+async def test_langflow_disconnect_error_is_retryable(task_service):
+ processor = Mock()
+ ft = FileTask(file_path="google-drive-file-id", filename="statement.pdf")
+ ft.status = TaskStatus.FAILED
+ ft.phase = IngestionPhase.DOCLING
+ ft.docling_status = DoclingPhaseStatus.PENDING
+ ft.error = "Server disconnected without sending a response."
+ task = UploadTask(
+ task_id="task-langflow-disconnect",
+ total_files=1,
+ file_tasks={"google-drive-file-id": ft},
+ status=TaskStatus.FAILED,
+ failed_files=1,
+ processor=processor,
+ )
+ _store_task(task_service, "user1", task)
+
+ metadata = task_service._infer_failure_metadata(ft)
+ assert metadata is not None
+ assert metadata["actionable_by"] == "RETRYABLE"
+ assert metadata["component"] == "langflow"
+
+ with (
+ patch("os.path.isfile", return_value=False),
+ patch.object(
+ task_service,
+ "background_custom_processor",
+ new_callable=AsyncMock,
+ ) as mock_bg,
+ patch("asyncio.create_task", return_value=Mock()),
+ ):
+ result = await task_service.retry_failed_files("user1", "task-langflow-disconnect")
+
+ assert result is not None
+ assert result["retried"] == 1
+ assert ft.phase == IngestionPhase.LANGFLOW
+ mock_bg.assert_called_once()
+
+
+async def test_retry_connector_id_path_does_not_require_local_file(task_service):
+ processor = Mock()
+ ft = FileTask(file_path="remote-file-id-123", filename="connector.pdf")
+ ft.status = TaskStatus.FAILED
+ ft.phase = IngestionPhase.DOCLING
+ ft.docling_status = DoclingPhaseStatus.PENDING
+ ft.error = "All connection attempts failed"
+ task = UploadTask(
+ task_id="task-connector-id",
+ total_files=1,
+ file_tasks={"remote-file-id-123": ft},
+ status=TaskStatus.FAILED,
+ failed_files=1,
+ processor=processor,
+ )
+ _store_task(task_service, "user1", task)
+
+ with (
+ patch("os.path.isfile", return_value=False),
+ patch.object(
+ task_service,
+ "background_custom_processor",
+ new_callable=AsyncMock,
+ ) as mock_bg,
+ patch("asyncio.create_task", return_value=Mock()),
+ ):
+ result = await task_service.retry_failed_files("user1", "task-connector-id")
+
+ assert result is not None
+ assert result["retried"] == 1
+ assert result["status"] == "accepted"
+ assert ft.status == TaskStatus.PENDING
+ mock_bg.assert_called_once()